From 57b83d61c5c9086ee9e09333dec77cdd818141be Mon Sep 17 00:00:00 2001 From: MartinSiran Date: Thu, 6 Jun 2024 09:46:44 +0200 Subject: [PATCH 01/12] [NAE-1788] Validation register backend - WIP add ValidationRunner & ValidationDelegate - implement ValidationRegistry with ValidationService - run validatioins on setDataField and finishTask - add validation process --- .../logic/action/ActionDelegate.groovy | 4 + .../logic/action/ValidationDelegate.groovy | 8 + .../logic/action/ValidationRunner.groovy | 53 +++ .../engine/startup/RunnerController.groovy | 1 + .../engine/startup/ValidationRunner.groovy | 23 + .../validations/ValidationRegistry.java | 25 ++ .../engine/validations/ValidationService.java | 57 +++ .../interfaces/IValidationService.java | 20 + .../engine/workflow/service/DataService.java | 10 +- .../engine/workflow/service/TaskService.java | 6 +- .../validations/validation.xml | 408 ++++++++++++++++++ 11 files changed, 611 insertions(+), 4 deletions(-) create mode 100644 src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationDelegate.groovy create mode 100644 src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationRunner.groovy create mode 100644 src/main/groovy/com/netgrif/application/engine/startup/ValidationRunner.groovy create mode 100644 src/main/java/com/netgrif/application/engine/validations/ValidationRegistry.java create mode 100644 src/main/java/com/netgrif/application/engine/validations/ValidationService.java create mode 100644 src/main/java/com/netgrif/application/engine/validations/interfaces/IValidationService.java create mode 100644 src/main/resources/petriNets/engine-processes/validations/validation.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 f00157c40fa..7f66d94b387 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 @@ -35,6 +35,7 @@ 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.utils.FullPageRequest +import com.netgrif.application.engine.validations.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.caseoutcomes.CreateCaseEventOutcome @@ -177,6 +178,9 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { @Autowired PublicViewProperties publicViewProperties + @Autowired + IValidationService validationService + FrontendActionOutcome Frontend /** diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationDelegate.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationDelegate.groovy new file mode 100644 index 00000000000..68f9570a61d --- /dev/null +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationDelegate.groovy @@ -0,0 +1,8 @@ +package com.netgrif.application.engine.petrinet.domain.dataset.logic.action + +import groovy.util.logging.Slf4j + +@Slf4j +class ValidationDelegate { + +} diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationRunner.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationRunner.groovy new file mode 100644 index 00000000000..3b8562439f4 --- /dev/null +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationRunner.groovy @@ -0,0 +1,53 @@ +package com.netgrif.application.engine.petrinet.domain.dataset.logic.action + + +import com.netgrif.application.engine.petrinet.domain.dataset.Field +import com.netgrif.application.engine.petrinet.domain.dataset.Validation +import com.netgrif.application.engine.validations.ValidationRegistry +import com.netgrif.application.engine.validations.ValidationService +import com.netgrif.application.engine.workflow.domain.Case +import groovy.util.logging.Slf4j +import org.springframework.beans.factory.annotation.Autowired +import org.springframework.beans.factory.annotation.Lookup +import org.springframework.stereotype.Component + +@Slf4j +@Component +abstract class ValidationRunner { + + @Lookup("validationDelegate") + abstract ValidationDelegate getValidationDelegate() + + @Autowired + private ValidationRegistry validationRegistry; + + @Autowired + private ValidationService service + + void run(Case useCase, List validations) { + if (validations) { + log.debug("Validations: ${validations.collect {it.rule }}") + validations.each { Validation validation -> + String validationName, validationArgs + (validationName, validationArgs) = validation.rule.trim().split(" ") + Closure code = getValidationCode(validationName) + initCode(code.delegate, useCase) + if (!code(*validationArgs.split(","))) { + throw new IllegalArgumentException(validation.message.toString()) + } + } + } + } + + protected Closure getValidationCode(String validationName) { + Closure code = validationRegistry.getValidation(validationName) + return code.rehydrate(getValidationDelegate(), code.owner, code.thisObject) + } + + protected static void initCode(def delegate, Case useCase) { + delegate.metaClass.useCase = useCase + useCase.dataSet.fields.values().forEach { Field field -> + delegate.metaClass."$field.importId" = field + } + } +} diff --git a/src/main/groovy/com/netgrif/application/engine/startup/RunnerController.groovy b/src/main/groovy/com/netgrif/application/engine/startup/RunnerController.groovy index d4ee2174a85..5b90e32db4d 100644 --- a/src/main/groovy/com/netgrif/application/engine/startup/RunnerController.groovy +++ b/src/main/groovy/com/netgrif/application/engine/startup/RunnerController.groovy @@ -27,6 +27,7 @@ class RunnerController { MailRunner, DemoRunner, QuartzSchedulerRunner, + ValidationRunner, FinisherRunnerSuperCreator, FinisherRunner, ] diff --git a/src/main/groovy/com/netgrif/application/engine/startup/ValidationRunner.groovy b/src/main/groovy/com/netgrif/application/engine/startup/ValidationRunner.groovy new file mode 100644 index 00000000000..9428cbae92d --- /dev/null +++ b/src/main/groovy/com/netgrif/application/engine/startup/ValidationRunner.groovy @@ -0,0 +1,23 @@ +package com.netgrif.application.engine.startup + +import com.netgrif.application.engine.validations.interfaces.IValidationService +import groovy.transform.CompileStatic +import groovy.util.logging.Slf4j +import org.springframework.beans.factory.annotation.Autowired +import org.springframework.context.annotation.Profile +import org.springframework.stereotype.Component + +@Slf4j +@Component +@Profile("!test") +@CompileStatic +class ValidationRunner extends AbstractOrderedCommandLineRunner { + + @Autowired + private IValidationService service + + @Override + void run(String... strings) throws Exception { + log.info("Starting validation runner") + } +} \ No newline at end of file diff --git a/src/main/java/com/netgrif/application/engine/validations/ValidationRegistry.java b/src/main/java/com/netgrif/application/engine/validations/ValidationRegistry.java new file mode 100644 index 00000000000..e75ad561ca1 --- /dev/null +++ b/src/main/java/com/netgrif/application/engine/validations/ValidationRegistry.java @@ -0,0 +1,25 @@ +package com.netgrif.application.engine.validations; + +import groovy.lang.Closure; +import org.springframework.stereotype.Component; + +import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; + +@Component +public final class ValidationRegistry { + + private final Map> validationsMap = new ConcurrentHashMap<>(); + + public Closure addValidation(String name, Closure closure) { + return validationsMap.put(name, closure); + } + + public Closure getValidation(String name) { + return validationsMap.get(name); + } + + public Closure removeValidation(String name) { + return validationsMap.remove(name); + } +} diff --git a/src/main/java/com/netgrif/application/engine/validations/ValidationService.java b/src/main/java/com/netgrif/application/engine/validations/ValidationService.java new file mode 100644 index 00000000000..d91871c56c2 --- /dev/null +++ b/src/main/java/com/netgrif/application/engine/validations/ValidationService.java @@ -0,0 +1,57 @@ +package com.netgrif.application.engine.validations; + +import com.netgrif.application.engine.event.IGroovyShellFactory; +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.ValidationRunner; +import com.netgrif.application.engine.validations.interfaces.IValidationService; +import com.netgrif.application.engine.workflow.domain.Case; +import groovy.lang.Closure; +import lombok.extern.slf4j.Slf4j; +import org.codehaus.groovy.control.CompilationFailedException; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +@Service +@Slf4j +public class ValidationService implements IValidationService { + + private final ValidationRegistry validationRegistry; + + private final ValidationRunner validationRunner; + + private final IGroovyShellFactory shellFactory; + + @Autowired + public ValidationService(ValidationRegistry validationRegistry, ValidationRunner validationRunner, IGroovyShellFactory shellFactory) { + this.validationRegistry = validationRegistry; + this.validationRunner = validationRunner; + this.shellFactory = shellFactory; + } + + @Override + public void validateTransition(Case useCase, Transition transition) { + transition.getDataSet().values().forEach(dataRef -> validationRunner.run(useCase, dataRef.getField().getValidations())); + } + + @Override + public void validateField(Case useCase, Field field) { + validationRunner.run(useCase, field.getValidations()); + } + + @Override + public void registerValidation(String name, String definition) throws ClassCastException, CompilationFailedException { + Closure code = (Closure) this.shellFactory.getGroovyShell().evaluate("{" + definition + "}"); + validationRegistry.addValidation(name, code); + } + + @Override + public Closure getValidation(String name) { + return validationRegistry.getValidation(name); + } + + @Override + public void unregisterValidation(String name) { + validationRegistry.removeValidation(name); + } +} diff --git a/src/main/java/com/netgrif/application/engine/validations/interfaces/IValidationService.java b/src/main/java/com/netgrif/application/engine/validations/interfaces/IValidationService.java new file mode 100644 index 00000000000..d8528191782 --- /dev/null +++ b/src/main/java/com/netgrif/application/engine/validations/interfaces/IValidationService.java @@ -0,0 +1,20 @@ +package com.netgrif.application.engine.validations.interfaces; + +import com.netgrif.application.engine.petrinet.domain.Transition; +import com.netgrif.application.engine.petrinet.domain.dataset.Field; +import com.netgrif.application.engine.workflow.domain.Case; +import groovy.lang.Closure; +import org.codehaus.groovy.control.CompilationFailedException; + +public interface IValidationService { + + void validateTransition(Case useCase, Transition transition); + + void validateField(Case useCase, Field field); + + void registerValidation(String name, String definition) throws ClassCastException, CompilationFailedException; + + Closure getValidation(String name); + + void unregisterValidation(String name); +} 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 fe5e93bf263..55825eb35d7 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 @@ -89,6 +89,9 @@ public class DataService implements IDataService { @Autowired protected IValidationService validation; + @Autowired + protected com.netgrif.application.engine.validations.interfaces.IValidationService validationService; + @Value("${nae.image.preview.scaling.px:400}") protected int imageScale; @@ -227,9 +230,10 @@ public SetDataEventOutcome setDataField(Task task, String fieldId, Field newD setOutcomeMessage(task, useCase, outcome, fieldId, field, DataEventType.SET); } useCase.getDataSet().get(fieldId).applyChanges(newDataField); - if (validationEnable) { - validation.valid(useCase.getDataSet().get(fieldId)); - } + validationService.validateField(useCase, useCase.getDataSet().get(fieldId)); +// if (validationEnable) { +// validation.valid(useCase.getDataSet().get(fieldId)); +// } useCase = workflowService.save(useCase); outcome.addChangedField(fieldId, newDataField); historyService.save(new SetDataEventLog(task, useCase, EventPhase.EXECUTION, DataSet.of(fieldId, newDataField), 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 b8045e2533c..079d7671670 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 @@ -115,6 +115,9 @@ public class TaskService implements ITaskService { @Autowired protected IValidationService validation; + @Autowired + protected com.netgrif.application.engine.validations.interfaces.IValidationService validationService; + @Autowired public void setElasticTaskService(IElasticTaskService elasticTaskService) { this.elasticTaskService = elasticTaskService; @@ -273,7 +276,8 @@ public FinishTaskEventOutcome finishTask(Task task, IUser user, Map outcomes = new ArrayList<>(eventService.runActions(transition.getPreFinishActions(), workflowService.findOne(task.getCaseId()), task, transition, params)); useCase = workflowService.findOne(task.getCaseId()); task = findOne(task.getStringId()); diff --git a/src/main/resources/petriNets/engine-processes/validations/validation.xml b/src/main/resources/petriNets/engine-processes/validations/validation.xml new file mode 100644 index 00000000000..dcee591cd30 --- /dev/null +++ b/src/main/resources/petriNets/engine-processes/validations/validation.xml @@ -0,0 +1,408 @@ + + validation + 1.0.0 + VAL + Validation + home + true + false + false + + + system + + true + true + true + + + + admin + + false + false + true + + + + default + + false + false + true + + + + system + System + + + admin + Admin + + + + name + Name + + + validation_definition_groovy + Validation definition - Groovy + + textarea + + + + validation_definition_javascript + Validation definition - JavaScript + + textarea + + + + version + Version + + + active + Is active + false + + + + Meno + Definícia validácie - Groovy + Definícia validácie - JavaScript + Verzia + Je aktívny + Detail + Aktivovať + Deaktivovať + + + Name + Validierungsdefinition - Groovy + Validierungsdefinition - JavaScript + Ausführung + Ist aktiv + Detail + Aktivieren + Deaktivieren + + + + init + 300 + 300 + + + init_0 + 4 + grid + + name + + editable + + + 0 + 0 + 1 + 2 + + outline + + + + validation_definition_groovy + + editable + + + 0 + 1 + 2 + 4 + + outline + + + + validation_definition_javascript + + editable + + + 0 + 3 + 2 + 4 + + outline + + + + version + + editable + + + 2 + 0 + 1 + 2 + + outline + + + + + init_assign + + + init_finish + + + init_cancel + + + init_delegate + + + + activate + 580 + 220 + + + admin + + true + true + true + true + + + + onFinish_activate + + + name: f.name, + validation_definition_groovy: f.validation_definition_groovy, + active: f.active; + + validationService.registerValidation(name.value, validation_definition_groovy.value) + change active value { true } + + + + + + deactivate + 580 + 380 + + + admin + + true + true + true + true + + + + onFinish_deactivate + + + name: f.name, + active: f.active; + + validationService.unregisterValidation(name.value) + change active value { false } + + + + + + detail + 300 + 60 + + + detail_0 + 4 + grid + + name + + visible + + + 0 + 0 + 1 + 2 + + outline + + + + active + + visible + + + 2 + 1 + 1 + 2 + + outline + + + + version + + visible + + + 2 + 0 + 1 + 2 + + outline + + + + validation_definition_javascript + + editable + + + 0 + 4 + 2 + 4 + + outline + + + + validation_definition_groovy + + editable + + + 0 + 2 + 2 + 4 + + outline + + + + + detail_assign + + + detail_finish + + + detail_cancel + + + detail_delegate + + + + p1 + 180 + 300 + + + p2 + 420 + 300 + + 0 + false + + + p3 + 740 + 300 + + 0 + false + + + p5 + 300 + 180 + + 0 + false + + + a1 + regular + p1 + init + 1 + + + a2 + regular + init + p5 + 1 + + + a3 + read + p5 + detail + 1 + + + a5 + regular + init + p2 + 1 + + + a6 + regular + p2 + activate + 1 + + + a7 + regular + activate + p3 + 1 + + + a8 + regular + p3 + deactivate + 1 + + + a9 + regular + deactivate + p2 + 1 + + \ No newline at end of file From a34f7bfabff1f4ab7796e904fa228dcb6a82be93 Mon Sep 17 00:00:00 2001 From: MartinSiran Date: Thu, 6 Jun 2024 11:49:32 +0200 Subject: [PATCH 02/12] [NAE-1788] Validation register backend - implement ValidationRunner on startup --- .../engine/startup/ValidationRunner.groovy | 27 ++++++++++++++++++- .../validations/validation.xml | 3 +++ 2 files changed, 29 insertions(+), 1 deletion(-) diff --git a/src/main/groovy/com/netgrif/application/engine/startup/ValidationRunner.groovy b/src/main/groovy/com/netgrif/application/engine/startup/ValidationRunner.groovy index 9428cbae92d..c5f54581dfd 100644 --- a/src/main/groovy/com/netgrif/application/engine/startup/ValidationRunner.groovy +++ b/src/main/groovy/com/netgrif/application/engine/startup/ValidationRunner.groovy @@ -1,10 +1,17 @@ package com.netgrif.application.engine.startup + +import com.netgrif.application.engine.auth.service.interfaces.IUserService +import com.netgrif.application.engine.elastic.service.interfaces.IElasticCaseService +import com.netgrif.application.engine.elastic.web.requestbodies.CaseSearchRequest import com.netgrif.application.engine.validations.interfaces.IValidationService +import com.netgrif.application.engine.workflow.domain.Case import groovy.transform.CompileStatic import groovy.util.logging.Slf4j import org.springframework.beans.factory.annotation.Autowired import org.springframework.context.annotation.Profile +import org.springframework.context.i18n.LocaleContextHolder +import org.springframework.data.domain.PageRequest import org.springframework.stereotype.Component @Slf4j @@ -13,11 +20,29 @@ import org.springframework.stereotype.Component @CompileStatic class ValidationRunner extends AbstractOrderedCommandLineRunner { + private static final int PAGE_SIZE = 100 + + @Autowired + private IUserService userService + + @Autowired + private IValidationService validationService + @Autowired - private IValidationService service + private IElasticCaseService elasticCaseService @Override void run(String... strings) throws Exception { log.info("Starting validation runner") + CaseSearchRequest request = new CaseSearchRequest() + request.query = "processIdentifier:validation AND dataSet.is_active.value:true" + int pageCount = (int) (elasticCaseService.count([request], userService.loggedOrSystem.transformToLoggedUser(), LocaleContextHolder.locale, false) / PAGE_SIZE) + pageCount.times { + elasticCaseService.search([request], userService.loggedOrSystem.transformToLoggedUser(), PageRequest.of(it, PAGE_SIZE), LocaleContextHolder.locale, false) + .getContent() + .each { Case validationCase -> + validationService.registerValidation(validationCase.getDataSet().get("name").getValue() as String, validationCase.getDataSet().get("validation_definition_groovy").getValue() as String) + } + } } } \ No newline at end of file diff --git a/src/main/resources/petriNets/engine-processes/validations/validation.xml b/src/main/resources/petriNets/engine-processes/validations/validation.xml index dcee591cd30..ac6335aa7e0 100644 --- a/src/main/resources/petriNets/engine-processes/validations/validation.xml +++ b/src/main/resources/petriNets/engine-processes/validations/validation.xml @@ -103,6 +103,7 @@ name editable + required 0 @@ -117,6 +118,7 @@ validation_definition_groovy editable + required 0 @@ -293,6 +295,7 @@ validation_definition_groovy editable + required 0 From 5f7f0e037011deaf3ced9240829b44d418599c07 Mon Sep 17 00:00:00 2001 From: MartinSiran Date: Tue, 11 Jun 2024 17:55:26 +0200 Subject: [PATCH 03/12] [NAE-1788] Validation register backend - rename validation runner to validation executioner due to compilation errors - update executioner and service and its method calls - implement an example test scenario - remove original validations package, comment out original validations tests --- .../logic/action/ValidationExecutioner.groovy | 58 + .../logic/action/ValidationRunner.groovy | 53 - .../engine/startup/ValidationRunner.groovy | 28 +- .../domain/ValidationDataInput.groovy | 24 - .../models/AbstractFieldValidation.groovy | 14 - .../models/BooleanFieldValidation.groovy | 17 - .../models/DateFieldValidation.groovy | 122 - .../models/DateTimeFieldValidation.groovy | 122 - .../models/EnumerationFieldValidation.groovy | 17 - .../models/I18nFieldValidation.groovy | 17 - .../models/NumberFieldValidation.groovy | 93 - .../models/TextFieldValidation.groovy | 60 - .../service/ValidationService.groovy | 75 - .../interfaces/IValidationService.groovy | 8 - .../PrototypesConfiguration.java | 7 + .../validations/ValidationRegistry.java | 6 + .../engine/validations/ValidationService.java | 16 +- .../engine/workflow/service/DataService.java | 16 +- .../engine/workflow/service/TaskService.java | 8 +- .../validations/validation.xml | 4 +- .../application/engine/TestHelper.groovy | 3 + .../BooleanFieldValidationTest.groovy | 108 +- .../NumberFieldValidationTest.groovy | 136 +- .../validation/TextFieldValidationTest.groovy | 58 +- .../engine/validation/ValidationTest.groovy | 2018 ++++++++--------- .../validation/ValidationTestDynamic.groovy | 118 + .../petriNets/validation/valid_text.xml | 29 + 27 files changed, 1419 insertions(+), 1816 deletions(-) create mode 100644 src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy delete mode 100644 src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationRunner.groovy delete mode 100644 src/main/groovy/com/netgrif/application/engine/validation/domain/ValidationDataInput.groovy delete mode 100644 src/main/groovy/com/netgrif/application/engine/validation/models/AbstractFieldValidation.groovy delete mode 100644 src/main/groovy/com/netgrif/application/engine/validation/models/BooleanFieldValidation.groovy delete mode 100644 src/main/groovy/com/netgrif/application/engine/validation/models/DateFieldValidation.groovy delete mode 100644 src/main/groovy/com/netgrif/application/engine/validation/models/DateTimeFieldValidation.groovy delete mode 100644 src/main/groovy/com/netgrif/application/engine/validation/models/EnumerationFieldValidation.groovy delete mode 100644 src/main/groovy/com/netgrif/application/engine/validation/models/I18nFieldValidation.groovy delete mode 100644 src/main/groovy/com/netgrif/application/engine/validation/models/NumberFieldValidation.groovy delete mode 100644 src/main/groovy/com/netgrif/application/engine/validation/models/TextFieldValidation.groovy delete mode 100644 src/main/groovy/com/netgrif/application/engine/validation/service/ValidationService.groovy delete mode 100644 src/main/groovy/com/netgrif/application/engine/validation/service/interfaces/IValidationService.groovy create mode 100644 src/test/groovy/com/netgrif/application/engine/validation/ValidationTestDynamic.groovy diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy new file mode 100644 index 00000000000..a6157996a72 --- /dev/null +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy @@ -0,0 +1,58 @@ +package com.netgrif.application.engine.petrinet.domain.dataset.logic.action + +import com.netgrif.application.engine.event.IGroovyShellFactory +import com.netgrif.application.engine.petrinet.domain.dataset.Field +import com.netgrif.application.engine.petrinet.domain.dataset.Validation +import com.netgrif.application.engine.validations.ValidationRegistry +import com.netgrif.application.engine.workflow.domain.Case +import groovy.util.logging.Slf4j +import org.springframework.beans.factory.annotation.Autowired +import org.springframework.beans.factory.annotation.Lookup +import org.springframework.stereotype.Component + +@Slf4j +@Component +abstract class ValidationExecutioner { + + @Lookup("validationDelegate") + abstract ValidationDelegate getValidationDelegate() + + @Autowired + private ValidationRegistry registry; + + @Autowired + private IGroovyShellFactory shellFactory + + void run(Case useCase, Field field, List validations) { + if (validations) { + log.info("Validations: ${validations.collect {it.rule }}") + + def delegate = getValidationDelegate() + + initCode(delegate, useCase, field, this.registry.getValidationNames()) + for (Validation validation : validations) { + Closure code = (Closure) this.shellFactory.getGroovyShell().evaluate("{ -> " + validation.rule + "}") + code = code.rehydrate(delegate, code.owner, code.thisObject) + if (!code()) { + throw new IllegalArgumentException(validation.message.toString()) + } + } + } + } + + protected Closure getValidationCode(String validationName, Field thisField) { + Closure code = this.registry.getValidation(validationName) + code.delegate.metaClass.thisField = thisField + return code.rehydrate(code.delegate, code.owner, code.thisObject) + } + + protected void initCode(def delegate, Case useCase, Field thisField, List validationNames) { + delegate.metaClass.useCase = useCase + useCase.dataSet.fields.values().forEach { Field field -> + delegate.metaClass."$field.importId" = field + } + validationNames.forEach { validationName -> + delegate.metaClass."$validationName" = getValidationCode(validationName, thisField) + } + } +} diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationRunner.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationRunner.groovy deleted file mode 100644 index 3b8562439f4..00000000000 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationRunner.groovy +++ /dev/null @@ -1,53 +0,0 @@ -package com.netgrif.application.engine.petrinet.domain.dataset.logic.action - - -import com.netgrif.application.engine.petrinet.domain.dataset.Field -import com.netgrif.application.engine.petrinet.domain.dataset.Validation -import com.netgrif.application.engine.validations.ValidationRegistry -import com.netgrif.application.engine.validations.ValidationService -import com.netgrif.application.engine.workflow.domain.Case -import groovy.util.logging.Slf4j -import org.springframework.beans.factory.annotation.Autowired -import org.springframework.beans.factory.annotation.Lookup -import org.springframework.stereotype.Component - -@Slf4j -@Component -abstract class ValidationRunner { - - @Lookup("validationDelegate") - abstract ValidationDelegate getValidationDelegate() - - @Autowired - private ValidationRegistry validationRegistry; - - @Autowired - private ValidationService service - - void run(Case useCase, List validations) { - if (validations) { - log.debug("Validations: ${validations.collect {it.rule }}") - validations.each { Validation validation -> - String validationName, validationArgs - (validationName, validationArgs) = validation.rule.trim().split(" ") - Closure code = getValidationCode(validationName) - initCode(code.delegate, useCase) - if (!code(*validationArgs.split(","))) { - throw new IllegalArgumentException(validation.message.toString()) - } - } - } - } - - protected Closure getValidationCode(String validationName) { - Closure code = validationRegistry.getValidation(validationName) - return code.rehydrate(getValidationDelegate(), code.owner, code.thisObject) - } - - protected static void initCode(def delegate, Case useCase) { - delegate.metaClass.useCase = useCase - useCase.dataSet.fields.values().forEach { Field field -> - delegate.metaClass."$field.importId" = field - } - } -} diff --git a/src/main/groovy/com/netgrif/application/engine/startup/ValidationRunner.groovy b/src/main/groovy/com/netgrif/application/engine/startup/ValidationRunner.groovy index c5f54581dfd..0b67826536b 100644 --- a/src/main/groovy/com/netgrif/application/engine/startup/ValidationRunner.groovy +++ b/src/main/groovy/com/netgrif/application/engine/startup/ValidationRunner.groovy @@ -1,26 +1,29 @@ package com.netgrif.application.engine.startup - import com.netgrif.application.engine.auth.service.interfaces.IUserService import com.netgrif.application.engine.elastic.service.interfaces.IElasticCaseService import com.netgrif.application.engine.elastic.web.requestbodies.CaseSearchRequest import com.netgrif.application.engine.validations.interfaces.IValidationService import com.netgrif.application.engine.workflow.domain.Case -import groovy.transform.CompileStatic import groovy.util.logging.Slf4j import org.springframework.beans.factory.annotation.Autowired -import org.springframework.context.annotation.Profile import org.springframework.context.i18n.LocaleContextHolder import org.springframework.data.domain.PageRequest import org.springframework.stereotype.Component @Slf4j @Component -@Profile("!test") -@CompileStatic class ValidationRunner extends AbstractOrderedCommandLineRunner { private static final int PAGE_SIZE = 100 + public static final String VALIDATION_FILE_NAME = "engine-processes/validations/validation.xml" + public static final String VALIDATION_PETRI_NET_IDENTIFIER = "validation" + public static final String VALIDATION_ACTIVE_FIELD_ID = "active" + public static final String VALIDATION_NAME_FIELD_ID = "name" + public static final String VALIDATION_GROOVY_DEFINITION_FIELD_ID = "validation_definition_groovy" + + @Autowired + private ImportHelper helper @Autowired private IUserService userService @@ -34,15 +37,24 @@ class ValidationRunner extends AbstractOrderedCommandLineRunner { @Override void run(String... strings) throws Exception { log.info("Starting validation runner") + + helper.upsertNet(VALIDATION_FILE_NAME, VALIDATION_PETRI_NET_IDENTIFIER) + CaseSearchRequest request = new CaseSearchRequest() - request.query = "processIdentifier:validation AND dataSet.is_active.value:true" - int pageCount = (int) (elasticCaseService.count([request], userService.loggedOrSystem.transformToLoggedUser(), LocaleContextHolder.locale, false) / PAGE_SIZE) + request.query = String.format("processIdentifier:%s AND dataSet.%s.value:true", VALIDATION_PETRI_NET_IDENTIFIER, VALIDATION_ACTIVE_FIELD_ID) + long numberActiveValidations = elasticCaseService.count([request], userService.loggedOrSystem.transformToLoggedUser(), LocaleContextHolder.locale, false) + int pageCount = (int) (numberActiveValidations / PAGE_SIZE) + 1 pageCount.times { elasticCaseService.search([request], userService.loggedOrSystem.transformToLoggedUser(), PageRequest.of(it, PAGE_SIZE), LocaleContextHolder.locale, false) .getContent() .each { Case validationCase -> - validationService.registerValidation(validationCase.getDataSet().get("name").getValue() as String, validationCase.getDataSet().get("validation_definition_groovy").getValue() as String) + validationService.registerValidation( + validationCase.getDataSet().get(VALIDATION_NAME_FIELD_ID).rawValue as String, + validationCase.getDataSet().get(VALIDATION_GROOVY_DEFINITION_FIELD_ID).rawValue as String + ) } } + + log.info("Validation runner finished, [{}] validations successfully imported", numberActiveValidations) } } \ No newline at end of file diff --git a/src/main/groovy/com/netgrif/application/engine/validation/domain/ValidationDataInput.groovy b/src/main/groovy/com/netgrif/application/engine/validation/domain/ValidationDataInput.groovy deleted file mode 100644 index 97e6f6865a1..00000000000 --- a/src/main/groovy/com/netgrif/application/engine/validation/domain/ValidationDataInput.groovy +++ /dev/null @@ -1,24 +0,0 @@ -package com.netgrif.application.engine.validation.domain - -import com.netgrif.application.engine.petrinet.domain.I18nString -import com.netgrif.application.engine.petrinet.domain.dataset.Field -import lombok.AllArgsConstructor -import lombok.Data - -class ValidationDataInput { - - Field data - - I18nString validationMessage - - Locale locale - - String validationRegex - - ValidationDataInput(Field data, I18nString validationMessage, Locale locale, String validationRegex) { - this.data = data - this.validationMessage = validationMessage - this.locale = locale - this.validationRegex = validationRegex - } -} diff --git a/src/main/groovy/com/netgrif/application/engine/validation/models/AbstractFieldValidation.groovy b/src/main/groovy/com/netgrif/application/engine/validation/models/AbstractFieldValidation.groovy deleted file mode 100644 index 16b2c490718..00000000000 --- a/src/main/groovy/com/netgrif/application/engine/validation/models/AbstractFieldValidation.groovy +++ /dev/null @@ -1,14 +0,0 @@ -package com.netgrif.application.engine.validation.models - -import com.netgrif.application.engine.validation.domain.ValidationDataInput - -class AbstractFieldValidation implements Serializable { - - private static final long serialVersionUID = 3287601522204188694L - - void notempty(ValidationDataInput validationData) { - if (validationData.getData().getValue() == null || validationData.getData().getRawValue() == null) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } -} diff --git a/src/main/groovy/com/netgrif/application/engine/validation/models/BooleanFieldValidation.groovy b/src/main/groovy/com/netgrif/application/engine/validation/models/BooleanFieldValidation.groovy deleted file mode 100644 index 201e8460ce0..00000000000 --- a/src/main/groovy/com/netgrif/application/engine/validation/models/BooleanFieldValidation.groovy +++ /dev/null @@ -1,17 +0,0 @@ -package com.netgrif.application.engine.validation.models - -import com.netgrif.application.engine.petrinet.domain.dataset.BooleanField -import com.netgrif.application.engine.validation.domain.ValidationDataInput - -class BooleanFieldValidation extends AbstractFieldValidation { - -// REQUIRED_TRUE = 'requiredTrue' -// REQUIRED = 'required' - - void requiredtrue(ValidationDataInput validationData) { - Boolean value = ((BooleanField) validationData.getData()).getRawValue() - if (!(value == true) || value == null) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } -} diff --git a/src/main/groovy/com/netgrif/application/engine/validation/models/DateFieldValidation.groovy b/src/main/groovy/com/netgrif/application/engine/validation/models/DateFieldValidation.groovy deleted file mode 100644 index 3beaecd6294..00000000000 --- a/src/main/groovy/com/netgrif/application/engine/validation/models/DateFieldValidation.groovy +++ /dev/null @@ -1,122 +0,0 @@ -package com.netgrif.application.engine.validation.models - -import com.netgrif.application.engine.petrinet.domain.dataset.DateField -import com.netgrif.application.engine.petrinet.domain.dataset.DateTimeField -import com.netgrif.application.engine.petrinet.domain.dataset.Field -import com.netgrif.application.engine.validation.domain.ValidationDataInput -import groovy.util.logging.Slf4j - -import java.time.DayOfWeek -import java.time.LocalDate -import java.time.format.DateTimeFormatter -import java.time.format.DateTimeParseException -import java.time.temporal.ChronoField - -@Slf4j -class DateFieldValidation extends AbstractFieldValidation { - -// BETWEEN = 'between' -// WORKDAY = 'workday' -// WEEKEND = 'weekend' -// REQUIRED = 'required', -// VALID_BETWEEN = 'validBetween', -// VALID_WORKDAY = 'validWorkday', -// VALID_WEEKEND = 'validWeekend' - -// between today,future -// between past,today -// between 2020-03-03,today - - public static final String FUTURE = "future" - public static final String TODAY = "today" - public static final String PAST = "past" - public static final String NOW = "now" - - void between(ValidationDataInput validationData) { - LocalDate updateDate_TODAY = LocalDate.now() - List regex = validationData.getValidationRegex().trim().split(",") - LocalDate setDate = getDateValue(validationData.getData()) - - if (regex.size() == 2) { - def fromDate = parseStringToLocalDate(regex.get(0)) != null ? parseStringToLocalDate(regex.get(0)) : regex.get(0) - def toDate = parseStringToLocalDate(regex.get(1)) != null ? parseStringToLocalDate(regex.get(1)) : regex.get(1) - if ((fromDate == TODAY || fromDate == NOW) && toDate == FUTURE) { - if (setDate < updateDate_TODAY) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } else if (fromDate == PAST && (toDate == TODAY || toDate == NOW)) { - if (setDate > updateDate_TODAY) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } else if (fromDate == PAST && (toDate instanceof LocalDate)) { - if (setDate > toDate) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } else if (fromDate == TODAY && (toDate instanceof LocalDate)) { - if (setDate < toDate || setDate > updateDate_TODAY) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } else if ((fromDate instanceof LocalDate) && toDate == TODAY) { - if (setDate < fromDate || setDate > updateDate_TODAY) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } else if (toDate == FUTURE && (fromDate instanceof LocalDate)) { - if (setDate < fromDate) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } else if ((fromDate instanceof LocalDate) && (toDate instanceof LocalDate)) { - if (setDate > toDate || setDate < fromDate) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } - } - } - - void workday(ValidationDataInput validationData) { - LocalDate setDate = getDateValue(validationData.getData()) - if (isWeekend(setDate)) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } - - void weekend(ValidationDataInput validationData) { - LocalDate setDate = getDateValue(validationData.getData()) - if (!isWeekend(setDate)) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } - - // TODO: release/8.0.0 Refactor, each type own validator with common functions - LocalDate getDateValue(Field field) { - if (field instanceof DateField) { - return ((DateField) field).getRawValue() - } - throw new IllegalArgumentException("Cannot validate field " + field.stringId + " of type " + field.type + " with date validation") - } - - protected static boolean isWeekend(LocalDate day) { - DayOfWeek dayOfWeek = DayOfWeek.of(day.get(ChronoField.DAY_OF_WEEK)); - return dayOfWeek == DayOfWeek.SUNDAY || dayOfWeek == DayOfWeek.SATURDAY; - } - - protected LocalDate parseStringToLocalDate(String stringDate) { - if (stringDate == null) { - return null - } - List patterns = Arrays.asList("dd.MM.yyyy") - try { - return LocalDate.parse(stringDate, DateTimeFormatter.BASIC_ISO_DATE) - } catch (DateTimeParseException ignored) { - try { - return LocalDate.parse(stringDate, DateTimeFormatter.ISO_DATE) - } catch (DateTimeParseException ignored2) { - for (String pattern : patterns) { - try { - return LocalDate.parse(stringDate, DateTimeFormatter.ofPattern(pattern)) - } catch (DateTimeParseException | IllegalArgumentException ignored3) {} - } - } - } - return null - } -} diff --git a/src/main/groovy/com/netgrif/application/engine/validation/models/DateTimeFieldValidation.groovy b/src/main/groovy/com/netgrif/application/engine/validation/models/DateTimeFieldValidation.groovy deleted file mode 100644 index 20d58c025c4..00000000000 --- a/src/main/groovy/com/netgrif/application/engine/validation/models/DateTimeFieldValidation.groovy +++ /dev/null @@ -1,122 +0,0 @@ -package com.netgrif.application.engine.validation.models - -import com.netgrif.application.engine.petrinet.domain.dataset.DateField -import com.netgrif.application.engine.petrinet.domain.dataset.DateTimeField -import com.netgrif.application.engine.petrinet.domain.dataset.Field -import com.netgrif.application.engine.validation.domain.ValidationDataInput - -import java.time.DayOfWeek -import java.time.LocalDate -import java.time.LocalDateTime -import java.time.format.DateTimeFormatter -import java.time.format.DateTimeParseException -import java.time.temporal.ChronoField - -class DateTimeFieldValidation extends AbstractFieldValidation { - -// BETWEEN = 'between' -// WORKDAY = 'workday' -// WEEKEND = 'weekend' -// REQUIRED = 'required', -// VALID_BETWEEN = 'validBetween', -// VALID_WORKDAY = 'validWorkday', -// VALID_WEEKEND = 'validWeekend' - -// between today,future -// between past,today -// between 2020-03-03,today - - public static final String FUTURE = "future" - public static final String TODAY = "today" - public static final String PAST = "past" - public static final String NOW = "now" - - - void between(ValidationDataInput validationData) { - LocalDateTime updateDate_TODAY = LocalDateTime.now() - List regex = validationData.getValidationRegex().trim().split(",") - LocalDateTime setDate = getDateTimeValue(validationData.getData()) - if (regex.size() == 2) { - def fromDate = parseStringToLocalDateTime(regex.get(0)) != null ? parseStringToLocalDateTime(regex.get(0)) : regex.get(0) - def toDate = parseStringToLocalDateTime(regex.get(1)) != null ? parseStringToLocalDateTime(regex.get(1)) : regex.get(1) - if ((fromDate == TODAY || fromDate == NOW) && toDate == FUTURE) { - if (setDate < updateDate_TODAY) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } else if (fromDate == PAST && (toDate == TODAY || toDate == NOW)) { - if (setDate > updateDate_TODAY) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } else if (fromDate == PAST && (toDate instanceof LocalDateTime)) { - if (setDate > toDate) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } else if (fromDate == TODAY && (toDate instanceof LocalDateTime)) { - if (setDate < toDate || setDate > updateDate_TODAY) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } else if ((fromDate instanceof LocalDateTime) && toDate == TODAY) { - if (setDate < fromDate || setDate > updateDate_TODAY) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } else if (toDate == FUTURE && (fromDate instanceof LocalDateTime)) { - if (setDate < fromDate) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } else if ((fromDate instanceof LocalDateTime) && (toDate instanceof LocalDateTime)) { - if (setDate > toDate || setDate < fromDate) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } - } - } - - void workday(ValidationDataInput validationData) { - LocalDateTime setDate = getDateTimeValue(validationData.getData()) - if (isWeekend(setDate)) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } - - void weekend(ValidationDataInput validationData) { - LocalDateTime setDate = getDateTimeValue(validationData.getData()) - if (!isWeekend(setDate)) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } - - protected static boolean isWeekend(LocalDateTime day) { - DayOfWeek dayOfWeek = DayOfWeek.of(day.get(ChronoField.DAY_OF_WEEK)); - return dayOfWeek == DayOfWeek.SUNDAY || dayOfWeek == DayOfWeek.SATURDAY; - } -// TODO: release/8.0.0 Refactor, each type own validator with common functions - LocalDateTime getDateTimeValue(Field field) { - if (field instanceof DateTimeField) { - return ((DateTimeField) field).getRawValue() - } - throw new IllegalArgumentException("Cannot validate field " + field.stringId + " of type " + field.type + " with date validation") - } - - protected static LocalDateTime parseStringToLocalDateTime(String stringDate) { - if (stringDate == null) - return null - - List patterns = Arrays.asList("dd.MM.yyyy") - try { - return LocalDate.parse(stringDate, DateTimeFormatter.BASIC_ISO_DATE) - } catch (DateTimeParseException e) { - try { - return LocalDate.parse(stringDate, DateTimeFormatter.ISO_DATE) - } catch (DateTimeParseException ex) { - for (String pattern : patterns) { - try { - return LocalDate.parse(stringDate, DateTimeFormatter.ofPattern(pattern)) - } catch (DateTimeParseException | IllegalArgumentException exc) { - continue - } - } - } - } - return null - } -} diff --git a/src/main/groovy/com/netgrif/application/engine/validation/models/EnumerationFieldValidation.groovy b/src/main/groovy/com/netgrif/application/engine/validation/models/EnumerationFieldValidation.groovy deleted file mode 100644 index 265390cce75..00000000000 --- a/src/main/groovy/com/netgrif/application/engine/validation/models/EnumerationFieldValidation.groovy +++ /dev/null @@ -1,17 +0,0 @@ -package com.netgrif.application.engine.validation.models - -import com.netgrif.application.engine.validation.domain.ValidationDataInput - -class EnumerationFieldValidation extends AbstractFieldValidation { - -// WRONG_VALUE = 'wrongValue', -// REQUIRED = 'required' - - // TODO: release/8.0.0 should not be possible, setOption should null value if the options is no longer present - void wrongValue(ValidationDataInput validationData) { -// if (!(validationData.getData().getOptions().get(validationData.getData().getValue()))) { -// throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) -// } - } - -} diff --git a/src/main/groovy/com/netgrif/application/engine/validation/models/I18nFieldValidation.groovy b/src/main/groovy/com/netgrif/application/engine/validation/models/I18nFieldValidation.groovy deleted file mode 100644 index ae65744bb9f..00000000000 --- a/src/main/groovy/com/netgrif/application/engine/validation/models/I18nFieldValidation.groovy +++ /dev/null @@ -1,17 +0,0 @@ -package com.netgrif.application.engine.validation.models - -import com.netgrif.application.engine.validation.domain.ValidationDataInput - -class I18nFieldValidation extends AbstractFieldValidation { - -// TRANSLATION_REQUIRED = 'translationRequired', -// TRANSLATION_ONLY = 'translationOnly', -// REQUIRED_I18N = 'requiredI18n' - - void wrongValue(ValidationDataInput validationData) { - if (!(validationData.getData().getValue() == true)) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } - -} diff --git a/src/main/groovy/com/netgrif/application/engine/validation/models/NumberFieldValidation.groovy b/src/main/groovy/com/netgrif/application/engine/validation/models/NumberFieldValidation.groovy deleted file mode 100644 index 070ed4dd80d..00000000000 --- a/src/main/groovy/com/netgrif/application/engine/validation/models/NumberFieldValidation.groovy +++ /dev/null @@ -1,93 +0,0 @@ -package com.netgrif.application.engine.validation.models - -import com.netgrif.application.engine.validation.domain.ValidationDataInput - -class NumberFieldValidation extends AbstractFieldValidation { - static final String INF = 'inf' - -// static final String ODD = 'odd' -// static final String EVEN = 'even' -// static final String POSITIVE = 'positive' -// static final String NEGATIVE = 'negative' -// static final String DECIMAL = 'decimal' -// static final String IN_RANGE = 'inrange' -// static final String INF = 'inf' -// static final String REQUIRED = 'required' -// static final String VALID_ODD = 'validOdd' -// static final String VALID_EVEN = 'validEven' -// static final String VALID_POSITIVE = 'validPositive' -// static final String VALID_NEGATIVE = 'validNegative' -// static final String VALID_DECIMAL = 'validDecimal' -// static final String VALID_IN_RANGE = 'validInRange' - - - void odd(ValidationDataInput validationData) { - if (!(validationData.getData().getValue() == null || validationData.getData().getRawValue() == null)) { - if (validationData.getData().getRawValue() % 2 == 0) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } - } - - void even(ValidationDataInput validationData) { - if (!(validationData.getData().getValue() == null || validationData.getData().getRawValue() == null)) { - if (validationData.getData().getRawValue() % 2 != 0) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } - } - - void positive(ValidationDataInput validationData) { - if (!(validationData.getData().getValue() == null || validationData.getData().getRawValue() == null)) { - if (validationData.getData().getRawValue() < 0) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } - } - - void negative(ValidationDataInput validationData) { - if (!(validationData.getData().getValue() == null || validationData.getData().getRawValue() == null)) { - - - if (validationData.getData() != null) { - if (validationData.getData().getRawValue() > 0) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } - } - } - - void decimal(ValidationDataInput validationData) { - if (!(validationData.getData().getValue() == null || validationData.getData().getRawValue() == null)) { - if (validationData.getData().getRawValue() % 1 != 0) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } - } - - void inrange(ValidationDataInput validationData) { - if (!(validationData.getData().getValue() == null || validationData.getData().getRawValue() == null)) { - String[] ranges = validationData.validationRegex.split(",") - if (ranges.size() == 2) { - if (ranges.any { it.toLowerCase().equals(INF) }) { - if (ranges.first().toLowerCase() != INF) { - if (validationData.getData().getRawValue() < ranges[0] as Double) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } else { - if (ranges[1].toLowerCase() != INF) { - if (validationData.getData().getRawValue() > ranges[1] as Double) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } - } - } else { - if (validationData.getData().getRawValue() < ranges[0] as Double || validationData.getData().getRawValue() > ranges[1] as Double) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } - } - } - } - -} diff --git a/src/main/groovy/com/netgrif/application/engine/validation/models/TextFieldValidation.groovy b/src/main/groovy/com/netgrif/application/engine/validation/models/TextFieldValidation.groovy deleted file mode 100644 index 33abd482be3..00000000000 --- a/src/main/groovy/com/netgrif/application/engine/validation/models/TextFieldValidation.groovy +++ /dev/null @@ -1,60 +0,0 @@ -package com.netgrif.application.engine.validation.models - -import com.netgrif.application.engine.validation.domain.ValidationDataInput - -class TextFieldValidation extends AbstractFieldValidation { - - public static String telNumberRegex = '^(?:\\+?(\\d{1,3}))?([-. (]*(\\d{3})[-. )]*)?((\\d{3})[-. ]*(\\d{2,4})(?:[-.x ]*(\\d+))?)$' - public static String emailRegex = '^[a-zA-Z0-9\\._\\%\\+\\-]+@[a-zA-Z0-9\\.\\-]+\\.[a-zA-Z]{2,}$' -// REQUIRED = 'required' -// MIN_LENGTH = 'minLength' -// MAX_LENGTH = 'maxLength' -// VALID_MIN_LENGTH = 'minlength' -// VALID_MAX_LENGTH = 'maxlength' -// PATTERN = 'pattern' -// REGEX = 'regex' -// VALID_TEL_NUMBER = 'validTelNumber' -// TEL_NUMBER = 'telNumber' -// EMAIL = 'email' - - void regex(ValidationDataInput validationData) { - if (validationData.getData().getValue() != null && validationData.getData().getRawValue() != null) { - if (!(validationData.getData().getRawValue() ==~ validationData.getValidationRegex())) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } - } - - void minlength(ValidationDataInput validationData) { - if (validationData.getData().getValue() != null && validationData.getData().getRawValue() != null) { - if (!((validationData.getData().getRawValue() as String).length() >= (validationData.getValidationRegex() as Integer))) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } - } - - void maxlength(ValidationDataInput validationData) { - if (validationData.getData().getValue() != null && validationData.getData().getRawValue() != null) { - if ((validationData.getData().getRawValue() as String).length() > (validationData.getValidationRegex() as Integer)) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } - } - - void telnumber(ValidationDataInput validationData) { - if (validationData.getData().getValue() != null && validationData.getData().getRawValue() != null) { - if (!(validationData.getData().getRawValue() ==~ telNumberRegex)) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } - } - - void email(ValidationDataInput validationData) { - if (validationData.getData().getValue() != null && validationData.getData().getRawValue() != null) { - if (!(validationData.getData().getRawValue() ==~ emailRegex)) { - throw new IllegalArgumentException(validationData.getValidationMessage().getTranslation(validationData.getLocale())) - } - } - } - -} diff --git a/src/main/groovy/com/netgrif/application/engine/validation/service/ValidationService.groovy b/src/main/groovy/com/netgrif/application/engine/validation/service/ValidationService.groovy deleted file mode 100644 index 26e8b77afcc..00000000000 --- a/src/main/groovy/com/netgrif/application/engine/validation/service/ValidationService.groovy +++ /dev/null @@ -1,75 +0,0 @@ -package com.netgrif.application.engine.validation.service - -import com.netgrif.application.engine.petrinet.domain.I18nString -import com.netgrif.application.engine.petrinet.domain.dataset.* -import com.netgrif.application.engine.validation.domain.ValidationDataInput -import com.netgrif.application.engine.validation.models.* -import com.netgrif.application.engine.validation.service.interfaces.IValidationService -import groovy.util.logging.Slf4j -import org.springframework.context.i18n.LocaleContextHolder -import org.springframework.stereotype.Service - -import java.util.stream.Collectors - -@Slf4j -@Service -class ValidationService implements IValidationService { - - @Override - void valid(Field dataField) { - if (dataField.getValidations() == null) { - return - } - dataField.getValidations().forEach(validation -> { - List rules = validation.getRule().trim().split(" ").toList() - if (rules.size() >= 1) { - AbstractFieldValidation instance = new AbstractFieldValidation() - if (dataField instanceof NumberField) { - instance = new NumberFieldValidation() - } else if (dataField instanceof TextField) { - instance = new TextFieldValidation() - } else if (dataField instanceof BooleanField) { - instance = new BooleanFieldValidation() - } else if (dataField instanceof DateField) { - instance = new DateFieldValidation() - } else if (dataField instanceof DateTimeField) { - instance = new DateTimeFieldValidation() - } else if (dataField instanceof ButtonField) { - - } else if (dataField instanceof UserField) { - - } else if (dataField instanceof DateField) { - - } else if (dataField instanceof DateTimeField) { - - } else if (dataField instanceof EnumerationField) { - - } else if (dataField instanceof EnumerationMapField) { - - } else if (dataField instanceof MultichoiceMapField) { - - } else if (dataField instanceof MultichoiceField) { - - } else if (dataField instanceof FileField) { - - } else if (dataField instanceof FileListField) { - - } else if (dataField instanceof UserListField) { - - } else if (dataField instanceof I18nField) { - - } - MetaMethod method = instance.metaClass.getMethods().find { it.name.toLowerCase() == rules.first().toLowerCase() } - if (method != null) { - I18nString validMessage = validation.getMessage() ?: new I18nString("Invalid Field value") - method.invoke(instance, new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" ")))) - } else { - log.warn("Method [" + rules.first() + "] in dataField " + dataField.getImportId() + " not found") - } - } - }) - - - } - -} diff --git a/src/main/groovy/com/netgrif/application/engine/validation/service/interfaces/IValidationService.groovy b/src/main/groovy/com/netgrif/application/engine/validation/service/interfaces/IValidationService.groovy deleted file mode 100644 index 22ed23b223c..00000000000 --- a/src/main/groovy/com/netgrif/application/engine/validation/service/interfaces/IValidationService.groovy +++ /dev/null @@ -1,8 +0,0 @@ -package com.netgrif.application.engine.validation.service.interfaces - -import com.netgrif.application.engine.petrinet.domain.dataset.Field - -interface IValidationService { - - void valid(Field dataField); -} \ No newline at end of file diff --git a/src/main/java/com/netgrif/application/engine/configuration/PrototypesConfiguration.java b/src/main/java/com/netgrif/application/engine/configuration/PrototypesConfiguration.java index b23b385c5ac..cda58dc5076 100644 --- a/src/main/java/com/netgrif/application/engine/configuration/PrototypesConfiguration.java +++ b/src/main/java/com/netgrif/application/engine/configuration/PrototypesConfiguration.java @@ -4,6 +4,7 @@ import com.netgrif.application.engine.importer.service.Importer; import com.netgrif.application.engine.petrinet.domain.dataset.logic.action.ActionDelegate; import com.netgrif.application.engine.petrinet.domain.dataset.logic.action.ExpressionDelegate; +import com.netgrif.application.engine.petrinet.domain.dataset.logic.action.ValidationDelegate; import com.netgrif.application.engine.workflow.domain.FileStorageConfiguration; import org.springframework.beans.factory.config.ConfigurableBeanFactory; import org.springframework.context.annotation.Bean; @@ -31,6 +32,12 @@ public ExpressionDelegate expressionDelegate() { return new ExpressionDelegate(); } + @Bean("validationDelegate") + @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE) + public ValidationDelegate validationDelegate() { + return new ValidationDelegate(); + } + @Bean("fileStorageConfiguration") @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE) public FileStorageConfiguration fileStorageConfiguration() { diff --git a/src/main/java/com/netgrif/application/engine/validations/ValidationRegistry.java b/src/main/java/com/netgrif/application/engine/validations/ValidationRegistry.java index e75ad561ca1..37591819d14 100644 --- a/src/main/java/com/netgrif/application/engine/validations/ValidationRegistry.java +++ b/src/main/java/com/netgrif/application/engine/validations/ValidationRegistry.java @@ -3,6 +3,8 @@ import groovy.lang.Closure; import org.springframework.stereotype.Component; +import java.util.ArrayList; +import java.util.List; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; @@ -19,6 +21,10 @@ public Closure getValidation(String name) { return validationsMap.get(name); } + public List getValidationNames() { + return new ArrayList<>(validationsMap.keySet()); + } + public Closure removeValidation(String name) { return validationsMap.remove(name); } diff --git a/src/main/java/com/netgrif/application/engine/validations/ValidationService.java b/src/main/java/com/netgrif/application/engine/validations/ValidationService.java index d91871c56c2..d59104dda72 100644 --- a/src/main/java/com/netgrif/application/engine/validations/ValidationService.java +++ b/src/main/java/com/netgrif/application/engine/validations/ValidationService.java @@ -3,7 +3,7 @@ import com.netgrif.application.engine.event.IGroovyShellFactory; 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.ValidationRunner; +import com.netgrif.application.engine.petrinet.domain.dataset.logic.action.ValidationExecutioner; import com.netgrif.application.engine.validations.interfaces.IValidationService; import com.netgrif.application.engine.workflow.domain.Case; import groovy.lang.Closure; @@ -18,25 +18,29 @@ public class ValidationService implements IValidationService { private final ValidationRegistry validationRegistry; - private final ValidationRunner validationRunner; + private final ValidationExecutioner validationExecutioner; private final IGroovyShellFactory shellFactory; @Autowired - public ValidationService(ValidationRegistry validationRegistry, ValidationRunner validationRunner, IGroovyShellFactory shellFactory) { + public ValidationService(ValidationRegistry validationRegistry, ValidationExecutioner validationExecutioner, IGroovyShellFactory shellFactory) { this.validationRegistry = validationRegistry; - this.validationRunner = validationRunner; + this.validationExecutioner = validationExecutioner; this.shellFactory = shellFactory; } @Override public void validateTransition(Case useCase, Transition transition) { - transition.getDataSet().values().forEach(dataRef -> validationRunner.run(useCase, dataRef.getField().getValidations())); + transition.getDataSet().values().forEach(dataRef -> { + if (dataRef.getField() != null) { + validationExecutioner.run(useCase, dataRef.getField(), dataRef.getField().getValidations()); + } + }); } @Override public void validateField(Case useCase, Field field) { - validationRunner.run(useCase, field.getValidations()); + validationExecutioner.run(useCase, field, field.getValidations()); } @Override 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 55825eb35d7..ba0e962afbf 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 @@ -18,11 +18,8 @@ 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; -import com.netgrif.application.engine.workflow.domain.EventNotExecutableException; -import com.netgrif.application.engine.workflow.domain.Task; +import com.netgrif.application.engine.validations.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.GetDataEventOutcome; import com.netgrif.application.engine.workflow.domain.eventoutcomes.dataoutcomes.GetDataGroupsEventOutcome; @@ -87,10 +84,7 @@ public class DataService implements IDataService { protected IPetriNetService petriNetService; @Autowired - protected IValidationService validation; - - @Autowired - protected com.netgrif.application.engine.validations.interfaces.IValidationService validationService; + protected IValidationService validationService; @Value("${nae.image.preview.scaling.px:400}") protected int imageScale; @@ -231,9 +225,7 @@ public SetDataEventOutcome setDataField(Task task, String fieldId, Field newD } useCase.getDataSet().get(fieldId).applyChanges(newDataField); validationService.validateField(useCase, useCase.getDataSet().get(fieldId)); -// if (validationEnable) { -// validation.valid(useCase.getDataSet().get(fieldId)); -// } + useCase = workflowService.save(useCase); outcome.addChangedField(fieldId, newDataField); historyService.save(new SetDataEventLog(task, useCase, EventPhase.EXECUTION, DataSet.of(fieldId, newDataField), 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 079d7671670..9e602ed5384 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 @@ -31,7 +31,7 @@ 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.validations.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; @@ -113,10 +113,7 @@ public class TaskService implements ITaskService { protected IHistoryService historyService; @Autowired - protected IValidationService validation; - - @Autowired - protected com.netgrif.application.engine.validations.interfaces.IValidationService validationService; + protected IValidationService validationService; @Autowired public void setElasticTaskService(IElasticTaskService elasticTaskService) { @@ -277,7 +274,6 @@ public FinishTaskEventOutcome finishTask(Task task, IUser user, Map outcomes = new ArrayList<>(eventService.runActions(transition.getPreFinishActions(), workflowService.findOne(task.getCaseId()), task, transition, params)); useCase = workflowService.findOne(task.getCaseId()); task = findOne(task.getStringId()); diff --git a/src/main/resources/petriNets/engine-processes/validations/validation.xml b/src/main/resources/petriNets/engine-processes/validations/validation.xml index ac6335aa7e0..f12fc8216bd 100644 --- a/src/main/resources/petriNets/engine-processes/validations/validation.xml +++ b/src/main/resources/petriNets/engine-processes/validations/validation.xml @@ -193,7 +193,7 @@ validation_definition_groovy: f.validation_definition_groovy, active: f.active; - validationService.registerValidation(name.value, validation_definition_groovy.value) + validationService.registerValidation(name.rawValue, validation_definition_groovy.rawValue) change active value { true } @@ -220,7 +220,7 @@ name: f.name, active: f.active; - validationService.unregisterValidation(name.value) + validationService.unregisterValidation(name.rawValue) change active value { false } diff --git a/src/test/groovy/com/netgrif/application/engine/TestHelper.groovy b/src/test/groovy/com/netgrif/application/engine/TestHelper.groovy index db7992527bc..f5430a8f312 100644 --- a/src/test/groovy/com/netgrif/application/engine/TestHelper.groovy +++ b/src/test/groovy/com/netgrif/application/engine/TestHelper.groovy @@ -52,6 +52,8 @@ class TestHelper { private UriRunner uriRunner @Autowired private IPetriNetService petriNetService + @Autowired + private ValidationRunner validationRunner void truncateDbs() { template.db.drop() @@ -74,6 +76,7 @@ class TestHelper { filterRunner.run() impersonationRunner.run() superCreator.run() + validationRunner.run() finisherRunner.run() } } \ No newline at end of file diff --git a/src/test/groovy/com/netgrif/application/engine/validation/BooleanFieldValidationTest.groovy b/src/test/groovy/com/netgrif/application/engine/validation/BooleanFieldValidationTest.groovy index c6d8dc4bbda..bdf2371fc23 100644 --- a/src/test/groovy/com/netgrif/application/engine/validation/BooleanFieldValidationTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/validation/BooleanFieldValidationTest.groovy @@ -3,8 +3,8 @@ package com.netgrif.application.engine.validation import com.netgrif.application.engine.TestHelper import com.netgrif.application.engine.petrinet.domain.I18nString import com.netgrif.application.engine.petrinet.domain.dataset.BooleanField -import com.netgrif.application.engine.validation.domain.ValidationDataInput -import com.netgrif.application.engine.validation.models.BooleanFieldValidation +//import com.netgrif.application.engine.validation.domain.ValidationDataInput +//import com.netgrif.application.engine.validation.models.BooleanFieldValidation import org.junit.jupiter.api.Assertions import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Test @@ -31,56 +31,56 @@ class BooleanFieldValidationTest { testHelper.truncateDbs() } - @Test - void requiredTrue() { - BooleanFieldValidation booleanFieldValidation = new BooleanFieldValidation() - BooleanField dataField = new BooleanField(rawValue: true) - I18nString validMessage = new I18nString(ErrorMessage) - List rules = [] - ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) - - booleanFieldValidation.requiredtrue(input) - } - - @Test - void notempty() { - BooleanFieldValidation booleanFieldValidation = new BooleanFieldValidation() - BooleanField dataField = new BooleanField(rawValue: true) - I18nString validMessage = new I18nString(ErrorMessage) - List rules = [] - ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) - - booleanFieldValidation.notempty(input) - } - - - @Test - void notempty_Exception() { - BooleanFieldValidation booleanFieldValidation = new BooleanFieldValidation() - BooleanField dataField = new BooleanField() - dataField.value = null - I18nString validMessage = new I18nString(ErrorMessage) - List rules = [] - ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - booleanFieldValidation.notempty(input) - }) - Assertions.assertEquals(ErrorMessage, thrown.getMessage()); - } - - @Test - void notempty_Exception2() { - BooleanFieldValidation booleanFieldValidation = new BooleanFieldValidation() - BooleanField dataField = new BooleanField() - dataField.value = null - I18nString validMessage = new I18nString(ErrorMessage) - List rules = [] - ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - booleanFieldValidation.notempty(input) - }) - Assertions.assertEquals(ErrorMessage, thrown.getMessage()); - } +// @Test +// void requiredTrue() { +// BooleanFieldValidation booleanFieldValidation = new BooleanFieldValidation() +// BooleanField dataField = new BooleanField(rawValue: true) +// I18nString validMessage = new I18nString(ErrorMessage) +// List rules = [] +// ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) +// +// booleanFieldValidation.requiredtrue(input) +// } +// +// @Test +// void notempty() { +// BooleanFieldValidation booleanFieldValidation = new BooleanFieldValidation() +// BooleanField dataField = new BooleanField(rawValue: true) +// I18nString validMessage = new I18nString(ErrorMessage) +// List rules = [] +// ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) +// +// booleanFieldValidation.notempty(input) +// } +// +// +// @Test +// void notempty_Exception() { +// BooleanFieldValidation booleanFieldValidation = new BooleanFieldValidation() +// BooleanField dataField = new BooleanField() +// dataField.value = null +// I18nString validMessage = new I18nString(ErrorMessage) +// List rules = [] +// ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// booleanFieldValidation.notempty(input) +// }) +// Assertions.assertEquals(ErrorMessage, thrown.getMessage()); +// } +// +// @Test +// void notempty_Exception2() { +// BooleanFieldValidation booleanFieldValidation = new BooleanFieldValidation() +// BooleanField dataField = new BooleanField() +// dataField.value = null +// I18nString validMessage = new I18nString(ErrorMessage) +// List rules = [] +// ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// booleanFieldValidation.notempty(input) +// }) +// Assertions.assertEquals(ErrorMessage, thrown.getMessage()); +// } } diff --git a/src/test/groovy/com/netgrif/application/engine/validation/NumberFieldValidationTest.groovy b/src/test/groovy/com/netgrif/application/engine/validation/NumberFieldValidationTest.groovy index a4aa85ed99e..2714f105022 100644 --- a/src/test/groovy/com/netgrif/application/engine/validation/NumberFieldValidationTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/validation/NumberFieldValidationTest.groovy @@ -3,8 +3,8 @@ package com.netgrif.application.engine.validation import com.netgrif.application.engine.TestHelper import com.netgrif.application.engine.petrinet.domain.I18nString import com.netgrif.application.engine.petrinet.domain.dataset.NumberField -import com.netgrif.application.engine.validation.domain.ValidationDataInput -import com.netgrif.application.engine.validation.models.NumberFieldValidation +//import com.netgrif.application.engine.validation.domain.ValidationDataInput +//import com.netgrif.application.engine.validation.models.NumberFieldValidation import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Test import org.junit.jupiter.api.extension.ExtendWith @@ -31,70 +31,70 @@ class NumberFieldValidationTest { } - @Test - void odd() { - NumberFieldValidation numberFieldValidation = new NumberFieldValidation() - NumberField dataField = new NumberField(rawValue: 5) - I18nString validMessage = new I18nString("Invalid Field value") - List rules = [] - ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) - - numberFieldValidation.odd(input) - } - - - @Test - void even() { - NumberFieldValidation numberFieldValidation = new NumberFieldValidation() - NumberField dataField = new NumberField(rawValue: 4) - I18nString validMessage = new I18nString("Invalid Field value") - List rules = [] - ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) - - numberFieldValidation.even(input) - } - - @Test - void positive() { - NumberFieldValidation numberFieldValidation = new NumberFieldValidation() - NumberField dataField = new NumberField(rawValue: 4) - I18nString validMessage = new I18nString("Invalid Field value") - List rules = [] - ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) - - numberFieldValidation.positive(input) - } - - @Test - void positivenegative() { - NumberFieldValidation numberFieldValidation = new NumberFieldValidation() - NumberField dataField = new NumberField(rawValue: -4) - I18nString validMessage = new I18nString("Invalid Field value") - List rules = [] - ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) - - numberFieldValidation.negative(input) - } - - @Test - void decimal() { - NumberFieldValidation numberFieldValidation = new NumberFieldValidation() - NumberField dataField = new NumberField(rawValue: 4) - I18nString validMessage = new I18nString("Invalid Field value") - List rules = [] - ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) - - numberFieldValidation.decimal(input) - } - - @Test - void inrange() { - NumberFieldValidation numberFieldValidation = new NumberFieldValidation() - NumberField dataField = new NumberField(rawValue: 7) - I18nString validMessage = new I18nString("Invalid Field value") - List rules = ["5,10"] - ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) - - numberFieldValidation.inrange(input) - } +// @Test +// void odd() { +// NumberFieldValidation numberFieldValidation = new NumberFieldValidation() +// NumberField dataField = new NumberField(rawValue: 5) +// I18nString validMessage = new I18nString("Invalid Field value") +// List rules = [] +// ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) +// +// numberFieldValidation.odd(input) +// } +// +// +// @Test +// void even() { +// NumberFieldValidation numberFieldValidation = new NumberFieldValidation() +// NumberField dataField = new NumberField(rawValue: 4) +// I18nString validMessage = new I18nString("Invalid Field value") +// List rules = [] +// ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) +// +// numberFieldValidation.even(input) +// } +// +// @Test +// void positive() { +// NumberFieldValidation numberFieldValidation = new NumberFieldValidation() +// NumberField dataField = new NumberField(rawValue: 4) +// I18nString validMessage = new I18nString("Invalid Field value") +// List rules = [] +// ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) +// +// numberFieldValidation.positive(input) +// } +// +// @Test +// void positivenegative() { +// NumberFieldValidation numberFieldValidation = new NumberFieldValidation() +// NumberField dataField = new NumberField(rawValue: -4) +// I18nString validMessage = new I18nString("Invalid Field value") +// List rules = [] +// ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) +// +// numberFieldValidation.negative(input) +// } +// +// @Test +// void decimal() { +// NumberFieldValidation numberFieldValidation = new NumberFieldValidation() +// NumberField dataField = new NumberField(rawValue: 4) +// I18nString validMessage = new I18nString("Invalid Field value") +// List rules = [] +// ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) +// +// numberFieldValidation.decimal(input) +// } +// +// @Test +// void inrange() { +// NumberFieldValidation numberFieldValidation = new NumberFieldValidation() +// NumberField dataField = new NumberField(rawValue: 7) +// I18nString validMessage = new I18nString("Invalid Field value") +// List rules = ["5,10"] +// ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) +// +// numberFieldValidation.inrange(input) +// } } diff --git a/src/test/groovy/com/netgrif/application/engine/validation/TextFieldValidationTest.groovy b/src/test/groovy/com/netgrif/application/engine/validation/TextFieldValidationTest.groovy index e806d4b9a96..7c7548c72f7 100644 --- a/src/test/groovy/com/netgrif/application/engine/validation/TextFieldValidationTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/validation/TextFieldValidationTest.groovy @@ -3,8 +3,8 @@ package com.netgrif.application.engine.validation import com.netgrif.application.engine.TestHelper import com.netgrif.application.engine.petrinet.domain.I18nString import com.netgrif.application.engine.petrinet.domain.dataset.TextField -import com.netgrif.application.engine.validation.domain.ValidationDataInput -import com.netgrif.application.engine.validation.models.TextFieldValidation +//import com.netgrif.application.engine.validation.domain.ValidationDataInput +//import com.netgrif.application.engine.validation.models.TextFieldValidation import org.junit.jupiter.api.Assertions import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Test @@ -31,31 +31,31 @@ class TextFieldValidationTest { testHelper.truncateDbs() } - @Test - void minlength_Exception() { - TextFieldValidation textFieldValidation = new TextFieldValidation() - TextField dataField = new TextField(rawValue: 'totok') - I18nString validMessage = new I18nString(ErrorMessage) - List rules = ["minlength","6"] - ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - textFieldValidation.minlength(input) - }) - Assertions.assertEquals(ErrorMessage, thrown.getMessage()); - } - - @Test - void maxlength_Exception() { - TextFieldValidation textFieldValidation = new TextFieldValidation() - TextField dataField = new TextField(rawValue: 'totok') - I18nString validMessage = new I18nString(ErrorMessage) - List rules = ["maxlength","4"] - ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - textFieldValidation.maxlength(input) - }) - Assertions.assertEquals(ErrorMessage, thrown.getMessage()); - } +// @Test +// void minlength_Exception() { +// TextFieldValidation textFieldValidation = new TextFieldValidation() +// TextField dataField = new TextField(rawValue: 'totok') +// I18nString validMessage = new I18nString(ErrorMessage) +// List rules = ["minlength","6"] +// ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// textFieldValidation.minlength(input) +// }) +// Assertions.assertEquals(ErrorMessage, thrown.getMessage()); +// } +// +// @Test +// void maxlength_Exception() { +// TextFieldValidation textFieldValidation = new TextFieldValidation() +// TextField dataField = new TextField(rawValue: 'totok') +// I18nString validMessage = new I18nString(ErrorMessage) +// List rules = ["maxlength","4"] +// ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// textFieldValidation.maxlength(input) +// }) +// Assertions.assertEquals(ErrorMessage, thrown.getMessage()); +// } } diff --git a/src/test/groovy/com/netgrif/application/engine/validation/ValidationTest.groovy b/src/test/groovy/com/netgrif/application/engine/validation/ValidationTest.groovy index 4e640f09792..d99c4a5044e 100644 --- a/src/test/groovy/com/netgrif/application/engine/validation/ValidationTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/validation/ValidationTest.groovy @@ -47,1013 +47,1013 @@ class ValidationTest { @Autowired private SuperCreator superCreator - @BeforeEach - void setup() { - testHelper.truncateDbs() - } - - private PetriNet importTextNet() { - PetriNet testNet = importHelper.createNet("validation/valid_text.xml", VersionType.MAJOR).get() - assert testNet != null - return testNet - } - - private PetriNet importRegexNet() { - PetriNet testNet = importHelper.createNet("validation/valid_regex.xml", VersionType.MAJOR).get() - assert testNet != null - return testNet - } - - private PetriNet importBooleanNet() { - PetriNet testNet = importHelper.createNet("validation/valid_boolean.xml", VersionType.MAJOR).get() - assert testNet != null - return testNet - } - - private PetriNet importDateNet() { - PetriNet testNet = importHelper.createNet("validation/valid_date.xml", VersionType.MAJOR).get() - assert testNet != null - return testNet - } - - private PetriNet importNumberNet() { - PetriNet testNet = importHelper.createNet("validation/valid_number.xml", VersionType.MAJOR).get() - assert testNet != null - return testNet - } - - // TEXT FIELD - @Test - void textValid_email() { - PetriNet testNet = importTextNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["text01": new TextField(rawValue: "test@netgrif.com")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void textValid_email2() { - PetriNet testNet = importTextNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["text01": new TextField(rawValue: "test@netgrif.co.com")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void textValid_email3() { - PetriNet testNet = importTextNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["text01": new TextField(rawValue: "te.st@netgrif.co.com")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void textValid_email_Exception() { - PetriNet testNet = importTextNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["text01": new TextField(rawValue: "test@@aaa.com")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-text01", thrown.getMessage()); - } - - @Test - void textValid_email_Exception2() { - PetriNet testNet = importTextNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["text01": new TextField(rawValue: "test@aaa.s")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-text01", thrown.getMessage()); - } - - @Test - void textValid_telnumber() { - PetriNet testNet = importTextNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["text02": new TextField(rawValue: "+421 000 000 000")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void textValid_telnumber2() { - PetriNet testNet = importTextNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["text02": new TextField(rawValue: "+421-000-000-000")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void textValid_telnumber3() { - PetriNet testNet = importTextNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["text02": new TextField(rawValue: "0910-000-000")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void textValid_telnumber4() { - PetriNet testNet = importTextNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["text02": new TextField(rawValue: "0910000000")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void textValid_telnumber_Exception() { - PetriNet testNet = importTextNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["text02": new TextField(rawValue: "aaa 000 000 000")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-text02", thrown.getMessage()); - } - - @Test - void regexValid_regex01() { - PetriNet testNet = importRegexNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["regex01": new TextField(rawValue: "12345")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void regexValid_regex02() { - PetriNet testNet = importRegexNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["regex02": new TextField(rawValue: "AbC-012-Z9")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void regexValid_regex03() { - PetriNet testNet = importRegexNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["regex03": new TextField(rawValue: "TOTOK4EveR09")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void regexValid_regex04() { - PetriNet testNet = importRegexNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["regex04": new TextField(rawValue: "AA 09 bb")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void regexValid_regex05() { - PetriNet testNet = importRegexNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["regex05": new TextField(rawValue: "A(:?BB+ľščťžýáíééé===é/*-+12154 ô/[]??.!\\.-úaa<>4 MM adsa!!; ff @#&")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void regexValid_regex05_2() { - PetriNet testNet = importRegexNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["regex05": new TextField(rawValue: " ")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void regexValid_regex06() { - PetriNet testNet = importRegexNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["regex06": new TextField(rawValue: "Toto00okJeTest012@netgrif.com")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void regexValid_regex06_2() { - PetriNet testNet = importRegexNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["regex06": new TextField(rawValue: "e-mail.totok@netgrif.com")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void regexValid_regex06_3() { - PetriNet testNet = importRegexNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["regex06": new TextField(rawValue: "totok@az.sk.so")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void regexValid_regex01_Exception() { - PetriNet testNet = importRegexNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["regex01": new TextField(rawValue: "54544545454")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-regex01", thrown.getMessage()); - } - - @Test - void regexValid_regex01_Exception2() { - PetriNet testNet = importRegexNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["regex01": new TextField(rawValue: "")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-regex01", thrown.getMessage()); - } - - @Test - void regexValid_regex01_Exception3() { - PetriNet testNet = importRegexNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["regex01": new TextField(rawValue: "aav")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-regex01", thrown.getMessage()); - } - - @Test - void regexValid_regex02_Exception() { - PetriNet testNet = importRegexNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["regex02": new TextField(rawValue: "AAAAAAAAAAAAAaaaaaaaaaa")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-regex02", thrown.getMessage()); - } - - @Test - void regexValid_regex02_Exception2() { - PetriNet testNet = importRegexNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["regex02": new TextField(rawValue: "AAAAAAA??a")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-regex02", thrown.getMessage()); - } - - @Test - void regexValid_regex02_Exception3() { - PetriNet testNet = importRegexNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["regex02": new TextField(rawValue: "-")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-regex02", thrown.getMessage()); - } - - @Test - void regexValid_regex03_Exception() { - PetriNet testNet = importRegexNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["regex03": new TextField(rawValue: "aaaTOTOKaa1231")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-regex03", thrown.getMessage()); - } - - @Test - void regexValid_regex03_Exception2() { - PetriNet testNet = importRegexNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["regex03": new TextField(rawValue: "TOTOK")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-regex03", thrown.getMessage()); - } - - @Test - void regexValid_regex03_Exception3() { - PetriNet testNet = importRegexNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["regex03": new TextField(rawValue: "TOTOK4EveR0!")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-regex03", thrown.getMessage()); - } - - @Test - void regexValid_regex04_Exception() { - PetriNet testNet = importRegexNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["regex04": new TextField(rawValue: "5412122121212121")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-regex04", thrown.getMessage()); - } - - @Test - void regexValid_regex05_Exception() { - PetriNet testNet = importRegexNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["regex05": new TextField(rawValue: "")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-regex05", thrown.getMessage()); - } - - @Test - void regexValid_regex06_Exception() { - PetriNet testNet = importRegexNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["regex06": new TextField(rawValue: "aaa@@@aaa.ss")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-regex06", thrown.getMessage()); - } - - @Test - void regexValid_regex06_Exception2() { - PetriNet testNet = importRegexNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["regex06": new TextField(rawValue: "aaa@aa")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-regex06", thrown.getMessage()); - } - - @Test - void regexValid_regex06_Exception3() { - PetriNet testNet = importRegexNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["regex06": new TextField(rawValue: "@aa.sk")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-regex06", thrown.getMessage()); - } - - @Test - void regexValid_regex06_Exception4() { - PetriNet testNet = importRegexNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["regex06": new TextField(rawValue: "tot ok@az.sk.so")])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-regex06", thrown.getMessage()); - } - - // BOOLEAN FIELD - @Test - void booleanValid_requiredTrue() { - PetriNet testNet = importBooleanNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["boolean_0": new BooleanField(rawValue:true)])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void booleanValid_requiredTrue_Exception() { - PetriNet testNet = importBooleanNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["boolean_0": new BooleanField(rawValue:false)])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-boolean", thrown.getMessage()); - } - - @Test - void booleanValid_requiredTrue_Exception2() { - PetriNet testNet = importBooleanNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["boolean_0": new BooleanField(rawValue: null)])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-boolean", thrown.getMessage()); - } - - // DATE FIELD - @Test - void dateValid_between_today() { - PetriNet testNet = importDateNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["date01": new DateField(rawValue: LocalDate.now())])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void dateValid_between_today_plusDay() { - PetriNet testNet = importDateNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["date01": new DateField(rawValue: LocalDate.now().plusDays(1))])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void dateValid_between_today_Exception() { - PetriNet testNet = importDateNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["date01": new DateField(rawValue: LocalDate.now().minusDays(1))])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-date01", thrown.getMessage()); - } - - @Test - void dateValid_between_past() { - PetriNet testNet = importDateNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["date02": new DateField(rawValue: LocalDate.now())])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void dateValid_between_past_minusDay() { - PetriNet testNet = importDateNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["date02": new DateField(rawValue: LocalDate.now().minusDays(1))])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void dateValid_between_past_Exception() { - PetriNet testNet = importDateNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["date02": new DateField(rawValue: LocalDate.now().plusDays(1))])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-date02", thrown.getMessage()); - } - - @Test - void dateValid_between_fromDate() { - PetriNet testNet = importDateNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["date03": new DateField(rawValue: LocalDate.of(2020, 3, 3))])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void dateValid_between_fromDate_today() { - PetriNet testNet = importDateNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["date03": new DateField(rawValue: LocalDate.now())])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void dateValid_between_fromDate_Exception() { - PetriNet testNet = importDateNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["date03": new DateField(rawValue: LocalDate.now().plusDays(1))])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-date03", thrown.getMessage()); - } - - @Test - void dateValid_between_fromDate_past() { - PetriNet testNet = importDateNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["date04": new DateField(rawValue: LocalDate.of(2020, 3, 3))])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void dateValid_between_fromDate_past_minusDay() { - PetriNet testNet = importDateNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["date04": new DateField(rawValue: LocalDate.of(2020, 3, 3))])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void dateValid_between_fromDate_past_Exception() { - PetriNet testNet = importDateNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - // TODO: release/8.0.0 should fail with 3.3.2020? yes from 6.4.0 - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["date04": new DateField(rawValue: LocalDate.of(2020, 3, 4))])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-date04", thrown.getMessage()); - } - - @Test - void dateValid_between_fromDate_toDate() { - PetriNet testNet = importDateNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["date05": new DateField(rawValue: LocalDate.of(2020, 1, 1))])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void dateValid_between_fromDate_toDate2() { - PetriNet testNet = importDateNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["date05": new DateField(rawValue: LocalDate.of(2022,3,3))])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void dateValid_workday() { - PetriNet testNet = importDateNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["date06": new DateField(rawValue: LocalDate.of(1994,7,4))])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void dateValid_workday_Exception() { - PetriNet testNet = importDateNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["date06": new DateField(rawValue: LocalDate.of(1994,7,3))])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-date06", thrown.getMessage()); - } - - @Test - void dateValid_weekend() { - PetriNet testNet = importDateNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["date07": new DateField(rawValue: LocalDate.of(1994,7,3))])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void dateValid_weekend_Exception() { - PetriNet testNet = importDateNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["date07": new DateField(rawValue: LocalDate.of(1994,7,4))])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-date07", thrown.getMessage()); - } - - // Number Field - @Test - void numberValid_odd() { - PetriNet testNet = importNumberNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["number01": new NumberField(rawValue: 3)])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void numberValid_odd_Exception() { - PetriNet testNet = importNumberNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["number01": new NumberField(rawValue: 2)])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-number01", thrown.getMessage()); - } - - @Test - void numberValid_even() { - PetriNet testNet = importNumberNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["number02": new NumberField(rawValue: 2)])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void numberValid_even_Exception() { - PetriNet testNet = importNumberNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["number02": new NumberField(rawValue: 3)])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-number02", thrown.getMessage()); - } - - @Test - void numberValid_positive() { - PetriNet testNet = importNumberNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["number03": new NumberField(rawValue: 1.25624)])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void numberValid_positive_Exception() { - PetriNet testNet = importNumberNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["number03": new NumberField(rawValue: -1.1558)])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-number03", thrown.getMessage()); - } - - @Test - void numberValid_negative() { - PetriNet testNet = importNumberNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["number04": new NumberField(rawValue: -1.25624)])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void numberValid_negative_Exception() { - PetriNet testNet = importNumberNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["number04": new NumberField(rawValue: 1.1558)])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-number04", thrown.getMessage()); - } - - @Test - void numberValid_decimal() { - PetriNet testNet = importNumberNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["number05": new NumberField(rawValue: 10)])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void numberValid_decimal_Exception() { - PetriNet testNet = importNumberNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["number05": new NumberField(rawValue: 10.1558d)])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-number05", thrown.getMessage()); - } - - @Test - void numberValid_inRange() { - PetriNet testNet = importNumberNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["number06": new NumberField(rawValue: 13.2452d)])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void numberValid_inRange_Exception() { - PetriNet testNet = importNumberNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["number06": new NumberField(rawValue: 9.1558)])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-number06", thrown.getMessage()); - } - - - @Test - void numberValid_inRange_odd() { - PetriNet testNet = importNumberNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - importHelper.setTaskData(task.getStringId(), new DataSet(["number07": new NumberField(rawValue: 1)])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - } - - @Test - void numberValid_inRange_odd_Exception() { - PetriNet testNet = importNumberNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["number07": new NumberField(rawValue: 2)])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-number07-1", thrown.getMessage()); - } - - @Test - void numberValid_inRange_odd_Exception2() { - PetriNet testNet = importNumberNet() - Case aCase = importHelper.createCase("TestCase", testNet) - assert aCase != null - Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() - assert task != null - - IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { - importHelper.setTaskData(task.getStringId(), new DataSet(["number07": new NumberField(rawValue: 7)])) - Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() - assert taskFinish != null - }) - Assertions.assertEquals("error-number07-2", thrown.getMessage()); - } +// @BeforeEach +// void setup() { +// testHelper.truncateDbs() +// } +// +// private PetriNet importTextNet() { +// PetriNet testNet = importHelper.createNet("validation/valid_text.xml", VersionType.MAJOR).get() +// assert testNet != null +// return testNet +// } +// +// private PetriNet importRegexNet() { +// PetriNet testNet = importHelper.createNet("validation/valid_regex.xml", VersionType.MAJOR).get() +// assert testNet != null +// return testNet +// } +// +// private PetriNet importBooleanNet() { +// PetriNet testNet = importHelper.createNet("validation/valid_boolean.xml", VersionType.MAJOR).get() +// assert testNet != null +// return testNet +// } +// +// private PetriNet importDateNet() { +// PetriNet testNet = importHelper.createNet("validation/valid_date.xml", VersionType.MAJOR).get() +// assert testNet != null +// return testNet +// } +// +// private PetriNet importNumberNet() { +// PetriNet testNet = importHelper.createNet("validation/valid_number.xml", VersionType.MAJOR).get() +// assert testNet != null +// return testNet +// } +// +// // TEXT FIELD +// @Test +// void textValid_email() { +// PetriNet testNet = importTextNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["text01": new TextField(rawValue: "test@netgrif.com")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void textValid_email2() { +// PetriNet testNet = importTextNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["text01": new TextField(rawValue: "test@netgrif.co.com")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void textValid_email3() { +// PetriNet testNet = importTextNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["text01": new TextField(rawValue: "te.st@netgrif.co.com")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void textValid_email_Exception() { +// PetriNet testNet = importTextNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["text01": new TextField(rawValue: "test@@aaa.com")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-text01", thrown.getMessage()); +// } +// +// @Test +// void textValid_email_Exception2() { +// PetriNet testNet = importTextNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["text01": new TextField(rawValue: "test@aaa.s")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-text01", thrown.getMessage()); +// } +// +// @Test +// void textValid_telnumber() { +// PetriNet testNet = importTextNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["text02": new TextField(rawValue: "+421 000 000 000")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void textValid_telnumber2() { +// PetriNet testNet = importTextNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["text02": new TextField(rawValue: "+421-000-000-000")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void textValid_telnumber3() { +// PetriNet testNet = importTextNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["text02": new TextField(rawValue: "0910-000-000")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void textValid_telnumber4() { +// PetriNet testNet = importTextNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["text02": new TextField(rawValue: "0910000000")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void textValid_telnumber_Exception() { +// PetriNet testNet = importTextNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["text02": new TextField(rawValue: "aaa 000 000 000")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-text02", thrown.getMessage()); +// } +// +// @Test +// void regexValid_regex01() { +// PetriNet testNet = importRegexNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["regex01": new TextField(rawValue: "12345")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void regexValid_regex02() { +// PetriNet testNet = importRegexNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["regex02": new TextField(rawValue: "AbC-012-Z9")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void regexValid_regex03() { +// PetriNet testNet = importRegexNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["regex03": new TextField(rawValue: "TOTOK4EveR09")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void regexValid_regex04() { +// PetriNet testNet = importRegexNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["regex04": new TextField(rawValue: "AA 09 bb")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void regexValid_regex05() { +// PetriNet testNet = importRegexNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["regex05": new TextField(rawValue: "A(:?BB+ľščťžýáíééé===é/*-+12154 ô/[]??.!\\.-úaa<>4 MM adsa!!; ff @#&")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void regexValid_regex05_2() { +// PetriNet testNet = importRegexNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["regex05": new TextField(rawValue: " ")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void regexValid_regex06() { +// PetriNet testNet = importRegexNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["regex06": new TextField(rawValue: "Toto00okJeTest012@netgrif.com")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void regexValid_regex06_2() { +// PetriNet testNet = importRegexNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["regex06": new TextField(rawValue: "e-mail.totok@netgrif.com")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void regexValid_regex06_3() { +// PetriNet testNet = importRegexNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["regex06": new TextField(rawValue: "totok@az.sk.so")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void regexValid_regex01_Exception() { +// PetriNet testNet = importRegexNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["regex01": new TextField(rawValue: "54544545454")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-regex01", thrown.getMessage()); +// } +// +// @Test +// void regexValid_regex01_Exception2() { +// PetriNet testNet = importRegexNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["regex01": new TextField(rawValue: "")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-regex01", thrown.getMessage()); +// } +// +// @Test +// void regexValid_regex01_Exception3() { +// PetriNet testNet = importRegexNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["regex01": new TextField(rawValue: "aav")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-regex01", thrown.getMessage()); +// } +// +// @Test +// void regexValid_regex02_Exception() { +// PetriNet testNet = importRegexNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["regex02": new TextField(rawValue: "AAAAAAAAAAAAAaaaaaaaaaa")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-regex02", thrown.getMessage()); +// } +// +// @Test +// void regexValid_regex02_Exception2() { +// PetriNet testNet = importRegexNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["regex02": new TextField(rawValue: "AAAAAAA??a")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-regex02", thrown.getMessage()); +// } +// +// @Test +// void regexValid_regex02_Exception3() { +// PetriNet testNet = importRegexNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["regex02": new TextField(rawValue: "-")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-regex02", thrown.getMessage()); +// } +// +// @Test +// void regexValid_regex03_Exception() { +// PetriNet testNet = importRegexNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["regex03": new TextField(rawValue: "aaaTOTOKaa1231")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-regex03", thrown.getMessage()); +// } +// +// @Test +// void regexValid_regex03_Exception2() { +// PetriNet testNet = importRegexNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["regex03": new TextField(rawValue: "TOTOK")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-regex03", thrown.getMessage()); +// } +// +// @Test +// void regexValid_regex03_Exception3() { +// PetriNet testNet = importRegexNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["regex03": new TextField(rawValue: "TOTOK4EveR0!")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-regex03", thrown.getMessage()); +// } +// +// @Test +// void regexValid_regex04_Exception() { +// PetriNet testNet = importRegexNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["regex04": new TextField(rawValue: "5412122121212121")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-regex04", thrown.getMessage()); +// } +// +// @Test +// void regexValid_regex05_Exception() { +// PetriNet testNet = importRegexNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["regex05": new TextField(rawValue: "")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-regex05", thrown.getMessage()); +// } +// +// @Test +// void regexValid_regex06_Exception() { +// PetriNet testNet = importRegexNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["regex06": new TextField(rawValue: "aaa@@@aaa.ss")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-regex06", thrown.getMessage()); +// } +// +// @Test +// void regexValid_regex06_Exception2() { +// PetriNet testNet = importRegexNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["regex06": new TextField(rawValue: "aaa@aa")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-regex06", thrown.getMessage()); +// } +// +// @Test +// void regexValid_regex06_Exception3() { +// PetriNet testNet = importRegexNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["regex06": new TextField(rawValue: "@aa.sk")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-regex06", thrown.getMessage()); +// } +// +// @Test +// void regexValid_regex06_Exception4() { +// PetriNet testNet = importRegexNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["regex06": new TextField(rawValue: "tot ok@az.sk.so")])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-regex06", thrown.getMessage()); +// } +// +// // BOOLEAN FIELD +// @Test +// void booleanValid_requiredTrue() { +// PetriNet testNet = importBooleanNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["boolean_0": new BooleanField(rawValue:true)])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void booleanValid_requiredTrue_Exception() { +// PetriNet testNet = importBooleanNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["boolean_0": new BooleanField(rawValue:false)])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-boolean", thrown.getMessage()); +// } +// +// @Test +// void booleanValid_requiredTrue_Exception2() { +// PetriNet testNet = importBooleanNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["boolean_0": new BooleanField(rawValue: null)])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-boolean", thrown.getMessage()); +// } +// +// // DATE FIELD +// @Test +// void dateValid_between_today() { +// PetriNet testNet = importDateNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["date01": new DateField(rawValue: LocalDate.now())])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void dateValid_between_today_plusDay() { +// PetriNet testNet = importDateNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["date01": new DateField(rawValue: LocalDate.now().plusDays(1))])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void dateValid_between_today_Exception() { +// PetriNet testNet = importDateNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["date01": new DateField(rawValue: LocalDate.now().minusDays(1))])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-date01", thrown.getMessage()); +// } +// +// @Test +// void dateValid_between_past() { +// PetriNet testNet = importDateNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["date02": new DateField(rawValue: LocalDate.now())])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void dateValid_between_past_minusDay() { +// PetriNet testNet = importDateNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["date02": new DateField(rawValue: LocalDate.now().minusDays(1))])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void dateValid_between_past_Exception() { +// PetriNet testNet = importDateNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["date02": new DateField(rawValue: LocalDate.now().plusDays(1))])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-date02", thrown.getMessage()); +// } +// +// @Test +// void dateValid_between_fromDate() { +// PetriNet testNet = importDateNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["date03": new DateField(rawValue: LocalDate.of(2020, 3, 3))])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void dateValid_between_fromDate_today() { +// PetriNet testNet = importDateNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["date03": new DateField(rawValue: LocalDate.now())])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void dateValid_between_fromDate_Exception() { +// PetriNet testNet = importDateNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["date03": new DateField(rawValue: LocalDate.now().plusDays(1))])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-date03", thrown.getMessage()); +// } +// +// @Test +// void dateValid_between_fromDate_past() { +// PetriNet testNet = importDateNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["date04": new DateField(rawValue: LocalDate.of(2020, 3, 3))])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void dateValid_between_fromDate_past_minusDay() { +// PetriNet testNet = importDateNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["date04": new DateField(rawValue: LocalDate.of(2020, 3, 3))])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void dateValid_between_fromDate_past_Exception() { +// PetriNet testNet = importDateNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// // TODO: release/8.0.0 should fail with 3.3.2020? yes from 6.4.0 +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["date04": new DateField(rawValue: LocalDate.of(2020, 3, 4))])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-date04", thrown.getMessage()); +// } +// +// @Test +// void dateValid_between_fromDate_toDate() { +// PetriNet testNet = importDateNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["date05": new DateField(rawValue: LocalDate.of(2020, 1, 1))])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void dateValid_between_fromDate_toDate2() { +// PetriNet testNet = importDateNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["date05": new DateField(rawValue: LocalDate.of(2022,3,3))])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void dateValid_workday() { +// PetriNet testNet = importDateNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["date06": new DateField(rawValue: LocalDate.of(1994,7,4))])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void dateValid_workday_Exception() { +// PetriNet testNet = importDateNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["date06": new DateField(rawValue: LocalDate.of(1994,7,3))])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-date06", thrown.getMessage()); +// } +// +// @Test +// void dateValid_weekend() { +// PetriNet testNet = importDateNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["date07": new DateField(rawValue: LocalDate.of(1994,7,3))])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void dateValid_weekend_Exception() { +// PetriNet testNet = importDateNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["date07": new DateField(rawValue: LocalDate.of(1994,7,4))])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-date07", thrown.getMessage()); +// } +// +// // Number Field +// @Test +// void numberValid_odd() { +// PetriNet testNet = importNumberNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["number01": new NumberField(rawValue: 3)])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void numberValid_odd_Exception() { +// PetriNet testNet = importNumberNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["number01": new NumberField(rawValue: 2)])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-number01", thrown.getMessage()); +// } +// +// @Test +// void numberValid_even() { +// PetriNet testNet = importNumberNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["number02": new NumberField(rawValue: 2)])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void numberValid_even_Exception() { +// PetriNet testNet = importNumberNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["number02": new NumberField(rawValue: 3)])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-number02", thrown.getMessage()); +// } +// +// @Test +// void numberValid_positive() { +// PetriNet testNet = importNumberNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["number03": new NumberField(rawValue: 1.25624)])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void numberValid_positive_Exception() { +// PetriNet testNet = importNumberNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["number03": new NumberField(rawValue: -1.1558)])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-number03", thrown.getMessage()); +// } +// +// @Test +// void numberValid_negative() { +// PetriNet testNet = importNumberNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["number04": new NumberField(rawValue: -1.25624)])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void numberValid_negative_Exception() { +// PetriNet testNet = importNumberNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["number04": new NumberField(rawValue: 1.1558)])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-number04", thrown.getMessage()); +// } +// +// @Test +// void numberValid_decimal() { +// PetriNet testNet = importNumberNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["number05": new NumberField(rawValue: 10)])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void numberValid_decimal_Exception() { +// PetriNet testNet = importNumberNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["number05": new NumberField(rawValue: 10.1558d)])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-number05", thrown.getMessage()); +// } +// +// @Test +// void numberValid_inRange() { +// PetriNet testNet = importNumberNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["number06": new NumberField(rawValue: 13.2452d)])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void numberValid_inRange_Exception() { +// PetriNet testNet = importNumberNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["number06": new NumberField(rawValue: 9.1558)])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-number06", thrown.getMessage()); +// } +// +// +// @Test +// void numberValid_inRange_odd() { +// PetriNet testNet = importNumberNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// importHelper.setTaskData(task.getStringId(), new DataSet(["number07": new NumberField(rawValue: 1)])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// } +// +// @Test +// void numberValid_inRange_odd_Exception() { +// PetriNet testNet = importNumberNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["number07": new NumberField(rawValue: 2)])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-number07-1", thrown.getMessage()); +// } +// +// @Test +// void numberValid_inRange_odd_Exception2() { +// PetriNet testNet = importNumberNet() +// Case aCase = importHelper.createCase("TestCase", testNet) +// assert aCase != null +// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() +// assert task != null +// +// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { +// importHelper.setTaskData(task.getStringId(), new DataSet(["number07": new NumberField(rawValue: 7)])) +// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() +// assert taskFinish != null +// }) +// Assertions.assertEquals("error-number07-2", thrown.getMessage()); +// } } diff --git a/src/test/groovy/com/netgrif/application/engine/validation/ValidationTestDynamic.groovy b/src/test/groovy/com/netgrif/application/engine/validation/ValidationTestDynamic.groovy new file mode 100644 index 00000000000..fff7286c3f4 --- /dev/null +++ b/src/test/groovy/com/netgrif/application/engine/validation/ValidationTestDynamic.groovy @@ -0,0 +1,118 @@ +package com.netgrif.application.engine.validation + +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.Field +import com.netgrif.application.engine.petrinet.domain.dataset.TextField +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.startup.ValidationRunner +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.repositories.CaseRepository +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 +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 +import org.springframework.test.context.ActiveProfiles +import org.springframework.test.context.junit.jupiter.SpringExtension + +@SpringBootTest +@ActiveProfiles(["test"]) +@ExtendWith(SpringExtension.class) +class ValidationTestDynamic { + + public static final String VALIDATION_PETRI_NET_IDENTIFIER = "validation" + public static final String VALIDATION_ACTIVE_FIELD_ID = "active" + + @Autowired + private ImportHelper importHelper + + @Autowired + private CaseRepository caseRepository + + @Autowired + private TestHelper testHelper + + @Autowired + private IPetriNetService petriNetService + + @Autowired + private SuperCreator superCreator + + @Autowired + private IWorkflowService workflowService + + @Autowired + private ITaskService taskService + +// @Autowired +// private ValidationRunner validationRunner + + @BeforeEach + void setup() { + testHelper.truncateDbs() +// +// validationRunner.run() + } + + private PetriNet importTextNet() { + PetriNet testNet = importHelper.createNet("validation/valid_text.xml", VersionType.MAJOR).get() + assert testNet != null + return testNet + } + + private Case createValidation(String name, String validationDefinitionGroovy, Boolean active = true) { + PetriNet net = petriNetService.getNewestVersionByIdentifier(VALIDATION_PETRI_NET_IDENTIFIER) + + Case validationCase = importHelper.createCase("Validation ${name}", net) + assert validationCase != null + + Task validationTask = importHelper.assignTaskToSuper("Init", validationCase.stringId).getTask() + assert validationTask != null + + SetDataEventOutcome outcome = importHelper.setTaskData("Init", validationCase.stringId, new DataSet([ + "name": new TextField(rawValue: name), + "validation_definition_groovy": new TextField(rawValue: validationDefinitionGroovy) + ] as Map>)) + assert outcome != null + + validationTask = importHelper.finishTaskAsSuper("Init", validationCase.stringId).getTask() + assert validationTask != null + + if (active) { + validationTask = importHelper.assignTaskToSuper("Activate", validationCase.stringId).getTask() + assert validationTask != null + + validationTask = importHelper.finishTaskAsSuper("Activate", validationCase.stringId).getTask() + assert validationTask != null + } + + validationCase = workflowService.findOne(validationCase.stringId) + assert validationCase.dataSet.get(VALIDATION_ACTIVE_FIELD_ID).rawValue == active + + return validationCase + } + + @Test + void textDynamic_validation() { + + createValidation("aaaa", "a -> thisField.rawValue.size() == a as Integer", true) + + PetriNet testNet = importTextNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["text06": new TextField(rawValue: "12345")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } +} diff --git a/src/test/resources/petriNets/validation/valid_text.xml b/src/test/resources/petriNets/validation/valid_text.xml index 6935722ddc2..145d70578ad 100644 --- a/src/test/resources/petriNets/validation/valid_text.xml +++ b/src/test/resources/petriNets/validation/valid_text.xml @@ -61,6 +61,21 @@ + + text06 + + <validations> + <validation> + <expression>aaaa number01.rawValue</expression> + <message>error-text06</message> + </validation> + </validations> + </data> + <data type="number"> + <id>number01</id> + <title/> + <init>5</init> + </data> <transition> <id>t1</id> <x>260</x> @@ -140,6 +155,20 @@ <appearance>outline</appearance> </layout> </dataRef> + <dataRef> + <id>text06</id> + <logic> + <behavior>editable</behavior> + </logic> + <layout> + <x>0</x> + <y>5</y> + <rows>1</rows> + <cols>4</cols> + <template>material</template> + <appearance>outline</appearance> + </layout> + </dataRef> </dataGroup> <event type="assign"> <id>t1_assign</id> From 3c60c2159de0531e956759abf113be7d8e5ff610 Mon Sep 17 00:00:00 2001 From: MartinSiran <matosiro4@gmail.com> Date: Mon, 17 Jun 2024 09:26:07 +0200 Subject: [PATCH 04/12] [NAE-1788] Validation register backend - reimplement original validations into validation delegate - resolve possible duplicities (field - validation name, register existing validation name) - review tests - except date/datetime between, text regex --- .../logic/action/ValidationDelegate.groovy | 132 ++ .../logic/action/ValidationExecutioner.groovy | 39 +- .../validations/ValidationRegistry.java | 3 + .../BooleanFieldValidationTest.groovy | 94 +- .../NumberFieldValidationTest.groovy | 180 +- .../validation/TextFieldValidationTest.groovy | 57 +- .../engine/validation/ValidationTest.groovy | 2035 +++++++++-------- .../validation/ValidationTestDynamic.groovy | 26 +- .../petriNets/validation/valid_boolean.xml | 2 +- 9 files changed, 1381 insertions(+), 1187 deletions(-) diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationDelegate.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationDelegate.groovy index 68f9570a61d..721bda02f35 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationDelegate.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationDelegate.groovy @@ -1,8 +1,140 @@ package com.netgrif.application.engine.petrinet.domain.dataset.logic.action + +import com.netgrif.application.engine.petrinet.domain.dataset.* import groovy.util.logging.Slf4j +import java.time.LocalDate +import java.time.LocalDateTime +import java.time.format.DateTimeFormatter +import java.time.format.DateTimeParseException + @Slf4j class ValidationDelegate { + public static final String FUTURE = 'future' + public static final String TODAY = 'today' + public static final String PAST = 'past' + public static final String NOW = 'now' + public static final String INF = 'inf' + public static final String TEL_NUMBER_REGEX = '^(?:\\+?(\\d{1,3}))?([-. (]*(\\d{3})[-. )]*)?((\\d{3})[-. ]*(\\d{2,4})(?:[-.x ]*(\\d+))?)$' + public static final String EMAIL_REGEX = '^[a-zA-Z0-9\\._\\%\\+\\-]+@[a-zA-Z0-9\\.\\-]+\\.[a-zA-Z]{2,}$' + + Field<?> thisField + + Closure<Boolean> notempty = { return thisField.rawValue != null } + + // boolean field validations + Closure<Boolean> requiredtrue = { return thisField instanceof BooleanField && notempty && thisField.rawValue == true } + + // date field validations + Closure<String> future = { return FUTURE } + Closure<String> today = { return TODAY } + Closure<String> past = { return PAST } + Closure<String> now = { return NOW } + + Closure<Boolean> between = { def from, def to -> // todo: retype everything into localdatetime + if (thisField !instanceof DateField || thisField !instanceof DateTimeField) { + return false + } + + LocalDateTime updateDate_TODAY = LocalDateTime.now() + + def fromDate = from instanceof String && parseStringToLocalDate(from) != null ? parseStringToLocalDate(from) : from + def toDate = to instanceof String && parseStringToLocalDate(to) != null ? parseStringToLocalDate(to) : to + + if ((fromDate == TODAY || fromDate == NOW) && toDate == FUTURE) { + if (thisField.rawValue < updateDate_TODAY) { + return false + } + } else if (fromDate == PAST && (toDate == TODAY || toDate == NOW)) { + if (thisField.rawValue > updateDate_TODAY) { + return false + } + } else if (fromDate == PAST && (toDate instanceof LocalDate)) { + if (thisField.rawValue > toDate) { + return false + } + } else if (fromDate == TODAY && (toDate instanceof LocalDate)) { + if (thisField.rawValue < toDate || thisField.rawValue > updateDate_TODAY) { + return false + } + } else if ((fromDate instanceof LocalDate) && toDate == TODAY) { + if (thisField.rawValue < fromDate || thisField.rawValue > updateDate_TODAY) { + return false + } + } else if (toDate == FUTURE && (fromDate instanceof LocalDate)) { + if (thisField.rawValue < fromDate) { + return false + } + } else if ((fromDate instanceof LocalDate) && (toDate instanceof LocalDate)) { + if (thisField.rawValue > toDate || thisField.rawValue < fromDate) { + return false + } + } + return true + } + + Closure<Boolean> workday = { return (thisField instanceof DateField || thisField instanceof DateTimeField) && notempty && !thisField.rawValue.dayOfWeek.isWeekend() } + + + Closure<Boolean> weekend = { return (thisField instanceof DateField || thisField instanceof DateTimeField) && notempty && thisField.rawValue.dayOfWeek.isWeekend() } + + protected static LocalDateTime parseStringToLocalDate(String stringDate) { + if (stringDate == null) { + return null + } + List<String> patterns = Arrays.asList("dd.MM.yyyy HH:mm:ss", "") + try { + return LocalDate.parse(stringDate, DateTimeFormatter.BASIC_ISO_DATE) + } catch (DateTimeParseException ignored) { + try { + return LocalDate.parse(stringDate, DateTimeFormatter.ISO_DATE) + } catch (DateTimeParseException ignored2) { + for (String pattern : patterns) { + try { + return LocalDate.parse(stringDate, DateTimeFormatter.ofPattern(pattern)) + } catch (DateTimeParseException | IllegalArgumentException ignored3) { + } + } + } + } + return null + } + + // number field validations + Closure<String> inf = { return INF } + + Closure<Boolean> odd = { return thisField instanceof NumberField && notempty && thisField.rawValue % 2 != 0 } + + Closure<Boolean> even = { return thisField instanceof NumberField && notempty && thisField.rawValue % 2 == 0 } + + Closure<Boolean> positive = { return thisField instanceof NumberField && notempty && thisField.rawValue >= 0 } + + Closure<Boolean> negative = { return thisField instanceof NumberField && notempty && thisField.rawValue <= 0 } + + Closure<Boolean> decimal = { return thisField instanceof NumberField && notempty && thisField.rawValue % 1 == 0 } + + Closure<Boolean> inrange = { def from, def to -> + if (from instanceof String && from.toLowerCase() == INF) { + from = Double.MIN_VALUE + } + + if (to instanceof String && to.toLowerCase() == INF) { + to = Double.MAX_VALUE + } + return thisField instanceof NumberField && notempty && thisField.rawValue >= from as Double && thisField.rawValue <= to as Double + } + + // text field validations + Closure<Boolean> regex = { String pattern -> return thisField instanceof TextField && notempty && thisField.rawValue ==~ pattern } + + Closure<Boolean> minlength = { Integer minLength -> return thisField instanceof TextField && notempty && (thisField.rawValue as String).length() >= minLength } + + Closure<Boolean> maxlength = { Integer maxLength -> return thisField instanceof TextField && notempty && (thisField.rawValue as String).length() <= maxLength } + + Closure<Boolean> telnumber = { -> return regex(TEL_NUMBER_REGEX) } + + Closure<Boolean> email = { -> return regex(EMAIL_REGEX) } + } diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy index a6157996a72..740ba9fb740 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy @@ -5,6 +5,7 @@ import com.netgrif.application.engine.petrinet.domain.dataset.Field import com.netgrif.application.engine.petrinet.domain.dataset.Validation import com.netgrif.application.engine.validations.ValidationRegistry import com.netgrif.application.engine.workflow.domain.Case +import groovy.json.StringEscapeUtils import groovy.util.logging.Slf4j import org.springframework.beans.factory.annotation.Autowired import org.springframework.beans.factory.annotation.Lookup @@ -27,32 +28,46 @@ abstract class ValidationExecutioner { if (validations) { log.info("Validations: ${validations.collect {it.rule }}") - def delegate = getValidationDelegate() - - initCode(delegate, useCase, field, this.registry.getValidationNames()) + ValidationDelegate delegate = initDelegate(useCase, field, this.registry.getValidationNames()) for (Validation validation : validations) { - Closure<Boolean> code = (Closure<Boolean>) this.shellFactory.getGroovyShell().evaluate("{ -> " + validation.rule + "}") - code = code.rehydrate(delegate, code.owner, code.thisObject) - if (!code()) { + Closure<Boolean> code = initCode(validation.rule, delegate) + def result = code() + if (result !instanceof Boolean) { + result = result() + } + if (!result) { throw new IllegalArgumentException(validation.message.toString()) } } } } - protected Closure<Boolean> getValidationCode(String validationName, Field<?> thisField) { - Closure<Boolean> code = this.registry.getValidation(validationName) - code.delegate.metaClass.thisField = thisField - return code.rehydrate(code.delegate, code.owner, code.thisObject) + protected Closure<Boolean> getValidationCode(String validationName) { + return this.registry.getValidation(validationName) + } + + protected Closure<Boolean> initCode(String rule, ValidationDelegate delegate) { + Closure<Boolean> code = this.shellFactory.getGroovyShell().evaluate("{ -> "+ rule + " }") as Closure<Boolean> + return code.rehydrate(delegate, code.owner, code.thisObject) } - protected void initCode(def delegate, Case useCase, Field<?> thisField, List<String> validationNames) { + protected ValidationDelegate initDelegate(Case useCase, Field<?> thisField, List<String> validationNames) { + ValidationDelegate delegate = getValidationDelegate() delegate.metaClass.useCase = useCase useCase.dataSet.fields.values().forEach { Field<?> field -> delegate.metaClass."$field.importId" = field } + + Set commonFieldValidationNames = useCase.dataSet.fields.keySet() + commonFieldValidationNames.retainAll(validationNames) + if (!commonFieldValidationNames.isEmpty()) { + log.warn("Ignoring validations {} for case [{}]: field names are identical with validation names", commonFieldValidationNames, useCase.stringId) + validationNames -= commonFieldValidationNames + } validationNames.forEach { validationName -> - delegate.metaClass."$validationName" = getValidationCode(validationName, thisField) + delegate.metaClass."$validationName" = getValidationCode(validationName) } + delegate.thisField = thisField + return delegate } } diff --git a/src/main/java/com/netgrif/application/engine/validations/ValidationRegistry.java b/src/main/java/com/netgrif/application/engine/validations/ValidationRegistry.java index 37591819d14..2c70b75202c 100644 --- a/src/main/java/com/netgrif/application/engine/validations/ValidationRegistry.java +++ b/src/main/java/com/netgrif/application/engine/validations/ValidationRegistry.java @@ -14,6 +14,9 @@ public final class ValidationRegistry { private final Map<String, Closure<Boolean>> validationsMap = new ConcurrentHashMap<>(); public Closure<Boolean> addValidation(String name, Closure<Boolean> closure) { + if (validationsMap.containsKey(name)) { + throw new IllegalArgumentException("Validation with name " + name + " already exists."); + } return validationsMap.put(name, closure); } diff --git a/src/test/groovy/com/netgrif/application/engine/validation/BooleanFieldValidationTest.groovy b/src/test/groovy/com/netgrif/application/engine/validation/BooleanFieldValidationTest.groovy index bdf2371fc23..f2672a31e6c 100644 --- a/src/test/groovy/com/netgrif/application/engine/validation/BooleanFieldValidationTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/validation/BooleanFieldValidationTest.groovy @@ -1,86 +1,62 @@ package com.netgrif.application.engine.validation import com.netgrif.application.engine.TestHelper -import com.netgrif.application.engine.petrinet.domain.I18nString import com.netgrif.application.engine.petrinet.domain.dataset.BooleanField -//import com.netgrif.application.engine.validation.domain.ValidationDataInput -//import com.netgrif.application.engine.validation.models.BooleanFieldValidation -import org.junit.jupiter.api.Assertions +import com.netgrif.application.engine.petrinet.domain.dataset.logic.action.ValidationDelegate import org.junit.jupiter.api.BeforeEach 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 -import org.springframework.context.i18n.LocaleContextHolder import org.springframework.test.context.ActiveProfiles import org.springframework.test.context.junit.jupiter.SpringExtension -import java.util.stream.Collectors @SpringBootTest @ActiveProfiles(["test"]) @ExtendWith(SpringExtension.class) class BooleanFieldValidationTest { - public static final String ErrorMessage = "Invalid Field value" @Autowired private TestHelper testHelper + private static ValidationDelegate getValidationDelegate() { + return new ValidationDelegate() + } + @BeforeEach void setup() { testHelper.truncateDbs() } -// @Test -// void requiredTrue() { -// BooleanFieldValidation booleanFieldValidation = new BooleanFieldValidation() -// BooleanField dataField = new BooleanField(rawValue: true) -// I18nString validMessage = new I18nString(ErrorMessage) -// List<String> rules = [] -// ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) -// -// booleanFieldValidation.requiredtrue(input) -// } -// -// @Test -// void notempty() { -// BooleanFieldValidation booleanFieldValidation = new BooleanFieldValidation() -// BooleanField dataField = new BooleanField(rawValue: true) -// I18nString validMessage = new I18nString(ErrorMessage) -// List<String> rules = [] -// ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) -// -// booleanFieldValidation.notempty(input) -// } -// -// -// @Test -// void notempty_Exception() { -// BooleanFieldValidation booleanFieldValidation = new BooleanFieldValidation() -// BooleanField dataField = new BooleanField() -// dataField.value = null -// I18nString validMessage = new I18nString(ErrorMessage) -// List<String> rules = [] -// ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// booleanFieldValidation.notempty(input) -// }) -// Assertions.assertEquals(ErrorMessage, thrown.getMessage()); -// } -// -// @Test -// void notempty_Exception2() { -// BooleanFieldValidation booleanFieldValidation = new BooleanFieldValidation() -// BooleanField dataField = new BooleanField() -// dataField.value = null -// I18nString validMessage = new I18nString(ErrorMessage) -// List<String> rules = [] -// ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// booleanFieldValidation.notempty(input) -// }) -// Assertions.assertEquals(ErrorMessage, thrown.getMessage()); -// } + @Test + void requiredTrue() { + ValidationDelegate delegate = getValidationDelegate() + delegate.thisField = new BooleanField(rawValue: true) + + assert delegate.requiredtrue() + } + @Test + void requiredTrue_fail() { + ValidationDelegate delegate = getValidationDelegate() + delegate.thisField = new BooleanField(rawValue: false) + + assert !delegate.requiredtrue() + } + + @Test + void notempty() { + ValidationDelegate delegate = getValidationDelegate() + delegate.thisField = new BooleanField(rawValue: true) + + assert delegate.notempty() + } + + @Test + void notempty_fail() { + ValidationDelegate delegate = getValidationDelegate() + delegate.thisField = new BooleanField(rawValue: null) + + assert !delegate.notempty() + } } diff --git a/src/test/groovy/com/netgrif/application/engine/validation/NumberFieldValidationTest.groovy b/src/test/groovy/com/netgrif/application/engine/validation/NumberFieldValidationTest.groovy index 2714f105022..26f93a9aeb7 100644 --- a/src/test/groovy/com/netgrif/application/engine/validation/NumberFieldValidationTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/validation/NumberFieldValidationTest.groovy @@ -1,100 +1,138 @@ package com.netgrif.application.engine.validation import com.netgrif.application.engine.TestHelper -import com.netgrif.application.engine.petrinet.domain.I18nString import com.netgrif.application.engine.petrinet.domain.dataset.NumberField -//import com.netgrif.application.engine.validation.domain.ValidationDataInput -//import com.netgrif.application.engine.validation.models.NumberFieldValidation +import com.netgrif.application.engine.petrinet.domain.dataset.logic.action.ValidationDelegate import org.junit.jupiter.api.BeforeEach 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 -import org.springframework.context.i18n.LocaleContextHolder import org.springframework.test.context.ActiveProfiles import org.springframework.test.context.junit.jupiter.SpringExtension -import java.util.stream.Collectors +import static org.junit.jupiter.api.Assertions.assertThrows @SpringBootTest @ActiveProfiles(["test"]) @ExtendWith(SpringExtension.class) class NumberFieldValidationTest { + private static final INF = 'inf' @Autowired private TestHelper testHelper + private static ValidationDelegate getValidationDelegate() { + return new ValidationDelegate() + } + @BeforeEach void setup() { testHelper.truncateDbs() } + @Test + void odd() { + ValidationDelegate delegate = getValidationDelegate() + delegate.thisField = new NumberField(rawValue: 5) + + assert delegate.odd() + } + + @Test + void odd_fail() { + ValidationDelegate delegate = getValidationDelegate() + delegate.thisField = new NumberField(rawValue: 4) + + assert !delegate.odd() + } + + @Test + void even() { + ValidationDelegate delegate = getValidationDelegate() + delegate.thisField = new NumberField(rawValue: 4) + + assert delegate.even() + } + + @Test + void even_fail() { + ValidationDelegate delegate = getValidationDelegate() + delegate.thisField = new NumberField(rawValue: 5) + + assert !delegate.even() + } + + @Test + void positive() { + ValidationDelegate delegate = getValidationDelegate() + delegate.thisField = new NumberField(rawValue: 4) + + assert delegate.positive() + } + + @Test + void positive_fail() { + ValidationDelegate delegate = getValidationDelegate() + delegate.thisField = new NumberField(rawValue: -4) + + assert delegate.positive() + } + + @Test + void negative() { + ValidationDelegate delegate = getValidationDelegate() + delegate.thisField = new NumberField(rawValue: -4) -// @Test -// void odd() { -// NumberFieldValidation numberFieldValidation = new NumberFieldValidation() -// NumberField dataField = new NumberField(rawValue: 5) -// I18nString validMessage = new I18nString("Invalid Field value") -// List<String> rules = [] -// ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) -// -// numberFieldValidation.odd(input) -// } -// -// -// @Test -// void even() { -// NumberFieldValidation numberFieldValidation = new NumberFieldValidation() -// NumberField dataField = new NumberField(rawValue: 4) -// I18nString validMessage = new I18nString("Invalid Field value") -// List<String> rules = [] -// ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) -// -// numberFieldValidation.even(input) -// } -// -// @Test -// void positive() { -// NumberFieldValidation numberFieldValidation = new NumberFieldValidation() -// NumberField dataField = new NumberField(rawValue: 4) -// I18nString validMessage = new I18nString("Invalid Field value") -// List<String> rules = [] -// ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) -// -// numberFieldValidation.positive(input) -// } -// -// @Test -// void positivenegative() { -// NumberFieldValidation numberFieldValidation = new NumberFieldValidation() -// NumberField dataField = new NumberField(rawValue: -4) -// I18nString validMessage = new I18nString("Invalid Field value") -// List<String> rules = [] -// ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) -// -// numberFieldValidation.negative(input) -// } -// -// @Test -// void decimal() { -// NumberFieldValidation numberFieldValidation = new NumberFieldValidation() -// NumberField dataField = new NumberField(rawValue: 4) -// I18nString validMessage = new I18nString("Invalid Field value") -// List<String> rules = [] -// ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) -// -// numberFieldValidation.decimal(input) -// } -// -// @Test -// void inrange() { -// NumberFieldValidation numberFieldValidation = new NumberFieldValidation() -// NumberField dataField = new NumberField(rawValue: 7) -// I18nString validMessage = new I18nString("Invalid Field value") -// List<String> rules = ["5,10"] -// ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) -// -// numberFieldValidation.inrange(input) -// } + assert delegate.negative() + } + + @Test + void negative_fail() { + ValidationDelegate delegate = getValidationDelegate() + delegate.thisField = new NumberField(rawValue: 4) + + assert !delegate.negative() + } + + @Test + void decimal() { + ValidationDelegate delegate = getValidationDelegate() + delegate.thisField = new NumberField(rawValue: 4) + + assert delegate.decimal() + } + + @Test + void decimal_fail() { + ValidationDelegate delegate = getValidationDelegate() + delegate.thisField = new NumberField(rawValue: 4.1) + + assert !delegate.decimal() + } + + @Test + void inrange() { + ValidationDelegate delegate = getValidationDelegate() + delegate.thisField = new NumberField(rawValue: 7) + + assert delegate.inrange(5, 10) + + assert delegate.inrange(INF, 10) + + assert delegate.inrange(5, INF) + + assert delegate.inrange(INF, INF) + + assert delegate.inrange("5", "10") + } + + @Test + void inrange_fail() { + ValidationDelegate delegate = getValidationDelegate() + delegate.thisField = new NumberField(rawValue: 7) + + assertThrows(NumberFormatException.class, { !delegate.inrange('totok', INF) }) + } } diff --git a/src/test/groovy/com/netgrif/application/engine/validation/TextFieldValidationTest.groovy b/src/test/groovy/com/netgrif/application/engine/validation/TextFieldValidationTest.groovy index 7c7548c72f7..6873268df31 100644 --- a/src/test/groovy/com/netgrif/application/engine/validation/TextFieldValidationTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/validation/TextFieldValidationTest.groovy @@ -3,6 +3,8 @@ package com.netgrif.application.engine.validation import com.netgrif.application.engine.TestHelper import com.netgrif.application.engine.petrinet.domain.I18nString import com.netgrif.application.engine.petrinet.domain.dataset.TextField +import com.netgrif.application.engine.petrinet.domain.dataset.logic.action.ValidationDelegate + //import com.netgrif.application.engine.validation.domain.ValidationDataInput //import com.netgrif.application.engine.validation.models.TextFieldValidation import org.junit.jupiter.api.Assertions @@ -22,40 +24,39 @@ import java.util.stream.Collectors @ExtendWith(SpringExtension.class) class TextFieldValidationTest { - public static final String ErrorMessage = "Invalid Field value" @Autowired private TestHelper testHelper + private static ValidationDelegate getValidationDelegate() { + return new ValidationDelegate() + } + @BeforeEach void setup() { testHelper.truncateDbs() } -// @Test -// void minlength_Exception() { -// TextFieldValidation textFieldValidation = new TextFieldValidation() -// TextField dataField = new TextField(rawValue: 'totok') -// I18nString validMessage = new I18nString(ErrorMessage) -// List<String> rules = ["minlength","6"] -// ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// textFieldValidation.minlength(input) -// }) -// Assertions.assertEquals(ErrorMessage, thrown.getMessage()); -// } -// -// @Test -// void maxlength_Exception() { -// TextFieldValidation textFieldValidation = new TextFieldValidation() -// TextField dataField = new TextField(rawValue: 'totok') -// I18nString validMessage = new I18nString(ErrorMessage) -// List<String> rules = ["maxlength","4"] -// ValidationDataInput input = new ValidationDataInput(dataField, validMessage, LocaleContextHolder.getLocale(), rules.stream().skip(1).collect(Collectors.joining(" "))) -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// textFieldValidation.maxlength(input) -// }) -// Assertions.assertEquals(ErrorMessage, thrown.getMessage()); -// } + @Test + void minlength() { + ValidationDelegate delegate = getValidationDelegate() + delegate.thisField = new TextField(rawValue: 'totok') + + assert !delegate.minlength(6) + + assert delegate.minlength(5) + + assert delegate.minlength(4) + } + + @Test + void maxlength() { + ValidationDelegate delegate = getValidationDelegate() + delegate.thisField = new TextField(rawValue: 'totok') + + assert !delegate.maxlength(4) + + assert delegate.maxlength(5) + + assert delegate.maxlength(6) + } } diff --git a/src/test/groovy/com/netgrif/application/engine/validation/ValidationTest.groovy b/src/test/groovy/com/netgrif/application/engine/validation/ValidationTest.groovy index d99c4a5044e..a0b5eb2288e 100644 --- a/src/test/groovy/com/netgrif/application/engine/validation/ValidationTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/validation/ValidationTest.groovy @@ -14,9 +14,9 @@ import com.netgrif.application.engine.workflow.domain.Case import com.netgrif.application.engine.workflow.domain.Task import com.netgrif.application.engine.workflow.domain.repositories.CaseRepository import com.netgrif.application.engine.workflow.web.responsebodies.DataSet -import org.junit.Ignore import org.junit.jupiter.api.Assertions 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 @@ -25,7 +25,6 @@ import org.springframework.test.context.ActiveProfiles import org.springframework.test.context.junit.jupiter.SpringExtension import java.time.LocalDate -import java.time.format.DateTimeFormatter @SpringBootTest @ActiveProfiles(["test"]) @@ -47,1013 +46,1027 @@ class ValidationTest { @Autowired private SuperCreator superCreator -// @BeforeEach -// void setup() { -// testHelper.truncateDbs() -// } -// -// private PetriNet importTextNet() { -// PetriNet testNet = importHelper.createNet("validation/valid_text.xml", VersionType.MAJOR).get() -// assert testNet != null -// return testNet -// } -// -// private PetriNet importRegexNet() { -// PetriNet testNet = importHelper.createNet("validation/valid_regex.xml", VersionType.MAJOR).get() -// assert testNet != null -// return testNet -// } -// -// private PetriNet importBooleanNet() { -// PetriNet testNet = importHelper.createNet("validation/valid_boolean.xml", VersionType.MAJOR).get() -// assert testNet != null -// return testNet -// } -// -// private PetriNet importDateNet() { -// PetriNet testNet = importHelper.createNet("validation/valid_date.xml", VersionType.MAJOR).get() -// assert testNet != null -// return testNet -// } -// -// private PetriNet importNumberNet() { -// PetriNet testNet = importHelper.createNet("validation/valid_number.xml", VersionType.MAJOR).get() -// assert testNet != null -// return testNet -// } -// -// // TEXT FIELD -// @Test -// void textValid_email() { -// PetriNet testNet = importTextNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["text01": new TextField(rawValue: "test@netgrif.com")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void textValid_email2() { -// PetriNet testNet = importTextNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["text01": new TextField(rawValue: "test@netgrif.co.com")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void textValid_email3() { -// PetriNet testNet = importTextNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["text01": new TextField(rawValue: "te.st@netgrif.co.com")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void textValid_email_Exception() { -// PetriNet testNet = importTextNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["text01": new TextField(rawValue: "test@@aaa.com")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-text01", thrown.getMessage()); -// } -// -// @Test -// void textValid_email_Exception2() { -// PetriNet testNet = importTextNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["text01": new TextField(rawValue: "test@aaa.s")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-text01", thrown.getMessage()); -// } -// -// @Test -// void textValid_telnumber() { -// PetriNet testNet = importTextNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["text02": new TextField(rawValue: "+421 000 000 000")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void textValid_telnumber2() { -// PetriNet testNet = importTextNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["text02": new TextField(rawValue: "+421-000-000-000")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void textValid_telnumber3() { -// PetriNet testNet = importTextNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["text02": new TextField(rawValue: "0910-000-000")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void textValid_telnumber4() { -// PetriNet testNet = importTextNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["text02": new TextField(rawValue: "0910000000")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void textValid_telnumber_Exception() { -// PetriNet testNet = importTextNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["text02": new TextField(rawValue: "aaa 000 000 000")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-text02", thrown.getMessage()); -// } -// -// @Test -// void regexValid_regex01() { -// PetriNet testNet = importRegexNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["regex01": new TextField(rawValue: "12345")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void regexValid_regex02() { -// PetriNet testNet = importRegexNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["regex02": new TextField(rawValue: "AbC-012-Z9")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void regexValid_regex03() { -// PetriNet testNet = importRegexNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["regex03": new TextField(rawValue: "TOTOK4EveR09")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void regexValid_regex04() { -// PetriNet testNet = importRegexNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["regex04": new TextField(rawValue: "AA 09 bb")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void regexValid_regex05() { -// PetriNet testNet = importRegexNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["regex05": new TextField(rawValue: "A(:?BB+ľščťžýáíééé===é/*-+12154 ô/[]??.!\\.-úaa<>4 MM adsa!!; ff @#&")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void regexValid_regex05_2() { -// PetriNet testNet = importRegexNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["regex05": new TextField(rawValue: " ")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void regexValid_regex06() { -// PetriNet testNet = importRegexNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["regex06": new TextField(rawValue: "Toto00okJeTest012@netgrif.com")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void regexValid_regex06_2() { -// PetriNet testNet = importRegexNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["regex06": new TextField(rawValue: "e-mail.totok@netgrif.com")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void regexValid_regex06_3() { -// PetriNet testNet = importRegexNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["regex06": new TextField(rawValue: "totok@az.sk.so")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void regexValid_regex01_Exception() { -// PetriNet testNet = importRegexNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["regex01": new TextField(rawValue: "54544545454")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-regex01", thrown.getMessage()); -// } -// -// @Test -// void regexValid_regex01_Exception2() { -// PetriNet testNet = importRegexNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["regex01": new TextField(rawValue: "")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-regex01", thrown.getMessage()); -// } -// -// @Test -// void regexValid_regex01_Exception3() { -// PetriNet testNet = importRegexNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["regex01": new TextField(rawValue: "aav")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-regex01", thrown.getMessage()); -// } -// -// @Test -// void regexValid_regex02_Exception() { -// PetriNet testNet = importRegexNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["regex02": new TextField(rawValue: "AAAAAAAAAAAAAaaaaaaaaaa")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-regex02", thrown.getMessage()); -// } -// -// @Test -// void regexValid_regex02_Exception2() { -// PetriNet testNet = importRegexNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["regex02": new TextField(rawValue: "AAAAAAA??a")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-regex02", thrown.getMessage()); -// } -// -// @Test -// void regexValid_regex02_Exception3() { -// PetriNet testNet = importRegexNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["regex02": new TextField(rawValue: "-")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-regex02", thrown.getMessage()); -// } -// -// @Test -// void regexValid_regex03_Exception() { -// PetriNet testNet = importRegexNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["regex03": new TextField(rawValue: "aaaTOTOKaa1231")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-regex03", thrown.getMessage()); -// } -// -// @Test -// void regexValid_regex03_Exception2() { -// PetriNet testNet = importRegexNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["regex03": new TextField(rawValue: "TOTOK")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-regex03", thrown.getMessage()); -// } -// -// @Test -// void regexValid_regex03_Exception3() { -// PetriNet testNet = importRegexNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["regex03": new TextField(rawValue: "TOTOK4EveR0!")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-regex03", thrown.getMessage()); -// } -// -// @Test -// void regexValid_regex04_Exception() { -// PetriNet testNet = importRegexNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["regex04": new TextField(rawValue: "5412122121212121")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-regex04", thrown.getMessage()); -// } -// -// @Test -// void regexValid_regex05_Exception() { -// PetriNet testNet = importRegexNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["regex05": new TextField(rawValue: "")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-regex05", thrown.getMessage()); -// } -// -// @Test -// void regexValid_regex06_Exception() { -// PetriNet testNet = importRegexNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["regex06": new TextField(rawValue: "aaa@@@aaa.ss")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-regex06", thrown.getMessage()); -// } -// -// @Test -// void regexValid_regex06_Exception2() { -// PetriNet testNet = importRegexNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["regex06": new TextField(rawValue: "aaa@aa")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-regex06", thrown.getMessage()); -// } -// -// @Test -// void regexValid_regex06_Exception3() { -// PetriNet testNet = importRegexNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["regex06": new TextField(rawValue: "@aa.sk")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-regex06", thrown.getMessage()); -// } -// -// @Test -// void regexValid_regex06_Exception4() { -// PetriNet testNet = importRegexNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["regex06": new TextField(rawValue: "tot ok@az.sk.so")])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-regex06", thrown.getMessage()); -// } -// -// // BOOLEAN FIELD -// @Test -// void booleanValid_requiredTrue() { -// PetriNet testNet = importBooleanNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["boolean_0": new BooleanField(rawValue:true)])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void booleanValid_requiredTrue_Exception() { -// PetriNet testNet = importBooleanNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["boolean_0": new BooleanField(rawValue:false)])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-boolean", thrown.getMessage()); -// } -// -// @Test -// void booleanValid_requiredTrue_Exception2() { -// PetriNet testNet = importBooleanNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["boolean_0": new BooleanField(rawValue: null)])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-boolean", thrown.getMessage()); -// } -// -// // DATE FIELD -// @Test -// void dateValid_between_today() { -// PetriNet testNet = importDateNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["date01": new DateField(rawValue: LocalDate.now())])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void dateValid_between_today_plusDay() { -// PetriNet testNet = importDateNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["date01": new DateField(rawValue: LocalDate.now().plusDays(1))])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void dateValid_between_today_Exception() { -// PetriNet testNet = importDateNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["date01": new DateField(rawValue: LocalDate.now().minusDays(1))])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-date01", thrown.getMessage()); -// } -// -// @Test -// void dateValid_between_past() { -// PetriNet testNet = importDateNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["date02": new DateField(rawValue: LocalDate.now())])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void dateValid_between_past_minusDay() { -// PetriNet testNet = importDateNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["date02": new DateField(rawValue: LocalDate.now().minusDays(1))])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void dateValid_between_past_Exception() { -// PetriNet testNet = importDateNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["date02": new DateField(rawValue: LocalDate.now().plusDays(1))])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-date02", thrown.getMessage()); -// } -// -// @Test -// void dateValid_between_fromDate() { -// PetriNet testNet = importDateNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["date03": new DateField(rawValue: LocalDate.of(2020, 3, 3))])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void dateValid_between_fromDate_today() { -// PetriNet testNet = importDateNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["date03": new DateField(rawValue: LocalDate.now())])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void dateValid_between_fromDate_Exception() { -// PetriNet testNet = importDateNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["date03": new DateField(rawValue: LocalDate.now().plusDays(1))])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-date03", thrown.getMessage()); -// } -// -// @Test -// void dateValid_between_fromDate_past() { -// PetriNet testNet = importDateNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["date04": new DateField(rawValue: LocalDate.of(2020, 3, 3))])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void dateValid_between_fromDate_past_minusDay() { -// PetriNet testNet = importDateNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["date04": new DateField(rawValue: LocalDate.of(2020, 3, 3))])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void dateValid_between_fromDate_past_Exception() { -// PetriNet testNet = importDateNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// // TODO: release/8.0.0 should fail with 3.3.2020? yes from 6.4.0 -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["date04": new DateField(rawValue: LocalDate.of(2020, 3, 4))])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-date04", thrown.getMessage()); -// } -// -// @Test -// void dateValid_between_fromDate_toDate() { -// PetriNet testNet = importDateNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["date05": new DateField(rawValue: LocalDate.of(2020, 1, 1))])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void dateValid_between_fromDate_toDate2() { -// PetriNet testNet = importDateNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["date05": new DateField(rawValue: LocalDate.of(2022,3,3))])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void dateValid_workday() { -// PetriNet testNet = importDateNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["date06": new DateField(rawValue: LocalDate.of(1994,7,4))])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void dateValid_workday_Exception() { -// PetriNet testNet = importDateNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["date06": new DateField(rawValue: LocalDate.of(1994,7,3))])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-date06", thrown.getMessage()); -// } -// -// @Test -// void dateValid_weekend() { -// PetriNet testNet = importDateNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["date07": new DateField(rawValue: LocalDate.of(1994,7,3))])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void dateValid_weekend_Exception() { -// PetriNet testNet = importDateNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["date07": new DateField(rawValue: LocalDate.of(1994,7,4))])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-date07", thrown.getMessage()); -// } -// -// // Number Field -// @Test -// void numberValid_odd() { -// PetriNet testNet = importNumberNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["number01": new NumberField(rawValue: 3)])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void numberValid_odd_Exception() { -// PetriNet testNet = importNumberNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["number01": new NumberField(rawValue: 2)])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-number01", thrown.getMessage()); -// } -// -// @Test -// void numberValid_even() { -// PetriNet testNet = importNumberNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["number02": new NumberField(rawValue: 2)])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void numberValid_even_Exception() { -// PetriNet testNet = importNumberNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["number02": new NumberField(rawValue: 3)])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-number02", thrown.getMessage()); -// } -// -// @Test -// void numberValid_positive() { -// PetriNet testNet = importNumberNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["number03": new NumberField(rawValue: 1.25624)])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void numberValid_positive_Exception() { -// PetriNet testNet = importNumberNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["number03": new NumberField(rawValue: -1.1558)])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-number03", thrown.getMessage()); -// } -// -// @Test -// void numberValid_negative() { -// PetriNet testNet = importNumberNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["number04": new NumberField(rawValue: -1.25624)])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void numberValid_negative_Exception() { -// PetriNet testNet = importNumberNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["number04": new NumberField(rawValue: 1.1558)])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-number04", thrown.getMessage()); -// } -// -// @Test -// void numberValid_decimal() { -// PetriNet testNet = importNumberNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["number05": new NumberField(rawValue: 10)])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void numberValid_decimal_Exception() { -// PetriNet testNet = importNumberNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["number05": new NumberField(rawValue: 10.1558d)])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-number05", thrown.getMessage()); -// } -// -// @Test -// void numberValid_inRange() { -// PetriNet testNet = importNumberNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["number06": new NumberField(rawValue: 13.2452d)])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void numberValid_inRange_Exception() { -// PetriNet testNet = importNumberNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["number06": new NumberField(rawValue: 9.1558)])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-number06", thrown.getMessage()); -// } -// -// -// @Test -// void numberValid_inRange_odd() { -// PetriNet testNet = importNumberNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// importHelper.setTaskData(task.getStringId(), new DataSet(["number07": new NumberField(rawValue: 1)])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// } -// -// @Test -// void numberValid_inRange_odd_Exception() { -// PetriNet testNet = importNumberNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["number07": new NumberField(rawValue: 2)])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-number07-1", thrown.getMessage()); -// } -// -// @Test -// void numberValid_inRange_odd_Exception2() { -// PetriNet testNet = importNumberNet() -// Case aCase = importHelper.createCase("TestCase", testNet) -// assert aCase != null -// Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() -// assert task != null -// -// IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { -// importHelper.setTaskData(task.getStringId(), new DataSet(["number07": new NumberField(rawValue: 7)])) -// Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() -// assert taskFinish != null -// }) -// Assertions.assertEquals("error-number07-2", thrown.getMessage()); -// } + @BeforeEach + void setup() { + testHelper.truncateDbs() + } + + private PetriNet importTextNet() { + PetriNet testNet = importHelper.createNet("validation/valid_text.xml", VersionType.MAJOR).get() + assert testNet != null + return testNet + } + + private PetriNet importRegexNet() { + PetriNet testNet = importHelper.createNet("validation/valid_regex.xml", VersionType.MAJOR).get() + assert testNet != null + return testNet + } + + private PetriNet importBooleanNet() { + PetriNet testNet = importHelper.createNet("validation/valid_boolean.xml", VersionType.MAJOR).get() + assert testNet != null + return testNet + } + + private PetriNet importDateNet() { + PetriNet testNet = importHelper.createNet("validation/valid_date.xml", VersionType.MAJOR).get() + assert testNet != null + return testNet + } + + private PetriNet importNumberNet() { + PetriNet testNet = importHelper.createNet("validation/valid_number.xml", VersionType.MAJOR).get() + assert testNet != null + return testNet + } + + // TEXT FIELD + @Test + void textValid_email() { + PetriNet testNet = importTextNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["text01": new TextField(rawValue: "test@netgrif.com")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + void textValid_email2() { + PetriNet testNet = importTextNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["text01": new TextField(rawValue: "test@netgrif.co.com")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + void textValid_email3() { + PetriNet testNet = importTextNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["text01": new TextField(rawValue: "te.st@netgrif.co.com")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + void textValid_email_Exception() { + PetriNet testNet = importTextNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["text01": new TextField(rawValue: "test@@aaa.com")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-text01", thrown.getMessage()); + } + + @Test + void textValid_email_Exception2() { + PetriNet testNet = importTextNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["text01": new TextField(rawValue: "test@aaa.s")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-text01", thrown.getMessage()); + } + + @Test + void textValid_telnumber() { + PetriNet testNet = importTextNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["text02": new TextField(rawValue: "+421 000 000 000")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + void textValid_telnumber2() { + PetriNet testNet = importTextNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["text02": new TextField(rawValue: "+421-000-000-000")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + void textValid_telnumber3() { + PetriNet testNet = importTextNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["text02": new TextField(rawValue: "0910-000-000")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + void textValid_telnumber4() { + PetriNet testNet = importTextNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["text02": new TextField(rawValue: "0910000000")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + void textValid_telnumber_Exception() { + PetriNet testNet = importTextNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["text02": new TextField(rawValue: "aaa 000 000 000")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-text02", thrown.getMessage()); + } + + @Test + void regexValid_regex01() { + PetriNet testNet = importRegexNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["regex01": new TextField(rawValue: "12345")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + void regexValid_regex02() { + PetriNet testNet = importRegexNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["regex02": new TextField(rawValue: "AbC-012-Z9")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + void regexValid_regex03() { + PetriNet testNet = importRegexNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["regex03": new TextField(rawValue: "TOTOK4EveR09")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + void regexValid_regex04() { + PetriNet testNet = importRegexNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["regex04": new TextField(rawValue: "AA 09 bb")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + void regexValid_regex05() { + PetriNet testNet = importRegexNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["regex05": new TextField(rawValue: "A(:?BB+ľščťžýáíééé===é/*-+12154 ô/[]??.!\\.-úaa<>4 MM adsa!!; ff @#&")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + void regexValid_regex05_2() { + PetriNet testNet = importRegexNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["regex05": new TextField(rawValue: " ")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + void regexValid_regex06() { + PetriNet testNet = importRegexNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["regex06": new TextField(rawValue: "Toto00okJeTest012@netgrif.com")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + void regexValid_regex06_2() { + PetriNet testNet = importRegexNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["regex06": new TextField(rawValue: "e-mail.totok@netgrif.com")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + void regexValid_regex06_3() { + PetriNet testNet = importRegexNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["regex06": new TextField(rawValue: "totok@az.sk.so")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + void regexValid_regex01_Exception() { + PetriNet testNet = importRegexNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["regex01": new TextField(rawValue: "54544545454")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-regex01", thrown.getMessage()); + } + + @Test + void regexValid_regex01_Exception2() { + PetriNet testNet = importRegexNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["regex01": new TextField(rawValue: "")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-regex01", thrown.getMessage()); + } + + @Test + void regexValid_regex01_Exception3() { + PetriNet testNet = importRegexNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["regex01": new TextField(rawValue: "aav")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-regex01", thrown.getMessage()); + } + + @Test + void regexValid_regex02_Exception() { + PetriNet testNet = importRegexNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["regex02": new TextField(rawValue: "AAAAAAAAAAAAAaaaaaaaaaa")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-regex02", thrown.getMessage()); + } + + @Test + void regexValid_regex02_Exception2() { + PetriNet testNet = importRegexNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["regex02": new TextField(rawValue: "AAAAAAA??a")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-regex02", thrown.getMessage()); + } + + @Test + void regexValid_regex02_Exception3() { + PetriNet testNet = importRegexNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["regex02": new TextField(rawValue: "-")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-regex02", thrown.getMessage()); + } + + @Test + void regexValid_regex03_Exception() { + PetriNet testNet = importRegexNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["regex03": new TextField(rawValue: "aaaTOTOKaa1231")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-regex03", thrown.getMessage()); + } + + @Test + void regexValid_regex03_Exception2() { + PetriNet testNet = importRegexNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["regex03": new TextField(rawValue: "TOTOK")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-regex03", thrown.getMessage()); + } + + @Test + void regexValid_regex03_Exception3() { + PetriNet testNet = importRegexNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["regex03": new TextField(rawValue: "TOTOK4EveR0!")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-regex03", thrown.getMessage()); + } + + @Test + void regexValid_regex04_Exception() { + PetriNet testNet = importRegexNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["regex04": new TextField(rawValue: "5412122121212121")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-regex04", thrown.getMessage()); + } + + @Test + void regexValid_regex05_Exception() { + PetriNet testNet = importRegexNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["regex05": new TextField(rawValue: "")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-regex05", thrown.getMessage()); + } + + @Test + void regexValid_regex06_Exception() { + PetriNet testNet = importRegexNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["regex06": new TextField(rawValue: "aaa@@@aaa.ss")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-regex06", thrown.getMessage()); + } + + @Test + void regexValid_regex06_Exception2() { + PetriNet testNet = importRegexNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["regex06": new TextField(rawValue: "aaa@aa")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-regex06", thrown.getMessage()); + } + + @Test + void regexValid_regex06_Exception3() { + PetriNet testNet = importRegexNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["regex06": new TextField(rawValue: "@aa.sk")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-regex06", thrown.getMessage()); + } + + @Test + void regexValid_regex06_Exception4() { + PetriNet testNet = importRegexNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["regex06": new TextField(rawValue: "tot ok@az.sk.so")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-regex06", thrown.getMessage()); + } + + // BOOLEAN FIELD + @Test + void booleanValid_requiredTrue() { + PetriNet testNet = importBooleanNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["boolean_0": new BooleanField(rawValue:true)])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + void booleanValid_requiredTrue_Exception() { + PetriNet testNet = importBooleanNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["boolean_0": new BooleanField(rawValue:false)])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-boolean", thrown.getMessage()); + } + + @Test + void booleanValid_requiredTrue_Exception2() { + PetriNet testNet = importBooleanNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["boolean_0": new BooleanField(rawValue: null)])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-boolean", thrown.getMessage()); + } + + // DATE FIELD + @Test + @Disabled + void dateValid_between_today() { + PetriNet testNet = importDateNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["date01": new DateField(rawValue: LocalDate.now())])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + @Disabled + void dateValid_between_today_plusDay() { + PetriNet testNet = importDateNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["date01": new DateField(rawValue: LocalDate.now().plusDays(1))])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + @Disabled + void dateValid_between_today_Exception() { + PetriNet testNet = importDateNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["date01": new DateField(rawValue: LocalDate.now().minusDays(1))])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-date01", thrown.getMessage()); + } + + @Test + @Disabled + void dateValid_between_past() { + PetriNet testNet = importDateNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["date02": new DateField(rawValue: LocalDate.now())])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + @Disabled + void dateValid_between_past_minusDay() { + PetriNet testNet = importDateNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["date02": new DateField(rawValue: LocalDate.now().minusDays(1))])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + @Disabled + void dateValid_between_past_Exception() { + PetriNet testNet = importDateNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["date02": new DateField(rawValue: LocalDate.now().plusDays(1))])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-date02", thrown.getMessage()); + } + + @Test + @Disabled + void dateValid_between_fromDate() { + PetriNet testNet = importDateNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["date03": new DateField(rawValue: LocalDate.of(2020, 3, 3))])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + @Disabled + void dateValid_between_fromDate_today() { + PetriNet testNet = importDateNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["date03": new DateField(rawValue: LocalDate.now())])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + @Disabled + void dateValid_between_fromDate_Exception() { + PetriNet testNet = importDateNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["date03": new DateField(rawValue: LocalDate.now().plusDays(1))])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-date03", thrown.getMessage()); + } + + @Test + @Disabled + void dateValid_between_fromDate_past() { + PetriNet testNet = importDateNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["date04": new DateField(rawValue: LocalDate.of(2020, 3, 3))])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + @Disabled + void dateValid_between_fromDate_past_minusDay() { + PetriNet testNet = importDateNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["date04": new DateField(rawValue: LocalDate.of(2020, 3, 3))])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + @Disabled + void dateValid_between_fromDate_past_Exception() { + PetriNet testNet = importDateNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + // TODO: release/8.0.0 should fail with 3.3.2020? yes from 6.4.0 + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["date04": new DateField(rawValue: LocalDate.of(2020, 3, 4))])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-date04", thrown.getMessage()); + } + + @Test + @Disabled + void dateValid_between_fromDate_toDate() { + PetriNet testNet = importDateNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["date05": new DateField(rawValue: LocalDate.of(2020, 1, 1))])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + @Disabled + void dateValid_between_fromDate_toDate2() { + PetriNet testNet = importDateNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["date05": new DateField(rawValue: LocalDate.of(2022,3,3))])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + void dateValid_workday() { + PetriNet testNet = importDateNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["date06": new DateField(rawValue: LocalDate.of(1994,7,4))])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + void dateValid_workday_Exception() { + PetriNet testNet = importDateNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["date06": new DateField(rawValue: LocalDate.of(1994,7,3))])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-date06", thrown.getMessage()); + } + + @Test + void dateValid_weekend() { + PetriNet testNet = importDateNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["date07": new DateField(rawValue: LocalDate.of(1994,7,3))])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + void dateValid_weekend_Exception() { + PetriNet testNet = importDateNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["date07": new DateField(rawValue: LocalDate.of(1994,7,4))])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-date07", thrown.getMessage()); + } + + // Number Field + @Test + void numberValid_odd() { + PetriNet testNet = importNumberNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["number01": new NumberField(rawValue: 3)])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + void numberValid_odd_Exception() { + PetriNet testNet = importNumberNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["number01": new NumberField(rawValue: 2)])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-number01", thrown.getMessage()); + } + + @Test + void numberValid_even() { + PetriNet testNet = importNumberNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["number02": new NumberField(rawValue: 2)])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + void numberValid_even_Exception() { + PetriNet testNet = importNumberNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["number02": new NumberField(rawValue: 3)])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-number02", thrown.getMessage()); + } + + @Test + void numberValid_positive() { + PetriNet testNet = importNumberNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["number03": new NumberField(rawValue: 1.25624)])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + void numberValid_positive_Exception() { + PetriNet testNet = importNumberNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["number03": new NumberField(rawValue: -1.1558)])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-number03", thrown.getMessage()); + } + + @Test + void numberValid_negative() { + PetriNet testNet = importNumberNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["number04": new NumberField(rawValue: -1.25624)])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + void numberValid_negative_Exception() { + PetriNet testNet = importNumberNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["number04": new NumberField(rawValue: 1.1558)])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-number04", thrown.getMessage()); + } + + @Test + void numberValid_decimal() { + PetriNet testNet = importNumberNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["number05": new NumberField(rawValue: 10)])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + void numberValid_decimal_Exception() { + PetriNet testNet = importNumberNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["number05": new NumberField(rawValue: 10.1558d)])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-number05", thrown.getMessage()); + } + + @Test + void numberValid_inRange() { + PetriNet testNet = importNumberNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["number06": new NumberField(rawValue: 13.2452d)])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + void numberValid_inRange_Exception() { + PetriNet testNet = importNumberNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["number06": new NumberField(rawValue: 9.1558)])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-number06", thrown.getMessage()); + } + + + @Test + void numberValid_inRange_odd() { + PetriNet testNet = importNumberNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + importHelper.setTaskData(task.getStringId(), new DataSet(["number07": new NumberField(rawValue: 1)])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + } + + @Test + void numberValid_inRange_odd_Exception() { + PetriNet testNet = importNumberNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["number07": new NumberField(rawValue: 2)])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-number07-1", thrown.getMessage()); + } + + @Test + void numberValid_inRange_odd_Exception2() { + PetriNet testNet = importNumberNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["number07": new NumberField(rawValue: 7)])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + Assertions.assertEquals("error-number07-2", thrown.getMessage()); + } } diff --git a/src/test/groovy/com/netgrif/application/engine/validation/ValidationTestDynamic.groovy b/src/test/groovy/com/netgrif/application/engine/validation/ValidationTestDynamic.groovy index fff7286c3f4..2f2f90b8d0c 100644 --- a/src/test/groovy/com/netgrif/application/engine/validation/ValidationTestDynamic.groovy +++ b/src/test/groovy/com/netgrif/application/engine/validation/ValidationTestDynamic.groovy @@ -16,6 +16,7 @@ import com.netgrif.application.engine.workflow.domain.repositories.CaseRepositor 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.Assertions import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Test import org.junit.jupiter.api.extension.ExtendWith @@ -53,14 +54,9 @@ class ValidationTestDynamic { @Autowired private ITaskService taskService -// @Autowired -// private ValidationRunner validationRunner - @BeforeEach void setup() { testHelper.truncateDbs() -// -// validationRunner.run() } private PetriNet importTextNet() { @@ -115,4 +111,24 @@ class ValidationTestDynamic { Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() assert taskFinish != null } + + @Test + void textDynamic_validation_fail() { + + createValidation("aaaa", "a -> thisField.rawValue.size() == a as Integer", true) + + PetriNet testNet = importTextNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + IllegalArgumentException thrown = Assertions.assertThrows(IllegalArgumentException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["text06": new TextField(rawValue: "1234567")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + + assert "error-text01" == thrown.getMessage() + } } diff --git a/src/test/resources/petriNets/validation/valid_boolean.xml b/src/test/resources/petriNets/validation/valid_boolean.xml index 77c4c1e5054..c48871987ae 100644 --- a/src/test/resources/petriNets/validation/valid_boolean.xml +++ b/src/test/resources/petriNets/validation/valid_boolean.xml @@ -11,7 +11,7 @@ <title/> <validations> <validation> - <expression>requiredTrue</expression> + <expression>requiredtrue</expression> <message>error-boolean</message> </validation> </validations> From b91b84201e6907a1d3fdc31ce663dcc0d7fc026c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Martin=20=C5=A0ir=C3=A1=C5=88?= <matosiro4@gmail.com> Date: Fri, 12 Jul 2024 11:27:42 +0200 Subject: [PATCH 05/12] [NAE-1788] Validation register backend - update validations regarding new petriflow schema --- .../logic/action/ValidationExecutioner.groovy | 14 +- .../engine/importer/service/FieldFactory.java | 11 +- .../service/validation/DataValidator.java | 1 - .../petrinet/domain/dataset/Validation.java | 6 +- .../validations/ValidationRegistry.java | 6 +- .../engine/validations/ValidationService.java | 9 +- .../interfaces/IValidationService.java | 2 + .../validations/validation.xml | 73 +- .../resources/petriNets/petriflow_schema.xsd | 798 +++++++++++++++++- .../validation/ValidationTestDynamic.groovy | 8 +- .../petriNets/validation/valid_text.xml | 57 +- 11 files changed, 945 insertions(+), 40 deletions(-) diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy index 740ba9fb740..7324cdd2100 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy @@ -5,7 +5,6 @@ import com.netgrif.application.engine.petrinet.domain.dataset.Field import com.netgrif.application.engine.petrinet.domain.dataset.Validation import com.netgrif.application.engine.validations.ValidationRegistry import com.netgrif.application.engine.workflow.domain.Case -import groovy.json.StringEscapeUtils import groovy.util.logging.Slf4j import org.springframework.beans.factory.annotation.Autowired import org.springframework.beans.factory.annotation.Lookup @@ -24,13 +23,13 @@ abstract class ValidationExecutioner { @Autowired private IGroovyShellFactory shellFactory - void run(Case useCase, Field<?> field, List<Validation> validations) { + void execute(Case useCase, Field<?> field, List<Validation> validations) { if (validations) { - log.info("Validations: ${validations.collect {it.rule }}") + log.info("Validations: ${validations.collect { it.name }}") - ValidationDelegate delegate = initDelegate(useCase, field, this.registry.getValidationNames()) + ValidationDelegate delegate = initDelegate(useCase, field, validations.collect { it.name }) for (Validation validation : validations) { - Closure<Boolean> code = initCode(validation.rule, delegate) + Closure<Boolean> code = initCode(validation, delegate) def result = code() if (result !instanceof Boolean) { result = result() @@ -46,8 +45,9 @@ abstract class ValidationExecutioner { return this.registry.getValidation(validationName) } - protected Closure<Boolean> initCode(String rule, ValidationDelegate delegate) { - Closure<Boolean> code = this.shellFactory.getGroovyShell().evaluate("{ -> "+ rule + " }") as Closure<Boolean> + protected Closure<Boolean> initCode(Validation validation, ValidationDelegate delegate) { + String validationCall = "${validation.name} (${validation.arguments.find { it.type.value == "server" }.argument.join(", ")})" + Closure<Boolean> code = this.shellFactory.getGroovyShell().evaluate("{ -> " + validationCall + " }") as Closure<Boolean> return code.rehydrate(delegate, code.owner, code.thisObject) } diff --git a/src/main/java/com/netgrif/application/engine/importer/service/FieldFactory.java b/src/main/java/com/netgrif/application/engine/importer/service/FieldFactory.java index bbb0903f021..141d6781cd4 100644 --- a/src/main/java/com/netgrif/application/engine/importer/service/FieldFactory.java +++ b/src/main/java/com/netgrif/application/engine/importer/service/FieldFactory.java @@ -54,19 +54,10 @@ Field<?> getField(Data data, Importer importer) throws IllegalArgumentException, if (data.getPlaceholder() != null) field.setPlaceholder(importer.toI18NString(data.getPlaceholder())); - // TODO: release/8.0.0 validation register - // TODO: release/8.0.0 valid deprecated - if (data.getValid() != null) { - List<Valid> list = data.getValid(); - for (Valid item : list) { - // TODO: release/8.0.0 new I18nString? - field.addValidation(new Validation(item.getValue(), new I18nString())); - } - } if (data.getValidations() != null) { List<com.netgrif.application.engine.importer.model.Validation> list = data.getValidations().getValidation(); for (com.netgrif.application.engine.importer.model.Validation item : list) { - field.addValidation(new Validation(item.getExpression().getValue(), importer.toI18NString(item.getMessage()))); + field.addValidation(new Validation(item.getName(), item.getArguments(), importer.toI18NString(item.getMessage()))); } } if (data.getComponent() != null) { diff --git a/src/main/java/com/netgrif/application/engine/importer/service/validation/DataValidator.java b/src/main/java/com/netgrif/application/engine/importer/service/validation/DataValidator.java index 4cf2a9dfe33..4a96c4b65d1 100644 --- a/src/main/java/com/netgrif/application/engine/importer/service/validation/DataValidator.java +++ b/src/main/java/com/netgrif/application/engine/importer/service/validation/DataValidator.java @@ -11,7 +11,6 @@ public class DataValidator extends ModelValidator implements IDataValidator { @Override public void checkDeprecatedAttributes(Data data) { validateAttribute(data.getView(), "view", data.getId()); - validateAttribute(data.getValid() != null && !data.getValid().isEmpty() ? data.getValid() : null, "valid", data.getId()); validateAttribute(data.getFormat(), "format", data.getId()); validateAttribute(data.getValues() != null && !data.getValues().isEmpty() ? data.getValues() : null, "values", data.getId()); } diff --git a/src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/Validation.java b/src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/Validation.java index 4b672333e0e..27a5f399b18 100644 --- a/src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/Validation.java +++ b/src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/Validation.java @@ -14,13 +14,15 @@ public class Validation implements Serializable { private static final long serialVersionUID = 3287600522204188694L; - protected String rule; + protected String name; + private com.netgrif.application.engine.importer.model.Arguments arguments; private I18nString message; @Override public Validation clone() { Validation cloned = new Validation(); - cloned.setRule(rule); + cloned.setName(name); + cloned.setArguments(arguments); if (this.message != null) { cloned.setMessage(this.message.clone()); } diff --git a/src/main/java/com/netgrif/application/engine/validations/ValidationRegistry.java b/src/main/java/com/netgrif/application/engine/validations/ValidationRegistry.java index 2c70b75202c..e4a9c1457c4 100644 --- a/src/main/java/com/netgrif/application/engine/validations/ValidationRegistry.java +++ b/src/main/java/com/netgrif/application/engine/validations/ValidationRegistry.java @@ -24,11 +24,9 @@ public Closure<Boolean> getValidation(String name) { return validationsMap.get(name); } - public List<String> getValidationNames() { - return new ArrayList<>(validationsMap.keySet()); - } - public Closure<Boolean> removeValidation(String name) { return validationsMap.remove(name); } + + public void removeAllValidations() { validationsMap.clear(); } } diff --git a/src/main/java/com/netgrif/application/engine/validations/ValidationService.java b/src/main/java/com/netgrif/application/engine/validations/ValidationService.java index d59104dda72..d334edf4e40 100644 --- a/src/main/java/com/netgrif/application/engine/validations/ValidationService.java +++ b/src/main/java/com/netgrif/application/engine/validations/ValidationService.java @@ -33,14 +33,14 @@ public ValidationService(ValidationRegistry validationRegistry, ValidationExecut public void validateTransition(Case useCase, Transition transition) { transition.getDataSet().values().forEach(dataRef -> { if (dataRef.getField() != null) { - validationExecutioner.run(useCase, dataRef.getField(), dataRef.getField().getValidations()); + validationExecutioner.execute(useCase, dataRef.getField(), dataRef.getField().getValidations()); } }); } @Override public void validateField(Case useCase, Field<?> field) { - validationExecutioner.run(useCase, field, field.getValidations()); + validationExecutioner.execute(useCase, field, field.getValidations()); } @Override @@ -58,4 +58,9 @@ public Closure<Boolean> getValidation(String name) { public void unregisterValidation(String name) { validationRegistry.removeValidation(name); } + + @Override + public void clearValidations() { + validationRegistry.removeAllValidations(); + } } diff --git a/src/main/java/com/netgrif/application/engine/validations/interfaces/IValidationService.java b/src/main/java/com/netgrif/application/engine/validations/interfaces/IValidationService.java index d8528191782..8ca9f08d7e6 100644 --- a/src/main/java/com/netgrif/application/engine/validations/interfaces/IValidationService.java +++ b/src/main/java/com/netgrif/application/engine/validations/interfaces/IValidationService.java @@ -17,4 +17,6 @@ public interface IValidationService { Closure<Boolean> getValidation(String name); void unregisterValidation(String name); + + void clearValidations(); } diff --git a/src/main/resources/petriNets/engine-processes/validations/validation.xml b/src/main/resources/petriNets/engine-processes/validations/validation.xml index f12fc8216bd..68183fdc049 100644 --- a/src/main/resources/petriNets/engine-processes/validations/validation.xml +++ b/src/main/resources/petriNets/engine-processes/validations/validation.xml @@ -52,6 +52,10 @@ <name>textarea</name> </component> </data> + <data type="number"> + <id>num_arguments_groovy</id> + <title name="num_arguments_groovy">Number of arguments - Groovy + validation_definition_javascript Validation definition - JavaScript @@ -59,6 +63,10 @@ textarea + + num_arguments_javascript + Number of arguments - JavaScript + version Version @@ -72,7 +80,9 @@ Meno Definícia validácie - Groovy + Počet argumentov - Groovy Definícia validácie - JavaScript + Počet argumentov - JavaScript Verzia Je aktívny Detail @@ -82,7 +92,9 @@ Name Validierungsdefinition - Groovy + Anzahl der Argumente - Groovy Validierungsdefinition - JavaScript + Anzahl der Argumente - JavaScript Ausführung Ist aktiv Detail @@ -136,7 +148,7 @@ 0 - 3 + 4 2 4 @@ -157,6 +169,35 @@ outline + + num_arguments_groovy + + editable + required + + + 0 + 3 + 1 + 2 + + outline + + + + num_arguments_javascript + + editable + + + 0 + 6 + 1 + 2 + + outline + + init_assign @@ -284,7 +325,7 @@ 0 - 4 + 5 2 4 @@ -306,6 +347,34 @@ outline + + num_arguments_groovy + + visible + + + 0 + 4 + 1 + 2 + + outline + + + + num_arguments_javascript + + visible + + + 0 + 7 + 1 + 2 + + outline + + detail_assign diff --git a/src/main/resources/petriNets/petriflow_schema.xsd b/src/main/resources/petriNets/petriflow_schema.xsd index 28e88a26d6f..115b1a30bd8 100644 --- a/src/main/resources/petriNets/petriflow_schema.xsd +++ b/src/main/resources/petriNets/petriflow_schema.xsd @@ -1,8 +1,800 @@ - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/test/groovy/com/netgrif/application/engine/validation/ValidationTestDynamic.groovy b/src/test/groovy/com/netgrif/application/engine/validation/ValidationTestDynamic.groovy index 2f2f90b8d0c..1d77bc6d792 100644 --- a/src/test/groovy/com/netgrif/application/engine/validation/ValidationTestDynamic.groovy +++ b/src/test/groovy/com/netgrif/application/engine/validation/ValidationTestDynamic.groovy @@ -8,7 +8,7 @@ import com.netgrif.application.engine.petrinet.domain.dataset.TextField 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.startup.ValidationRunner +import com.netgrif.application.engine.validations.interfaces.IValidationService 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 @@ -54,9 +54,13 @@ class ValidationTestDynamic { @Autowired private ITaskService taskService + @Autowired + private IValidationService validationService + @BeforeEach void setup() { testHelper.truncateDbs() + validationService.clearValidations() } private PetriNet importTextNet() { @@ -129,6 +133,6 @@ class ValidationTestDynamic { assert taskFinish != null }) - assert "error-text01" == thrown.getMessage() + assert "error-text06" == thrown.getMessage() } } diff --git a/src/test/resources/petriNets/validation/valid_text.xml b/src/test/resources/petriNets/validation/valid_text.xml index 145d70578ad..dba1b777538 100644 --- a/src/test/resources/petriNets/validation/valid_text.xml +++ b/src/test/resources/petriNets/validation/valid_text.xml @@ -11,8 +11,12 @@ text01 <validations> +<!-- <validation>--> +<!-- <expression>email</expression>--> +<!-- <message>error-text01</message>--> +<!-- </validation>--> <validation> - <expression>email</expression> + <name>email</name> <message>error-text01</message> </validation> </validations> @@ -21,8 +25,12 @@ <id>text02</id> <title/> <validations> +<!-- <validation>--> +<!-- <expression>telnumber</expression>--> +<!-- <message>error-text02</message>--> +<!-- </validation>--> <validation> - <expression>telnumber</expression> + <name>telnumber</name> <message>error-text02</message> </validation> </validations> @@ -31,8 +39,15 @@ <id>text03</id> <title/> <validations> +<!-- <validation>--> +<!-- <expression>maxlength 6</expression>--> +<!-- <message>error-text03</message>--> +<!-- </validation>--> <validation> - <expression>maxlength 6</expression> + <name>maxlength</name> + <arguments type="server"> + <argument>6</argument> + </arguments> <message>error-text03</message> </validation> </validations> @@ -41,8 +56,15 @@ <id>text04</id> <title/> <validations> +<!-- <validation>--> +<!-- <expression>minlength 3</expression>--> +<!-- <message>error-text04</message>--> +<!-- </validation>--> <validation> - <expression>minlength 3</expression> + <name>minlength</name> + <arguments type="server"> + <argument>3</argument> + </arguments> <message>error-text04</message> </validation> </validations> @@ -51,12 +73,26 @@ <id>text05</id> <title/> <validations> +<!-- <validation>--> +<!-- <expression>minlength 3</expression>--> +<!-- <message>error-text05</message>--> +<!-- </validation>--> +<!-- <validation>--> +<!-- <expression>maxlength 6</expression>--> +<!-- <message>error-text05</message>--> +<!-- </validation>--> <validation> - <expression>minlength 3</expression> + <name>minlength</name> + <arguments type="server"> + <argument>3</argument> + </arguments> <message>error-text05</message> </validation> <validation> - <expression>maxlength 6</expression> + <name>maxlength</name> + <arguments type="server"> + <argument>6</argument> + </arguments> <message>error-text05</message> </validation> </validations> @@ -65,8 +101,15 @@ <id>text06</id> <title/> <validations> +<!-- <validation>--> +<!-- <expression>aaaa number01.rawValue</expression>--> +<!-- <message>error-text06</message>--> +<!-- </validation>--> <validation> - <expression>aaaa number01.rawValue</expression> + <name>aaaa</name> + <arguments type="server"> + <argument>number01.rawValue</argument> + </arguments> <message>error-text06</message> </validation> </validations> From d0679f6205ab71c65f0c5b01797e10d9ca8d0db5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Martin=20=C5=A0ir=C3=A1=C5=88?= <matosiro4@gmail.com> Date: Tue, 16 Jul 2024 16:27:43 +0200 Subject: [PATCH 06/12] [NAE-1788] Validation register backend - rework closures to methods in ValidationDelegate - update validations execution - update FieldFactory and add new classes for validations - update validation tests --- .../logic/action/ValidationDelegate.groovy | 92 +++++++++++-------- .../logic/action/ValidationExecutioner.groovy | 22 +++-- .../engine/importer/service/FieldFactory.java | 5 +- .../petrinet/domain/dataset/Arguments.java | 27 ++++++ .../domain/dataset/ArgumentsType.java | 19 ++++ .../petrinet/domain/dataset/Validation.java | 6 +- .../NumberFieldValidationTest.groovy | 2 +- .../engine/validation/ValidationTest.groovy | 14 --- .../petriNets/validation/valid_boolean.xml | 2 +- .../petriNets/validation/valid_date.xml | 34 +++++-- .../petriNets/validation/valid_number.xml | 24 +++-- .../petriNets/validation/valid_regex.xml | 30 ++++-- .../petriNets/validation/valid_text.xml | 28 ------ 13 files changed, 194 insertions(+), 111 deletions(-) create mode 100644 src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/Arguments.java create mode 100644 src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/ArgumentsType.java diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationDelegate.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationDelegate.groovy index 721bda02f35..59181b23ef8 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationDelegate.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationDelegate.groovy @@ -22,10 +22,10 @@ class ValidationDelegate { Field<?> thisField - Closure<Boolean> notempty = { return thisField.rawValue != null } + Boolean notempty() { return thisField.rawValue != null } // boolean field validations - Closure<Boolean> requiredtrue = { return thisField instanceof BooleanField && notempty && thisField.rawValue == true } + Boolean requiredtrue() { return thisField instanceof BooleanField && notempty() && thisField.rawValue == true } // date field validations Closure<String> future = { return FUTURE } @@ -33,58 +33,70 @@ class ValidationDelegate { Closure<String> past = { return PAST } Closure<String> now = { return NOW } - Closure<Boolean> between = { def from, def to -> // todo: retype everything into localdatetime - if (thisField !instanceof DateField || thisField !instanceof DateTimeField) { + Boolean between(def from, def to) { + if (!(thisField instanceof DateField || thisField instanceof DateTimeField)) { return false } - LocalDateTime updateDate_TODAY = LocalDateTime.now() + LocalDateTime updateDate_TODAY = thisField instanceof DateField ? LocalDate.now().atStartOfDay() : LocalDateTime.now() + LocalDateTime thisFieldValue = thisField.rawValue instanceof LocalDateTime ? thisField.rawValue : thisField.rawValue.atStartOfDay() - def fromDate = from instanceof String && parseStringToLocalDate(from) != null ? parseStringToLocalDate(from) : from - def toDate = to instanceof String && parseStringToLocalDate(to) != null ? parseStringToLocalDate(to) : to + def fromDate = from + if (from instanceof String) { + LocalDate parsedDate = parseStringToLocalDate(from) + fromDate = parsedDate ? parsedDate.atStartOfDay() : from + } + + def toDate = to + if (to instanceof String) { + LocalDate parsedDate = parseStringToLocalDate(to) + toDate = parsedDate ? parsedDate.atStartOfDay() : to + } + + log.warn("{} > between {}, {}", thisFieldValue, fromDate, toDate) if ((fromDate == TODAY || fromDate == NOW) && toDate == FUTURE) { - if (thisField.rawValue < updateDate_TODAY) { + if (thisFieldValue < updateDate_TODAY) { return false } } else if (fromDate == PAST && (toDate == TODAY || toDate == NOW)) { - if (thisField.rawValue > updateDate_TODAY) { + if (thisFieldValue > updateDate_TODAY) { return false } - } else if (fromDate == PAST && (toDate instanceof LocalDate)) { - if (thisField.rawValue > toDate) { + } else if (fromDate == PAST && (toDate instanceof LocalDateTime)) { + if (thisFieldValue > toDate) { return false } - } else if (fromDate == TODAY && (toDate instanceof LocalDate)) { - if (thisField.rawValue < toDate || thisField.rawValue > updateDate_TODAY) { + } else if (fromDate == TODAY && (toDate instanceof LocalDateTime)) { + if (thisFieldValue > toDate || thisFieldValue < updateDate_TODAY) { return false } - } else if ((fromDate instanceof LocalDate) && toDate == TODAY) { - if (thisField.rawValue < fromDate || thisField.rawValue > updateDate_TODAY) { + } else if ((fromDate instanceof LocalDateTime) && toDate == TODAY) { + if (thisFieldValue < fromDate || thisFieldValue > updateDate_TODAY) { return false } - } else if (toDate == FUTURE && (fromDate instanceof LocalDate)) { - if (thisField.rawValue < fromDate) { + } else if (toDate == FUTURE && (fromDate instanceof LocalDateTime)) { + if (thisFieldValue < fromDate) { return false } - } else if ((fromDate instanceof LocalDate) && (toDate instanceof LocalDate)) { - if (thisField.rawValue > toDate || thisField.rawValue < fromDate) { + } else if ((fromDate instanceof LocalDateTime) && (toDate instanceof LocalDateTime)) { + if (thisFieldValue > toDate || thisFieldValue < fromDate) { return false } } return true } - Closure<Boolean> workday = { return (thisField instanceof DateField || thisField instanceof DateTimeField) && notempty && !thisField.rawValue.dayOfWeek.isWeekend() } + Boolean workday() { return (thisField instanceof DateField || thisField instanceof DateTimeField) && notempty() && !thisField.rawValue.dayOfWeek.isWeekend() } - Closure<Boolean> weekend = { return (thisField instanceof DateField || thisField instanceof DateTimeField) && notempty && thisField.rawValue.dayOfWeek.isWeekend() } + Boolean weekend() { return (thisField instanceof DateField || thisField instanceof DateTimeField) && notempty() && thisField.rawValue.dayOfWeek.isWeekend() } - protected static LocalDateTime parseStringToLocalDate(String stringDate) { + protected static LocalDate parseStringToLocalDate(String stringDate) { if (stringDate == null) { return null } - List<String> patterns = Arrays.asList("dd.MM.yyyy HH:mm:ss", "") + List<String> patterns = Arrays.asList("dd.MM.yyyy", "") try { return LocalDate.parse(stringDate, DateTimeFormatter.BASIC_ISO_DATE) } catch (DateTimeParseException ignored) { @@ -93,7 +105,7 @@ class ValidationDelegate { } catch (DateTimeParseException ignored2) { for (String pattern : patterns) { try { - return LocalDate.parse(stringDate, DateTimeFormatter.ofPattern(pattern)) + return LocalDateTime.parse(stringDate, DateTimeFormatter.ofPattern(pattern)) } catch (DateTimeParseException | IllegalArgumentException ignored3) { } } @@ -105,17 +117,25 @@ class ValidationDelegate { // number field validations Closure<String> inf = { return INF } - Closure<Boolean> odd = { return thisField instanceof NumberField && notempty && thisField.rawValue % 2 != 0 } + Boolean odd() { return thisField instanceof NumberField && notempty() && thisField.rawValue as Double % 2 != 0 } - Closure<Boolean> even = { return thisField instanceof NumberField && notempty && thisField.rawValue % 2 == 0 } + Boolean even() { return thisField instanceof NumberField && notempty() && thisField.rawValue as Double % 2 == 0 } - Closure<Boolean> positive = { return thisField instanceof NumberField && notempty && thisField.rawValue >= 0 } + Boolean positive() { return thisField instanceof NumberField && notempty() && thisField.rawValue >= 0 } - Closure<Boolean> negative = { return thisField instanceof NumberField && notempty && thisField.rawValue <= 0 } + Boolean negative() { return thisField instanceof NumberField && notempty() && thisField.rawValue <= 0 } - Closure<Boolean> decimal = { return thisField instanceof NumberField && notempty && thisField.rawValue % 1 == 0 } + Boolean decimal() { return thisField instanceof NumberField && notempty() && thisField.rawValue as Double % 1 == 0 } + + Boolean inrange(def from, def to) { + if (from == inf) { + from = inf() + } + + if (to == inf) { + to = inf() + } - Closure<Boolean> inrange = { def from, def to -> if (from instanceof String && from.toLowerCase() == INF) { from = Double.MIN_VALUE } @@ -123,18 +143,18 @@ class ValidationDelegate { if (to instanceof String && to.toLowerCase() == INF) { to = Double.MAX_VALUE } - return thisField instanceof NumberField && notempty && thisField.rawValue >= from as Double && thisField.rawValue <= to as Double + return thisField instanceof NumberField && notempty() && thisField.rawValue >= from as Double && thisField.rawValue <= to as Double } // text field validations - Closure<Boolean> regex = { String pattern -> return thisField instanceof TextField && notempty && thisField.rawValue ==~ pattern } + Boolean regex(String pattern) { return thisField instanceof TextField && notempty() && thisField.rawValue ==~ pattern } - Closure<Boolean> minlength = { Integer minLength -> return thisField instanceof TextField && notempty && (thisField.rawValue as String).length() >= minLength } + Boolean minlength(Integer minLength) { return thisField instanceof TextField && notempty() && (thisField.rawValue as String).length() >= minLength } - Closure<Boolean> maxlength = { Integer maxLength -> return thisField instanceof TextField && notempty && (thisField.rawValue as String).length() <= maxLength } + Boolean maxlength(Integer maxLength) { return thisField instanceof TextField && notempty() && (thisField.rawValue as String).length() <= maxLength } - Closure<Boolean> telnumber = { -> return regex(TEL_NUMBER_REGEX) } + Boolean telnumber() { return regex(TEL_NUMBER_REGEX) } - Closure<Boolean> email = { -> return regex(EMAIL_REGEX) } + Boolean email() { return regex(EMAIL_REGEX) } } diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy index 7324cdd2100..606c5da2789 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy @@ -1,6 +1,7 @@ package com.netgrif.application.engine.petrinet.domain.dataset.logic.action import com.netgrif.application.engine.event.IGroovyShellFactory +import com.netgrif.application.engine.petrinet.domain.dataset.ArgumentsType import com.netgrif.application.engine.petrinet.domain.dataset.Field import com.netgrif.application.engine.petrinet.domain.dataset.Validation import com.netgrif.application.engine.validations.ValidationRegistry @@ -29,12 +30,15 @@ abstract class ValidationExecutioner { ValidationDelegate delegate = initDelegate(useCase, field, validations.collect { it.name }) for (Validation validation : validations) { - Closure<Boolean> code = initCode(validation, delegate) - def result = code() - if (result !instanceof Boolean) { - result = result() + List<String> argumentList = [] + if (validation.arguments != null) { + if (validation.arguments.type != ArgumentsType.SERVER) { + continue + } + argumentList = validation.arguments.argument } - if (!result) { +// Closure<Boolean> code = initCode(validation, delegate) + if (!delegate."${validation.name}"(*argumentList)) { throw new IllegalArgumentException(validation.message.toString()) } } @@ -46,8 +50,12 @@ abstract class ValidationExecutioner { } protected Closure<Boolean> initCode(Validation validation, ValidationDelegate delegate) { - String validationCall = "${validation.name} (${validation.arguments.find { it.type.value == "server" }.argument.join(", ")})" - Closure<Boolean> code = this.shellFactory.getGroovyShell().evaluate("{ -> " + validationCall + " }") as Closure<Boolean> + List arguments = [] + if (validation.arguments != null) { + arguments = validation.arguments.argument + } + String validationCall = "${validation.name}(${arguments.join(", ")})" + Closure<Boolean> code = this.shellFactory.getGroovyShell().evaluate("{ -> return " + validationCall + " }") as Closure<Boolean> return code.rehydrate(delegate, code.owner, code.thisObject) } diff --git a/src/main/java/com/netgrif/application/engine/importer/service/FieldFactory.java b/src/main/java/com/netgrif/application/engine/importer/service/FieldFactory.java index 141d6781cd4..851bd12877c 100644 --- a/src/main/java/com/netgrif/application/engine/importer/service/FieldFactory.java +++ b/src/main/java/com/netgrif/application/engine/importer/service/FieldFactory.java @@ -9,6 +9,8 @@ import com.netgrif.application.engine.importer.service.validation.IDataValidator; import com.netgrif.application.engine.petrinet.domain.Component; import com.netgrif.application.engine.petrinet.domain.I18nString; +import com.netgrif.application.engine.petrinet.domain.dataset.Arguments; +import com.netgrif.application.engine.petrinet.domain.dataset.ArgumentsType; import com.netgrif.application.engine.petrinet.domain.dataset.Field; import com.netgrif.application.engine.petrinet.domain.dataset.Validation; import lombok.extern.slf4j.Slf4j; @@ -57,7 +59,8 @@ Field<?> getField(Data data, Importer importer) throws IllegalArgumentException, if (data.getValidations() != null) { List<com.netgrif.application.engine.importer.model.Validation> list = data.getValidations().getValidation(); for (com.netgrif.application.engine.importer.model.Validation item : list) { - field.addValidation(new Validation(item.getName(), item.getArguments(), importer.toI18NString(item.getMessage()))); + Arguments arguments = item.getArguments() != null ? new Arguments(ArgumentsType.fromString(item.getArguments().getType().value()), item.getArguments().getArgument()) : null; + field.addValidation(new Validation(item.getName(), arguments, importer.toI18NString(item.getMessage()))); } } if (data.getComponent() != null) { diff --git a/src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/Arguments.java b/src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/Arguments.java new file mode 100644 index 00000000000..59c94fa1993 --- /dev/null +++ b/src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/Arguments.java @@ -0,0 +1,27 @@ +package com.netgrif.application.engine.petrinet.domain.dataset; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.io.Serializable; +import java.util.List; + +@Data +@NoArgsConstructor +@AllArgsConstructor +public class Arguments implements Serializable { + + private static final long serialVersionUID = -2385696520525471923L; + + protected ArgumentsType type; + protected List<String> argument; + + @Override + public Arguments clone() { + Arguments cloned = new Arguments(); + cloned.setType(type); + cloned.setArgument(argument); + return cloned; + } +} diff --git a/src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/ArgumentsType.java b/src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/ArgumentsType.java new file mode 100644 index 00000000000..dcb2d84acbf --- /dev/null +++ b/src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/ArgumentsType.java @@ -0,0 +1,19 @@ +package com.netgrif.application.engine.petrinet.domain.dataset; + +import java.util.Arrays; +import java.util.Objects; + +public enum ArgumentsType { + SERVER("server"), + CLIENT("client"); + + public final String type; + + ArgumentsType(String type) { + this.type = type; + } + + public static ArgumentsType fromString(String type) { + return Arrays.stream(values()).filter(argumentsType -> Objects.equals(argumentsType.type, type)).findFirst().orElse(null); + } +} diff --git a/src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/Validation.java b/src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/Validation.java index 27a5f399b18..7a4b607bd1c 100644 --- a/src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/Validation.java +++ b/src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/Validation.java @@ -15,14 +15,16 @@ public class Validation implements Serializable { private static final long serialVersionUID = 3287600522204188694L; protected String name; - private com.netgrif.application.engine.importer.model.Arguments arguments; + private Arguments arguments; private I18nString message; @Override public Validation clone() { Validation cloned = new Validation(); cloned.setName(name); - cloned.setArguments(arguments); + if (arguments != null) { + cloned.setArguments(arguments.clone()); + } if (this.message != null) { cloned.setMessage(this.message.clone()); } diff --git a/src/test/groovy/com/netgrif/application/engine/validation/NumberFieldValidationTest.groovy b/src/test/groovy/com/netgrif/application/engine/validation/NumberFieldValidationTest.groovy index 26f93a9aeb7..6a5ab81c9f2 100644 --- a/src/test/groovy/com/netgrif/application/engine/validation/NumberFieldValidationTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/validation/NumberFieldValidationTest.groovy @@ -77,7 +77,7 @@ class NumberFieldValidationTest { ValidationDelegate delegate = getValidationDelegate() delegate.thisField = new NumberField(rawValue: -4) - assert delegate.positive() + assert !delegate.positive() } @Test diff --git a/src/test/groovy/com/netgrif/application/engine/validation/ValidationTest.groovy b/src/test/groovy/com/netgrif/application/engine/validation/ValidationTest.groovy index a0b5eb2288e..7b9d3a060ad 100644 --- a/src/test/groovy/com/netgrif/application/engine/validation/ValidationTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/validation/ValidationTest.groovy @@ -608,7 +608,6 @@ class ValidationTest { // DATE FIELD @Test - @Disabled void dateValid_between_today() { PetriNet testNet = importDateNet() Case aCase = importHelper.createCase("TestCase", testNet) @@ -621,7 +620,6 @@ class ValidationTest { } @Test - @Disabled void dateValid_between_today_plusDay() { PetriNet testNet = importDateNet() Case aCase = importHelper.createCase("TestCase", testNet) @@ -634,7 +632,6 @@ class ValidationTest { } @Test - @Disabled void dateValid_between_today_Exception() { PetriNet testNet = importDateNet() Case aCase = importHelper.createCase("TestCase", testNet) @@ -650,7 +647,6 @@ class ValidationTest { } @Test - @Disabled void dateValid_between_past() { PetriNet testNet = importDateNet() Case aCase = importHelper.createCase("TestCase", testNet) @@ -663,7 +659,6 @@ class ValidationTest { } @Test - @Disabled void dateValid_between_past_minusDay() { PetriNet testNet = importDateNet() Case aCase = importHelper.createCase("TestCase", testNet) @@ -676,7 +671,6 @@ class ValidationTest { } @Test - @Disabled void dateValid_between_past_Exception() { PetriNet testNet = importDateNet() Case aCase = importHelper.createCase("TestCase", testNet) @@ -692,7 +686,6 @@ class ValidationTest { } @Test - @Disabled void dateValid_between_fromDate() { PetriNet testNet = importDateNet() Case aCase = importHelper.createCase("TestCase", testNet) @@ -705,7 +698,6 @@ class ValidationTest { } @Test - @Disabled void dateValid_between_fromDate_today() { PetriNet testNet = importDateNet() Case aCase = importHelper.createCase("TestCase", testNet) @@ -718,7 +710,6 @@ class ValidationTest { } @Test - @Disabled void dateValid_between_fromDate_Exception() { PetriNet testNet = importDateNet() Case aCase = importHelper.createCase("TestCase", testNet) @@ -734,7 +725,6 @@ class ValidationTest { } @Test - @Disabled void dateValid_between_fromDate_past() { PetriNet testNet = importDateNet() Case aCase = importHelper.createCase("TestCase", testNet) @@ -747,7 +737,6 @@ class ValidationTest { } @Test - @Disabled void dateValid_between_fromDate_past_minusDay() { PetriNet testNet = importDateNet() Case aCase = importHelper.createCase("TestCase", testNet) @@ -760,7 +749,6 @@ class ValidationTest { } @Test - @Disabled void dateValid_between_fromDate_past_Exception() { PetriNet testNet = importDateNet() Case aCase = importHelper.createCase("TestCase", testNet) @@ -777,7 +765,6 @@ class ValidationTest { } @Test - @Disabled void dateValid_between_fromDate_toDate() { PetriNet testNet = importDateNet() Case aCase = importHelper.createCase("TestCase", testNet) @@ -790,7 +777,6 @@ class ValidationTest { } @Test - @Disabled void dateValid_between_fromDate_toDate2() { PetriNet testNet = importDateNet() Case aCase = importHelper.createCase("TestCase", testNet) diff --git a/src/test/resources/petriNets/validation/valid_boolean.xml b/src/test/resources/petriNets/validation/valid_boolean.xml index c48871987ae..d0146415816 100644 --- a/src/test/resources/petriNets/validation/valid_boolean.xml +++ b/src/test/resources/petriNets/validation/valid_boolean.xml @@ -11,7 +11,7 @@ <title/> <validations> <validation> - <expression>requiredtrue</expression> + <name>requiredtrue</name> <message>error-boolean</message> </validation> </validations> diff --git a/src/test/resources/petriNets/validation/valid_date.xml b/src/test/resources/petriNets/validation/valid_date.xml index 008cd3b31bb..663c1b2d70f 100644 --- a/src/test/resources/petriNets/validation/valid_date.xml +++ b/src/test/resources/petriNets/validation/valid_date.xml @@ -12,7 +12,11 @@ <title/> <validations> <validation> - <expression>between today,future</expression> <!-- od dnes do buducnosti--> + <name>between</name> <!-- od dnes do buducnosti--> + <arguments type="server"> + <argument>today</argument> + <argument>future</argument> + </arguments> <message>error-date01</message> </validation> </validations> @@ -22,7 +26,11 @@ <title/> <validations> <validation> - <expression>between past,today</expression> <!-- od minulosti do dnešného dňa --> + <name>between</name> <!-- od minulosti do dnešného dňa --> + <arguments type="server"> + <argument>past</argument> + <argument>today</argument> + </arguments> <message>error-date02</message> </validation> </validations> @@ -32,7 +40,11 @@ <title/> <validations> <validation> - <expression>between 2020-03-03,today</expression> <!-- od datumu do dnešného dňa --> + <name>between</name> <!-- od datumu do dnešného dňa --> + <arguments type="server"> + <argument>2020-03-03</argument> + <argument>today</argument> + </arguments> <message>error-date03</message> </validation> </validations> @@ -42,7 +54,11 @@ <title/> <validations> <validation> - <expression>between past,2020-03-03</expression> <!-- od minulosti do datumu --> + <name>between</name> <!-- od minulosti do datumu --> + <arguments type="server"> + <argument>past</argument> + <argument>2020-03-03</argument> + </arguments> <message>error-date04</message> </validation> </validations> @@ -52,7 +68,11 @@ <title/> <validations> <validation> - <expression>between 2020-01-01,2022-03-03</expression> <!-- od datumu do datumu --> + <name>between</name> <!-- od datumu do datumu --> + <arguments type="server"> + <argument>2020-01-01</argument> + <argument>2022-03-03</argument> + </arguments> <message>error-date05</message> </validation> </validations> @@ -62,7 +82,7 @@ <title/> <validations> <validation> - <expression>workday</expression> <!-- pracovny den --> + <name>workday</name> <!-- pracovny den --> <message>error-date06</message> </validation> </validations> @@ -72,7 +92,7 @@ <title/> <validations> <validation> - <expression>weekend</expression> <!-- vikend --> + <name>weekend</name> <!-- vikend --> <message>error-date07</message> </validation> </validations> diff --git a/src/test/resources/petriNets/validation/valid_number.xml b/src/test/resources/petriNets/validation/valid_number.xml index bbcb7063438..b4341761ead 100644 --- a/src/test/resources/petriNets/validation/valid_number.xml +++ b/src/test/resources/petriNets/validation/valid_number.xml @@ -12,7 +12,7 @@ <title/> <validations> <validation> - <expression>odd</expression> + <name>odd</name> <message>error-number01</message> </validation> </validations> @@ -22,7 +22,7 @@ <title/> <validations> <validation> - <expression>even</expression> + <name>even</name> <message>error-number02</message> </validation> </validations> @@ -32,7 +32,7 @@ <title/> <validations> <validation> - <expression>positive</expression> + <name>positive</name> <message>error-number03</message> </validation> </validations> @@ -42,7 +42,7 @@ <title/> <validations> <validation> - <expression>negative</expression> + <name>negative</name> <message>error-number04</message> </validation> </validations> @@ -52,7 +52,7 @@ <title/> <validations> <validation> - <expression>decimal</expression> + <name>decimal</name> <message>error-number05</message> </validation> </validations> @@ -62,7 +62,11 @@ <title/> <validations> <validation> - <expression>inrange 10,20</expression> + <name>inrange</name> + <arguments type="server"> + <argument>10</argument> + <argument>20</argument> + </arguments> <message>error-number06</message> </validation> </validations> @@ -73,11 +77,15 @@ <title/> <validations> <validation> - <expression>odd</expression> + <name>odd</name> <message>error-number07-1</message> </validation> <validation> - <expression>inrange 1,5</expression> + <name>inrange</name> + <arguments type="server"> + <argument>inf</argument> + <argument>5</argument> + </arguments> <message>error-number07-2</message> </validation> </validations> diff --git a/src/test/resources/petriNets/validation/valid_regex.xml b/src/test/resources/petriNets/validation/valid_regex.xml index 2b9dd0239a6..7ab73ba623e 100644 --- a/src/test/resources/petriNets/validation/valid_regex.xml +++ b/src/test/resources/petriNets/validation/valid_regex.xml @@ -11,7 +11,10 @@ <title/> <validations> <validation> - <expression>regex ^([0-9]{1,6})$</expression> <!-- Cislo pocet znakov 1-6 --> + <name>regex</name> + <arguments type="server"> + <argument>^([0-9]{1,6})$</argument> <!-- Cislo pocet znakov 1-6 --> + </arguments> <message>error-regex01</message> </validation> </validations> @@ -21,7 +24,10 @@ <title/> <validations> <validation> - <expression>regex ^([a-zA-Z0-9\-]{10})$</expression> <!-- Cislo alebo pismeno a polcka 10 znakov --> + <name>regex</name> + <arguments type="server"> + <argument>^([a-zA-Z0-9\-]{10})$</argument> <!-- Cislo alebo pismeno a polcka 10 znakov --> + </arguments> <message>error-regex02</message> </validation> </validations> @@ -31,7 +37,10 @@ <title/> <validations> <validation> - <expression>regex ^(TOTOK[a-zA-Z0-9]{7})$</expression> <!-- Prefix max 12 znakov --> + <name>regex</name> + <arguments type="server"> + <argument>^(TOTOK[a-zA-Z0-9]{7})$</argument> <!-- Prefix max 12 znakov --> + </arguments> <message>error-regex03</message> </validation> </validations> @@ -41,7 +50,10 @@ <title/> <validations> <validation> - <expression>regex ^([a-zA-Z0-9 ]{1,10})$</expression> <!-- 10 znakov vratane medzeri --> + <name>regex</name> + <arguments type="server"> + <argument>^([a-zA-Z0-9 ]{1,10})$</argument> <!-- 10 znakov vratane medzeri --> + </arguments> <message>error-regex04</message> </validation> </validations> @@ -51,7 +63,10 @@ <title/> <validations> <validation> - <expression>regex ^([A-ž0-9!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/? ]{1,100})$</expression> <!-- pismena a specialne znaky max100 --> + <name>regex</name> + <arguments type="server"> + <argument>^([A-ž0-9!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/? ]{1,100})$</argument> <!-- pismena a specialne znaky max100 --> + </arguments> <message>error-regex05</message> </validation> </validations> @@ -61,7 +76,10 @@ <title/> <validations> <validation> - <expression>regex ^[a-zA-Z0-9\._\%\+\-]+@[a-zA-Z0-9\.\-]+\.[a-zA-Z]{2,}$</expression> <!-- E-mail --> + <name>regex</name> + <arguments type="server"> + <argument>^[a-zA-Z0-9\._\%\+\-]+@[a-zA-Z0-9\.\-]+\.[a-zA-Z]{2,}$</argument> <!-- E-mail --> + </arguments> <message>error-regex06</message> </validation> </validations> diff --git a/src/test/resources/petriNets/validation/valid_text.xml b/src/test/resources/petriNets/validation/valid_text.xml index dba1b777538..0a8016a5a83 100644 --- a/src/test/resources/petriNets/validation/valid_text.xml +++ b/src/test/resources/petriNets/validation/valid_text.xml @@ -11,10 +11,6 @@ <id>text01</id> <title/> <validations> -<!-- <validation>--> -<!-- <expression>email</expression>--> -<!-- <message>error-text01</message>--> -<!-- </validation>--> <validation> <name>email</name> <message>error-text01</message> @@ -25,10 +21,6 @@ <id>text02</id> <title/> <validations> -<!-- <validation>--> -<!-- <expression>telnumber</expression>--> -<!-- <message>error-text02</message>--> -<!-- </validation>--> <validation> <name>telnumber</name> <message>error-text02</message> @@ -39,10 +31,6 @@ <id>text03</id> <title/> <validations> -<!-- <validation>--> -<!-- <expression>maxlength 6</expression>--> -<!-- <message>error-text03</message>--> -<!-- </validation>--> <validation> <name>maxlength</name> <arguments type="server"> @@ -56,10 +44,6 @@ <id>text04</id> <title/> <validations> -<!-- <validation>--> -<!-- <expression>minlength 3</expression>--> -<!-- <message>error-text04</message>--> -<!-- </validation>--> <validation> <name>minlength</name> <arguments type="server"> @@ -73,14 +57,6 @@ <id>text05</id> <title/> <validations> -<!-- <validation>--> -<!-- <expression>minlength 3</expression>--> -<!-- <message>error-text05</message>--> -<!-- </validation>--> -<!-- <validation>--> -<!-- <expression>maxlength 6</expression>--> -<!-- <message>error-text05</message>--> -<!-- </validation>--> <validation> <name>minlength</name> <arguments type="server"> @@ -101,10 +77,6 @@ <id>text06</id> <title/> <validations> -<!-- <validation>--> -<!-- <expression>aaaa number01.rawValue</expression>--> -<!-- <message>error-text06</message>--> -<!-- </validation>--> <validation> <name>aaaa</name> <arguments type="server"> From ce181ff91ccc6406f70de017c4e97138edbc9661 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Martin=20=C5=A0ir=C3=A1=C5=88?= <matosiro4@gmail.com> Date: Wed, 17 Jul 2024 15:22:10 +0200 Subject: [PATCH 07/12] [NAE-1788] Validation register backend - update schema and related data structure --- .../logic/action/ValidationExecutioner.groovy | 23 +++++++--------- .../engine/importer/service/FieldFactory.java | 18 +++++++------ .../petrinet/domain/dataset/Argument.java | 27 +++++++++++++++++++ .../petrinet/domain/dataset/Arguments.java | 11 +++++--- .../domain/dataset/ArgumentsType.java | 19 ------------- .../petrinet/domain/dataset/Validation.java | 12 ++++++--- .../resources/petriNets/petriflow_schema.xsd | 19 ++++++------- .../petriNets/validation/valid_date.xml | 20 +++++++------- .../petriNets/validation/valid_number.xml | 8 +++--- .../petriNets/validation/valid_regex.xml | 24 ++++++++--------- .../petriNets/validation/valid_text.xml | 22 +++++++-------- 11 files changed, 109 insertions(+), 94 deletions(-) create mode 100644 src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/Argument.java delete mode 100644 src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/ArgumentsType.java diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy index 606c5da2789..ef0a7fedc2c 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy @@ -1,7 +1,9 @@ package com.netgrif.application.engine.petrinet.domain.dataset.logic.action import com.netgrif.application.engine.event.IGroovyShellFactory -import com.netgrif.application.engine.petrinet.domain.dataset.ArgumentsType +import com.netgrif.application.engine.petrinet.domain.dataset.Argument +import com.netgrif.application.engine.petrinet.domain.dataset.Arguments + import com.netgrif.application.engine.petrinet.domain.dataset.Field import com.netgrif.application.engine.petrinet.domain.dataset.Validation import com.netgrif.application.engine.validations.ValidationRegistry @@ -30,15 +32,8 @@ abstract class ValidationExecutioner { ValidationDelegate delegate = initDelegate(useCase, field, validations.collect { it.name }) for (Validation validation : validations) { - List<String> argumentList = [] - if (validation.arguments != null) { - if (validation.arguments.type != ArgumentsType.SERVER) { - continue - } - argumentList = validation.arguments.argument - } -// Closure<Boolean> code = initCode(validation, delegate) - if (!delegate."${validation.name}"(*argumentList)) { + Closure<Boolean> code = initCode(validation, delegate) + if (!code()) { throw new IllegalArgumentException(validation.message.toString()) } } @@ -50,11 +45,11 @@ abstract class ValidationExecutioner { } protected Closure<Boolean> initCode(Validation validation, ValidationDelegate delegate) { - List arguments = [] - if (validation.arguments != null) { - arguments = validation.arguments.argument + List<String> argumentList = [] + if (validation.serverArguments != null) { + argumentList = validation.serverArguments.argument.collect { it.isDynamic ? it.value : "\"${it.value}\"" } } - String validationCall = "${validation.name}(${arguments.join(", ")})" + String validationCall = "${validation.name}(${argumentList.join(", ")})" Closure<Boolean> code = this.shellFactory.getGroovyShell().evaluate("{ -> return " + validationCall + " }") as Closure<Boolean> return code.rehydrate(delegate, code.owner, code.thisObject) } diff --git a/src/main/java/com/netgrif/application/engine/importer/service/FieldFactory.java b/src/main/java/com/netgrif/application/engine/importer/service/FieldFactory.java index 851bd12877c..06d6603545e 100644 --- a/src/main/java/com/netgrif/application/engine/importer/service/FieldFactory.java +++ b/src/main/java/com/netgrif/application/engine/importer/service/FieldFactory.java @@ -3,16 +3,11 @@ import com.netgrif.application.engine.configuration.properties.DatabaseProperties; import com.netgrif.application.engine.importer.model.Data; import com.netgrif.application.engine.importer.model.DataType; -import com.netgrif.application.engine.importer.model.Valid; import com.netgrif.application.engine.importer.service.builder.FieldBuilder; import com.netgrif.application.engine.importer.service.throwable.MissingIconKeyException; import com.netgrif.application.engine.importer.service.validation.IDataValidator; import com.netgrif.application.engine.petrinet.domain.Component; -import com.netgrif.application.engine.petrinet.domain.I18nString; -import com.netgrif.application.engine.petrinet.domain.dataset.Arguments; -import com.netgrif.application.engine.petrinet.domain.dataset.ArgumentsType; -import com.netgrif.application.engine.petrinet.domain.dataset.Field; -import com.netgrif.application.engine.petrinet.domain.dataset.Validation; +import com.netgrif.application.engine.petrinet.domain.dataset.*; import lombok.extern.slf4j.Slf4j; import java.util.List; @@ -59,8 +54,15 @@ Field<?> getField(Data data, Importer importer) throws IllegalArgumentException, if (data.getValidations() != null) { List<com.netgrif.application.engine.importer.model.Validation> list = data.getValidations().getValidation(); for (com.netgrif.application.engine.importer.model.Validation item : list) { - Arguments arguments = item.getArguments() != null ? new Arguments(ArgumentsType.fromString(item.getArguments().getType().value()), item.getArguments().getArgument()) : null; - field.addValidation(new Validation(item.getName(), arguments, importer.toI18NString(item.getMessage()))); + Arguments clientArguments = null; + if (item.getClientArguments() != null) { + clientArguments = new Arguments(item.getClientArguments().getArgument().stream().map(arg -> new Argument(arg.getValue(), arg.isDynamic())).collect(Collectors.toList())); + } + Arguments serverArguments = null; + if (item.getServerArguments() != null) { + serverArguments = new Arguments(item.getServerArguments().getArgument().stream().map(arg -> new Argument(arg.getValue(), arg.isDynamic())).collect(Collectors.toList())); + } + field.addValidation(new Validation(item.getName(), clientArguments, serverArguments, importer.toI18NString(item.getMessage()))); } } if (data.getComponent() != null) { diff --git a/src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/Argument.java b/src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/Argument.java new file mode 100644 index 00000000000..bcd44dd3fc2 --- /dev/null +++ b/src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/Argument.java @@ -0,0 +1,27 @@ +package com.netgrif.application.engine.petrinet.domain.dataset; + +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + +import java.io.Serializable; +import java.util.List; + +@Data +@NoArgsConstructor +@AllArgsConstructor +public class Argument implements Serializable { + + private static final long serialVersionUID = -8701225585091953864L; + + protected String value; + protected Boolean isDynamic; + + @Override + public Argument clone() { + Argument cloned = new Argument(); + cloned.setValue(value); + cloned.setIsDynamic(isDynamic); + return cloned; + } +} diff --git a/src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/Arguments.java b/src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/Arguments.java index 59c94fa1993..e3dc353f19c 100644 --- a/src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/Arguments.java +++ b/src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/Arguments.java @@ -5,6 +5,7 @@ import lombok.NoArgsConstructor; import java.io.Serializable; +import java.util.ArrayList; import java.util.List; @Data @@ -14,14 +15,16 @@ public class Arguments implements Serializable { private static final long serialVersionUID = -2385696520525471923L; - protected ArgumentsType type; - protected List<String> argument; + protected List<Argument> argument; @Override public Arguments clone() { Arguments cloned = new Arguments(); - cloned.setType(type); - cloned.setArgument(argument); + if (argument != null) { + List<Argument> clonedArgument = new ArrayList<>(); + argument.forEach(a -> clonedArgument.add(a.clone())); + cloned.setArgument(clonedArgument); + } return cloned; } } diff --git a/src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/ArgumentsType.java b/src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/ArgumentsType.java deleted file mode 100644 index dcb2d84acbf..00000000000 --- a/src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/ArgumentsType.java +++ /dev/null @@ -1,19 +0,0 @@ -package com.netgrif.application.engine.petrinet.domain.dataset; - -import java.util.Arrays; -import java.util.Objects; - -public enum ArgumentsType { - SERVER("server"), - CLIENT("client"); - - public final String type; - - ArgumentsType(String type) { - this.type = type; - } - - public static ArgumentsType fromString(String type) { - return Arrays.stream(values()).filter(argumentsType -> Objects.equals(argumentsType.type, type)).findFirst().orElse(null); - } -} diff --git a/src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/Validation.java b/src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/Validation.java index 7a4b607bd1c..611af521a31 100644 --- a/src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/Validation.java +++ b/src/main/java/com/netgrif/application/engine/petrinet/domain/dataset/Validation.java @@ -6,6 +6,8 @@ import lombok.NoArgsConstructor; import java.io.Serializable; +import java.util.ArrayList; +import java.util.List; @Data @NoArgsConstructor @@ -15,15 +17,19 @@ public class Validation implements Serializable { private static final long serialVersionUID = 3287600522204188694L; protected String name; - private Arguments arguments; + private Arguments clientArguments; + private Arguments serverArguments; private I18nString message; @Override public Validation clone() { Validation cloned = new Validation(); cloned.setName(name); - if (arguments != null) { - cloned.setArguments(arguments.clone()); + if (clientArguments != null) { + cloned.setClientArguments(clientArguments.clone()); + } + if (serverArguments != null) { + cloned.setServerArguments(serverArguments.clone()); } if (this.message != null) { cloned.setMessage(this.message.clone()); diff --git a/src/main/resources/petriNets/petriflow_schema.xsd b/src/main/resources/petriNets/petriflow_schema.xsd index 115b1a30bd8..b98d13925e6 100644 --- a/src/main/resources/petriNets/petriflow_schema.xsd +++ b/src/main/resources/petriNets/petriflow_schema.xsd @@ -593,7 +593,8 @@ <xs:complexType name="validation"> <xs:sequence> <xs:element type="xs:string" name="name"/> - <xs:element name="arguments" type="arguments" minOccurs="0"/> + <xs:element name="clientArguments" type="arguments" minOccurs="0"/> + <xs:element name="serverArguments" type="arguments" minOccurs="0"/> <xs:element name="message" type="i18nStringType" minOccurs="0"/> </xs:sequence> </xs:complexType> @@ -781,16 +782,16 @@ </xs:complexType> <xs:complexType name="arguments"> <xs:sequence> - <xs:element type="xs:string" name="argument" maxOccurs="unbounded" minOccurs="0"/> + <xs:element type="argument" name="argument" maxOccurs="unbounded" minOccurs="0"/> </xs:sequence> - <xs:attribute type="argumentType" name="type" use="required"/> </xs:complexType> - <xs:simpleType name="argumentType"> - <xs:restriction base="xs:string"> - <xs:enumeration value="client"/> - <xs:enumeration value="server"/> - </xs:restriction> - </xs:simpleType> + <xs:complexType name="argument"> + <xs:simpleContent> + <xs:extension base="xs:string"> + <xs:attribute name="dynamic" type="xs:boolean"/> + </xs:extension> + </xs:simpleContent> + </xs:complexType> <!-- UTILS --> <xs:simpleType name="empty"> <xs:restriction base="xs:string"> diff --git a/src/test/resources/petriNets/validation/valid_date.xml b/src/test/resources/petriNets/validation/valid_date.xml index 663c1b2d70f..669003e4c33 100644 --- a/src/test/resources/petriNets/validation/valid_date.xml +++ b/src/test/resources/petriNets/validation/valid_date.xml @@ -13,10 +13,10 @@ <validations> <validation> <name>between</name> <!-- od dnes do buducnosti--> - <arguments type="server"> + <serverArguments> <argument>today</argument> <argument>future</argument> - </arguments> + </serverArguments> <message>error-date01</message> </validation> </validations> @@ -27,10 +27,10 @@ <validations> <validation> <name>between</name> <!-- od minulosti do dnešného dňa --> - <arguments type="server"> + <serverArguments> <argument>past</argument> <argument>today</argument> - </arguments> + </serverArguments> <message>error-date02</message> </validation> </validations> @@ -41,10 +41,10 @@ <validations> <validation> <name>between</name> <!-- od datumu do dnešného dňa --> - <arguments type="server"> + <serverArguments> <argument>2020-03-03</argument> <argument>today</argument> - </arguments> + </serverArguments> <message>error-date03</message> </validation> </validations> @@ -55,10 +55,10 @@ <validations> <validation> <name>between</name> <!-- od minulosti do datumu --> - <arguments type="server"> + <serverArguments> <argument>past</argument> <argument>2020-03-03</argument> - </arguments> + </serverArguments> <message>error-date04</message> </validation> </validations> @@ -69,10 +69,10 @@ <validations> <validation> <name>between</name> <!-- od datumu do datumu --> - <arguments type="server"> + <serverArguments> <argument>2020-01-01</argument> <argument>2022-03-03</argument> - </arguments> + </serverArguments> <message>error-date05</message> </validation> </validations> diff --git a/src/test/resources/petriNets/validation/valid_number.xml b/src/test/resources/petriNets/validation/valid_number.xml index b4341761ead..60737623769 100644 --- a/src/test/resources/petriNets/validation/valid_number.xml +++ b/src/test/resources/petriNets/validation/valid_number.xml @@ -63,10 +63,10 @@ <validations> <validation> <name>inrange</name> - <arguments type="server"> + <serverArguments> <argument>10</argument> <argument>20</argument> - </arguments> + </serverArguments> <message>error-number06</message> </validation> </validations> @@ -82,10 +82,10 @@ </validation> <validation> <name>inrange</name> - <arguments type="server"> + <serverArguments> <argument>inf</argument> <argument>5</argument> - </arguments> + </serverArguments> <message>error-number07-2</message> </validation> </validations> diff --git a/src/test/resources/petriNets/validation/valid_regex.xml b/src/test/resources/petriNets/validation/valid_regex.xml index 7ab73ba623e..8c3d770c2d3 100644 --- a/src/test/resources/petriNets/validation/valid_regex.xml +++ b/src/test/resources/petriNets/validation/valid_regex.xml @@ -12,9 +12,9 @@ <validations> <validation> <name>regex</name> - <arguments type="server"> + <serverArguments> <argument>^([0-9]{1,6})$</argument> <!-- Cislo pocet znakov 1-6 --> - </arguments> + </serverArguments> <message>error-regex01</message> </validation> </validations> @@ -25,9 +25,9 @@ <validations> <validation> <name>regex</name> - <arguments type="server"> + <serverArguments> <argument>^([a-zA-Z0-9\-]{10})$</argument> <!-- Cislo alebo pismeno a polcka 10 znakov --> - </arguments> + </serverArguments> <message>error-regex02</message> </validation> </validations> @@ -38,9 +38,9 @@ <validations> <validation> <name>regex</name> - <arguments type="server"> + <serverArguments> <argument>^(TOTOK[a-zA-Z0-9]{7})$</argument> <!-- Prefix max 12 znakov --> - </arguments> + </serverArguments> <message>error-regex03</message> </validation> </validations> @@ -51,9 +51,9 @@ <validations> <validation> <name>regex</name> - <arguments type="server"> + <serverArguments> <argument>^([a-zA-Z0-9 ]{1,10})$</argument> <!-- 10 znakov vratane medzeri --> - </arguments> + </serverArguments> <message>error-regex04</message> </validation> </validations> @@ -64,9 +64,9 @@ <validations> <validation> <name>regex</name> - <arguments type="server"> + <serverArguments> <argument>^([A-ž0-9!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/? ]{1,100})$</argument> <!-- pismena a specialne znaky max100 --> - </arguments> + </serverArguments> <message>error-regex05</message> </validation> </validations> @@ -77,9 +77,9 @@ <validations> <validation> <name>regex</name> - <arguments type="server"> + <serverArguments> <argument>^[a-zA-Z0-9\._\%\+\-]+@[a-zA-Z0-9\.\-]+\.[a-zA-Z]{2,}$</argument> <!-- E-mail --> - </arguments> + </serverArguments> <message>error-regex06</message> </validation> </validations> diff --git a/src/test/resources/petriNets/validation/valid_text.xml b/src/test/resources/petriNets/validation/valid_text.xml index 0a8016a5a83..80bbbd56bf1 100644 --- a/src/test/resources/petriNets/validation/valid_text.xml +++ b/src/test/resources/petriNets/validation/valid_text.xml @@ -33,9 +33,9 @@ <validations> <validation> <name>maxlength</name> - <arguments type="server"> + <serverArguments> <argument>6</argument> - </arguments> + </serverArguments> <message>error-text03</message> </validation> </validations> @@ -46,9 +46,9 @@ <validations> <validation> <name>minlength</name> - <arguments type="server"> + <serverArguments> <argument>3</argument> - </arguments> + </serverArguments> <message>error-text04</message> </validation> </validations> @@ -59,16 +59,16 @@ <validations> <validation> <name>minlength</name> - <arguments type="server"> + <serverArguments> <argument>3</argument> - </arguments> + </serverArguments> <message>error-text05</message> </validation> <validation> <name>maxlength</name> - <arguments type="server"> + <serverArguments> <argument>6</argument> - </arguments> + </serverArguments> <message>error-text05</message> </validation> </validations> @@ -79,9 +79,9 @@ <validations> <validation> <name>aaaa</name> - <arguments type="server"> - <argument>number01.rawValue</argument> - </arguments> + <serverArguments> + <argument dynamic="true">number01.rawValue</argument> + </serverArguments> <message>error-text06</message> </validation> </validations> From 7458e091da33ba16bdba271590e3675f03c3d12c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Martin=20=C5=A0ir=C3=A1=C5=88?= <matosiro4@gmail.com> Date: Tue, 23 Jul 2024 08:30:30 +0200 Subject: [PATCH 08/12] [NAE-1788] Validation register backend - update validation delegate and executioner - add more tests for dynamic validations - update other tests for new validations --- .../logic/action/ActionDelegate.groovy | 4 +- .../logic/action/ValidationDelegate.groovy | 16 ------ .../logic/action/ValidationExecutioner.groovy | 9 ++- .../engine/startup/ValidationRunner.groovy | 2 +- .../engine/workflow/service/TaskService.java | 24 -------- .../petriNets/engine-processes/org_group.xml | 2 +- .../event/GroovyShellFactoryTest.groovy | 4 +- .../petrinet/domain/dataset/FieldTest.groovy | 35 +++++++----- .../validation/ValidationTestDynamic.groovy | 55 +++++++++++++++---- src/test/resources/data_test.xml | 53 +++++++++++++----- .../resources/petriNets/groovy_shell_test.xml | 4 +- .../petriNets/validation/valid_text.xml | 13 +++++ 12 files changed, 132 insertions(+), 89 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 7f66d94b387..18521bc1a0b 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 @@ -1088,8 +1088,8 @@ class ActionDelegate /*TODO: release/8.0.0: implements ActionAPI*/ { } } - Validation validation(String rule, I18nString message) { - return new Validation(rule, message) + Validation validation(String name, Arguments clientArguments, Arguments serverArguments, I18nString message) { + return new Validation(name, clientArguments, serverArguments, message) } // TODO: release/8.0.0 remove? diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationDelegate.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationDelegate.groovy index 59181b23ef8..a05cf65e956 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationDelegate.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationDelegate.groovy @@ -28,11 +28,6 @@ class ValidationDelegate { Boolean requiredtrue() { return thisField instanceof BooleanField && notempty() && thisField.rawValue == true } // date field validations - Closure<String> future = { return FUTURE } - Closure<String> today = { return TODAY } - Closure<String> past = { return PAST } - Closure<String> now = { return NOW } - Boolean between(def from, def to) { if (!(thisField instanceof DateField || thisField instanceof DateTimeField)) { return false @@ -53,8 +48,6 @@ class ValidationDelegate { toDate = parsedDate ? parsedDate.atStartOfDay() : to } - log.warn("{} > between {}, {}", thisFieldValue, fromDate, toDate) - if ((fromDate == TODAY || fromDate == NOW) && toDate == FUTURE) { if (thisFieldValue < updateDate_TODAY) { return false @@ -115,8 +108,6 @@ class ValidationDelegate { } // number field validations - Closure<String> inf = { return INF } - Boolean odd() { return thisField instanceof NumberField && notempty() && thisField.rawValue as Double % 2 != 0 } Boolean even() { return thisField instanceof NumberField && notempty() && thisField.rawValue as Double % 2 == 0 } @@ -128,13 +119,6 @@ class ValidationDelegate { Boolean decimal() { return thisField instanceof NumberField && notempty() && thisField.rawValue as Double % 1 == 0 } Boolean inrange(def from, def to) { - if (from == inf) { - from = inf() - } - - if (to == inf) { - to = inf() - } if (from instanceof String && from.toLowerCase() == INF) { from = Double.MIN_VALUE diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy index ef0a7fedc2c..c94f3732d0a 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy @@ -1,8 +1,6 @@ package com.netgrif.application.engine.petrinet.domain.dataset.logic.action import com.netgrif.application.engine.event.IGroovyShellFactory -import com.netgrif.application.engine.petrinet.domain.dataset.Argument -import com.netgrif.application.engine.petrinet.domain.dataset.Arguments import com.netgrif.application.engine.petrinet.domain.dataset.Field import com.netgrif.application.engine.petrinet.domain.dataset.Validation @@ -44,10 +42,15 @@ abstract class ValidationExecutioner { return this.registry.getValidation(validationName) } + protected static String escapeSpecialCharacters(String s){ + return s.replace('\\', '\\\\') + .replace('\'', '\\\'') + } + protected Closure<Boolean> initCode(Validation validation, ValidationDelegate delegate) { List<String> argumentList = [] if (validation.serverArguments != null) { - argumentList = validation.serverArguments.argument.collect { it.isDynamic ? it.value : "\"${it.value}\"" } + argumentList = validation.serverArguments.argument.collect { it.isDynamic ? it.value : "'${escapeSpecialCharacters(it.value)}'" } } String validationCall = "${validation.name}(${argumentList.join(", ")})" Closure<Boolean> code = this.shellFactory.getGroovyShell().evaluate("{ -> return " + validationCall + " }") as Closure<Boolean> diff --git a/src/main/groovy/com/netgrif/application/engine/startup/ValidationRunner.groovy b/src/main/groovy/com/netgrif/application/engine/startup/ValidationRunner.groovy index 0b67826536b..34ac806b411 100644 --- a/src/main/groovy/com/netgrif/application/engine/startup/ValidationRunner.groovy +++ b/src/main/groovy/com/netgrif/application/engine/startup/ValidationRunner.groovy @@ -41,7 +41,7 @@ class ValidationRunner extends AbstractOrderedCommandLineRunner { helper.upsertNet(VALIDATION_FILE_NAME, VALIDATION_PETRI_NET_IDENTIFIER) CaseSearchRequest request = new CaseSearchRequest() - request.query = String.format("processIdentifier:%s AND dataSet.%s.value:true", VALIDATION_PETRI_NET_IDENTIFIER, VALIDATION_ACTIVE_FIELD_ID) + request.query = String.format("processIdentifier:%s AND dataSet.%s.booleanValue:true", VALIDATION_PETRI_NET_IDENTIFIER, VALIDATION_ACTIVE_FIELD_ID) long numberActiveValidations = elasticCaseService.count([request], userService.loggedOrSystem.transformToLoggedUser(), LocaleContextHolder.locale, false) int pageCount = (int) (numberActiveValidations / PAGE_SIZE) + 1 pageCount.times { 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 9e602ed5384..1db3244a080 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 @@ -551,30 +551,6 @@ protected List<EventOutcome> executeTransition(Task task, Case useCase) { return outcomes; } - 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 -// && useCase.getPetriNet().getDataSet().get(entry.getKey()).getValidations() != null) { -// validation.valid(useCase.getPetriNet().getDataSet().get(entry.getKey()), useCase.getDataField(entry.getKey())); -// } -// if (!useCase.getDataField(entry.getKey()).isRequired(transition.getImportId())) -// continue; -// if (useCase.getDataField(entry.getKey()).isUndefined(transition.getImportId()) && !entry.getValue().isRequired()) -// continue; -// -// Object value = useCase.getDataSet().get(entry.getKey()).getValue(); -// if (value == null) { -// Field field = useCase.getField(entry.getKey()); -// throw new IllegalArgumentException("Field \"" + field.getName() + "\" has null value"); -// } -// if (value instanceof String && ((String) value).isEmpty()) { -// Field field = useCase.getField(entry.getKey()); -// throw new IllegalArgumentException("Field \"" + field.getName() + "\" has empty value"); -// } -// } - } - protected void scheduleTaskExecution(Task task, LocalDateTime time, Case useCase) { log.info("[{}]: Task {} scheduled to run at {}", useCase.getStringId(), task.getTitle(), time.toString()); scheduler.schedule(() -> { diff --git a/src/main/resources/petriNets/engine-processes/org_group.xml b/src/main/resources/petriNets/engine-processes/org_group.xml index 67a91e1a48d..ef669d7a13a 100644 --- a/src/main/resources/petriNets/engine-processes/org_group.xml +++ b/src/main/resources/petriNets/engine-processes/org_group.xml @@ -103,7 +103,7 @@ <desc name="invite_by_mail_desc">Add e-meail address to send invitation</desc> <validations> <validation> - <expression>email</expression> + <name>email</name> <message/> </validation> </validations> 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/petrinet/domain/dataset/FieldTest.groovy b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FieldTest.groovy index a0d1c0f70da..0596b2cef7c 100644 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FieldTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/FieldTest.groovy @@ -94,9 +94,10 @@ class FieldTest { assert field.placeholder.defaultValue == "Number field placeholder" //TODO: release/8.0.0 validations are ignored // java.lang.NullPointerException: Cannot invoke method get() on null object - assert field.validations.get(0).rule == "inrange 0,inf" - assert field.validations.get(1).rule == "inrange 0,inf" - assert field.validations.get(1).message.defaultValue == "Number field validation message" + assert field.validations.get(0).name == "inrange" + assert field.validations.get(0).serverArguments.argument.get(0).value == "0" + assert field.validations.get(0).serverArguments.argument.get(1).value == "inf" + assert field.validations.get(0).message.defaultValue == "Number field validation message" } private void assertTextField() { @@ -105,9 +106,8 @@ class FieldTest { assert field.description.defaultValue == "Text field description" assert field.name.defaultValue == "Text" assert field.placeholder.defaultValue == "Text field placeholder" - assert field.validations.get(0).rule == "email" - assert field.validations.get(1).rule == "email" - assert field.validations.get(1).message.defaultValue == "Mail validation message" + assert field.validations.get(0).name == "email" + assert field.validations.get(0).message.defaultValue == "Mail validation message" } private void assertEnumerationField() { @@ -153,11 +153,14 @@ class FieldTest { assert field.description.defaultValue == "Date field description" assert field.name.defaultValue == "Date" assert field.placeholder.defaultValue == "Date field placeholder" - assert field.validations.get(0).rule == "between today,future" - assert field.validations.get(1).message.defaultValue == "Date field validation message" - assert field.validations.get(1).rule == "between today,future" - assert field.validations.get(2).message.defaultValue == "Date field validation message 2" - assert field.validations.get(2).rule == "between today,tommorow" + assert field.validations.get(0).message.defaultValue == "Date field validation message" + assert field.validations.get(0).name == "between" + assert field.validations.get(0).serverArguments.argument.get(0).value == "today" + assert field.validations.get(0).serverArguments.argument.get(1).value == "future" + assert field.validations.get(1).message.defaultValue == "Date field validation message 2" + assert field.validations.get(1).name == "between" + assert field.validations.get(1).serverArguments.argument.get(0).value == "today" + assert field.validations.get(1).serverArguments.argument.get(1).value == "tommorow" } private void assertFileField() { @@ -217,9 +220,15 @@ class FieldTest { assert field.description.defaultValue == "This is I18n text field" assert field.placeholder.defaultValue == "Text I18n field" assert field.defaultValue.defaultValue == "Default i18n text value" - assert field.validations.get(0).rule == "translationRequired sk,en" + assert field.validations.get(0).name == "translationRequired" + assert field.validations.get(0).serverArguments.argument.get(0).value == "sk" + assert field.validations.get(0).serverArguments.argument.get(1).value == "en" assert field.validations.get(0).message.defaultValue == "Slovak and English language required" - assert field.validations.get(1).rule == "translationOnly sk,en,cz,de" + assert field.validations.get(1).name == "translationOnly" + assert field.validations.get(1).serverArguments.argument.get(0).value == "sk" + assert field.validations.get(1).serverArguments.argument.get(1).value == "en" + assert field.validations.get(1).serverArguments.argument.get(2).value == "cz" + assert field.validations.get(1).serverArguments.argument.get(3).value == "de" assert field.validations.get(1).message.defaultValue == "Only Slovak, English, Czech and German languages allowed" } } \ No newline at end of file diff --git a/src/test/groovy/com/netgrif/application/engine/validation/ValidationTestDynamic.groovy b/src/test/groovy/com/netgrif/application/engine/validation/ValidationTestDynamic.groovy index 1d77bc6d792..40d1c5506a4 100644 --- a/src/test/groovy/com/netgrif/application/engine/validation/ValidationTestDynamic.groovy +++ b/src/test/groovy/com/netgrif/application/engine/validation/ValidationTestDynamic.groovy @@ -7,13 +7,11 @@ import com.netgrif.application.engine.petrinet.domain.dataset.Field import com.netgrif.application.engine.petrinet.domain.dataset.TextField 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.startup.ValidationRunner import com.netgrif.application.engine.validations.interfaces.IValidationService 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.repositories.CaseRepository -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.Assertions @@ -36,26 +34,20 @@ class ValidationTestDynamic { @Autowired private ImportHelper importHelper - @Autowired - private CaseRepository caseRepository - @Autowired private TestHelper testHelper @Autowired private IPetriNetService petriNetService - @Autowired - private SuperCreator superCreator - @Autowired private IWorkflowService workflowService @Autowired - private ITaskService taskService + private IValidationService validationService @Autowired - private IValidationService validationService + protected ValidationRunner validationRunner @BeforeEach void setup() { @@ -135,4 +127,45 @@ class ValidationTestDynamic { assert "error-text06" == thrown.getMessage() } + + @Test + void textDynamic_validation_conflictWithFieldName() { + + createValidation("number01", "a -> thisField.rawValue.size() == a as Integer", true) + + PetriNet testNet = importTextNet() + Case aCase = importHelper.createCase("TestCase", testNet) + assert aCase != null + Task task = importHelper.assignTaskToSuper("Test", aCase.stringId).getTask() + assert task != null + + Assertions.assertThrows(MissingMethodException.class, () -> { + importHelper.setTaskData(task.getStringId(), new DataSet(["text07": new TextField(rawValue: "1234567")])) + Task taskFinish = importHelper.finishTaskAsSuper("Test", aCase.stringId).getTask() + assert taskFinish != null + }) + } + + @Test + void dynamicValidation_importActive() { + createValidation("test1", "-> thisField.rawValue = 1", true) + createValidation("test2", "-> thisField.rawValue = 2", true) + createValidation("test3", "-> thisField.rawValue = 3", false) + + assert validationService.getValidation("test1") instanceof Closure<Boolean> && validationService.getValidation("test1") != null + assert validationService.getValidation("test2") instanceof Closure<Boolean> && validationService.getValidation("test2") != null + assert validationService.getValidation("test3") == null + + validationService.clearValidations() + + assert validationService.getValidation("test1") == null + assert validationService.getValidation("test2") == null + assert validationService.getValidation("test3") == null + + validationRunner.run() + + assert validationService.getValidation("test1") instanceof Closure<Boolean> && validationService.getValidation("test1") != null + assert validationService.getValidation("test2") instanceof Closure<Boolean> && validationService.getValidation("test2") != null + assert validationService.getValidation("test3") == null + } } diff --git a/src/test/resources/data_test.xml b/src/test/resources/data_test.xml index a9e4feb8786..4060c221c99 100644 --- a/src/test/resources/data_test.xml +++ b/src/test/resources/data_test.xml @@ -10,10 +10,13 @@ <title>Number Number field placeholder Number field description - inrange 0,inf - inrange 0,inf + inrange + + 0 + inf + Number field validation message @@ -25,10 +28,9 @@ Text Text field placeholder Text field description - email - email + email Mail validation message @@ -67,10 +69,9 @@ Boolean Boolean field placeholder Boolean field description - requiredTrue - requiredTrue + requiredTrue Boolean field validation message @@ -82,14 +83,21 @@ Date Date field placeholder Date field description - between today,future - between today,future + between + + today + future + Date field validation message - between today,tommorow + between + + today + tommorow + Date field validation message 2 @@ -114,14 +122,21 @@ DateTime DateTime field placeholder DateTime field description - between today,future - between today,future + between + + today + future + Date field validation message - between today,future + between + + today + future + Date field validation message 2 @@ -162,11 +177,21 @@ Default i18n text value - translationRequired sk,en + translationRequired + + sk + en + Slovak and English language required - translationOnly sk,en,cz,de + translationOnly + + sk + en + cz + de + Only Slovak, English, Czech and German languages allowed diff --git a/src/test/resources/petriNets/groovy_shell_test.xml b/src/test/resources/petriNets/groovy_shell_test.xml index 51d41498cbe..a2a631389e9 100644 --- a/src/test/resources/petriNets/groovy_shell_test.xml +++ b/src/test/resources/petriNets/groovy_shell_test.xml @@ -25,7 +25,7 @@ newVariable_1 - validation("String", new I18nString("I18nString")) + validation("String", null, null, new I18nString("I18nString")) return "value" @@ -43,7 +43,7 @@ t1_assign - validation("String", new I18nString("I18nString")) + validation("String", null, null, new I18nString("I18nString")) diff --git a/src/test/resources/petriNets/validation/valid_text.xml b/src/test/resources/petriNets/validation/valid_text.xml index 80bbbd56bf1..dc83017552a 100644 --- a/src/test/resources/petriNets/validation/valid_text.xml +++ b/src/test/resources/petriNets/validation/valid_text.xml @@ -86,6 +86,19 @@ + + text07 + + <validations> + <validation> + <name>number01</name> + <serverArguments> + <argument dynamic="true">number01.rawValue</argument> + </serverArguments> + <message>error-text07</message> + </validation> + </validations> + </data> <data type="number"> <id>number01</id> <title/> From aa11d673dc17e0f459fb6d72805bb82984194b77 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Martin=20=C5=A0ir=C3=A1=C5=88?= <matosiro4@gmail.com> Date: Tue, 23 Jul 2024 08:52:15 +0200 Subject: [PATCH 09/12] [NAE-1788] Validation register backend - update transition validation in ValidationService --- .../application/engine/validations/ValidationService.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/main/java/com/netgrif/application/engine/validations/ValidationService.java b/src/main/java/com/netgrif/application/engine/validations/ValidationService.java index d334edf4e40..0aa8fe955df 100644 --- a/src/main/java/com/netgrif/application/engine/validations/ValidationService.java +++ b/src/main/java/com/netgrif/application/engine/validations/ValidationService.java @@ -31,9 +31,9 @@ public ValidationService(ValidationRegistry validationRegistry, ValidationExecut @Override public void validateTransition(Case useCase, Transition transition) { - transition.getDataSet().values().forEach(dataRef -> { - if (dataRef.getField() != null) { - validationExecutioner.execute(useCase, dataRef.getField(), dataRef.getField().getValidations()); + transition.getDataSet().keySet().forEach(fieldId -> { + if (useCase.getDataSet().get(fieldId) != null) { + validationExecutioner.execute(useCase, useCase.getDataSet().get(fieldId), useCase.getDataSet().get(fieldId).getValidations()); } }); } From e536b09b12ede163b8b32b55b1d3b85cda60d0cd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Martin=20=C5=A0ir=C3=A1=C5=88?= <matosiro4@gmail.com> Date: Wed, 24 Jul 2024 15:49:22 +0200 Subject: [PATCH 10/12] [NAE-1788] Validation register backend - refactor executioner - update ValidationRunner: mongo search - update validation process - update tests - remove unnecessary tests --- .../logic/action/ValidationDelegate.groovy | 1 + .../logic/action/ValidationExecutioner.groovy | 37 +- .../engine/startup/ValidationRunner.groovy | 19 +- .../validations/validation.xml | 119 +- .../DynamicValidationPerformanceTest.groovy | 100 - .../dataset/DynamicValidationTest.groovy | 121 - .../validation/ValidationTestDynamic.groovy | 3 +- .../petriNets/dynamic_validations.xml | 132 - .../dynamic_validations_performance_test.xml | 3306 ----------------- ...alidations_performance_test_comparison.xml | 3278 ---------------- 10 files changed, 108 insertions(+), 7008 deletions(-) delete mode 100644 src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicValidationPerformanceTest.groovy delete mode 100644 src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicValidationTest.groovy delete mode 100644 src/test/resources/petriNets/dynamic_validations.xml delete mode 100644 src/test/resources/petriNets/dynamic_validations_performance_test.xml delete mode 100644 src/test/resources/petriNets/dynamic_validations_performance_test_comparison.xml diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationDelegate.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationDelegate.groovy index a05cf65e956..e887fe51afb 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationDelegate.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationDelegate.groovy @@ -20,6 +20,7 @@ class ValidationDelegate { public static final String TEL_NUMBER_REGEX = '^(?:\\+?(\\d{1,3}))?([-. (]*(\\d{3})[-. )]*)?((\\d{3})[-. ]*(\\d{2,4})(?:[-.x ]*(\\d+))?)$' public static final String EMAIL_REGEX = '^[a-zA-Z0-9\\._\\%\\+\\-]+@[a-zA-Z0-9\\.\\-]+\\.[a-zA-Z]{2,}$' + // todo NAE-1788: thisField keyword Field<?> thisField Boolean notempty() { return thisField.rawValue != null } diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy index c94f3732d0a..dae3e620ce6 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy @@ -1,7 +1,6 @@ package com.netgrif.application.engine.petrinet.domain.dataset.logic.action import com.netgrif.application.engine.event.IGroovyShellFactory - import com.netgrif.application.engine.petrinet.domain.dataset.Field import com.netgrif.application.engine.petrinet.domain.dataset.Validation import com.netgrif.application.engine.validations.ValidationRegistry @@ -25,15 +24,17 @@ abstract class ValidationExecutioner { private IGroovyShellFactory shellFactory void execute(Case useCase, Field<?> field, List<Validation> validations) { - if (validations) { - log.info("Validations: ${validations.collect { it.name }}") + if (!validations) { + return + } - ValidationDelegate delegate = initDelegate(useCase, field, validations.collect { it.name }) - for (Validation validation : validations) { - Closure<Boolean> code = initCode(validation, delegate) - if (!code()) { - throw new IllegalArgumentException(validation.message.toString()) - } + log.info("Validations: ${validations.collect { it.name }}") + + ValidationDelegate delegate = initDelegate(useCase, field, validations.collect { it.name }) + for (Validation validation : validations) { + Closure<Boolean> code = initCode(validation, delegate) + if (!code()) { + throw new IllegalArgumentException(validation.message.toString()) } } } @@ -64,16 +65,22 @@ abstract class ValidationExecutioner { delegate.metaClass."$field.importId" = field } - Set commonFieldValidationNames = useCase.dataSet.fields.keySet() - commonFieldValidationNames.retainAll(validationNames) - if (!commonFieldValidationNames.isEmpty()) { - log.warn("Ignoring validations {} for case [{}]: field names are identical with validation names", commonFieldValidationNames, useCase.stringId) - validationNames -= commonFieldValidationNames - } + List<String> fieldNames = useCase.dataSet.fields.keySet() as List<String> + validationNames = filterConflictedValidationNames(fieldNames, validationNames) validationNames.forEach { validationName -> delegate.metaClass."$validationName" = getValidationCode(validationName) } + delegate.thisField = thisField return delegate } + + private List<String> filterConflictedValidationNames(List<String> fieldNames, List<String> validationNames) { + fieldNames.retainAll(validationNames) + if (!fieldNames.isEmpty()) { + log.warn("Ignoring validations {} for case [{}]: field names are identical with validation names", fieldNames, useCase.stringId) + validationNames -= fieldNames + } + return validationNames + } } diff --git a/src/main/groovy/com/netgrif/application/engine/startup/ValidationRunner.groovy b/src/main/groovy/com/netgrif/application/engine/startup/ValidationRunner.groovy index 34ac806b411..6270f0c9761 100644 --- a/src/main/groovy/com/netgrif/application/engine/startup/ValidationRunner.groovy +++ b/src/main/groovy/com/netgrif/application/engine/startup/ValidationRunner.groovy @@ -1,13 +1,13 @@ package com.netgrif.application.engine.startup import com.netgrif.application.engine.auth.service.interfaces.IUserService -import com.netgrif.application.engine.elastic.service.interfaces.IElasticCaseService -import com.netgrif.application.engine.elastic.web.requestbodies.CaseSearchRequest import com.netgrif.application.engine.validations.interfaces.IValidationService import com.netgrif.application.engine.workflow.domain.Case +import com.netgrif.application.engine.workflow.domain.QCase +import com.netgrif.application.engine.workflow.domain.repositories.CaseRepository +import com.querydsl.core.types.Predicate import groovy.util.logging.Slf4j import org.springframework.beans.factory.annotation.Autowired -import org.springframework.context.i18n.LocaleContextHolder import org.springframework.data.domain.PageRequest import org.springframework.stereotype.Component @@ -18,7 +18,6 @@ class ValidationRunner extends AbstractOrderedCommandLineRunner { private static final int PAGE_SIZE = 100 public static final String VALIDATION_FILE_NAME = "engine-processes/validations/validation.xml" public static final String VALIDATION_PETRI_NET_IDENTIFIER = "validation" - public static final String VALIDATION_ACTIVE_FIELD_ID = "active" public static final String VALIDATION_NAME_FIELD_ID = "name" public static final String VALIDATION_GROOVY_DEFINITION_FIELD_ID = "validation_definition_groovy" @@ -32,20 +31,18 @@ class ValidationRunner extends AbstractOrderedCommandLineRunner { private IValidationService validationService @Autowired - private IElasticCaseService elasticCaseService + private CaseRepository caseRepository @Override void run(String... strings) throws Exception { log.info("Starting validation runner") helper.upsertNet(VALIDATION_FILE_NAME, VALIDATION_PETRI_NET_IDENTIFIER) - - CaseSearchRequest request = new CaseSearchRequest() - request.query = String.format("processIdentifier:%s AND dataSet.%s.booleanValue:true", VALIDATION_PETRI_NET_IDENTIFIER, VALIDATION_ACTIVE_FIELD_ID) - long numberActiveValidations = elasticCaseService.count([request], userService.loggedOrSystem.transformToLoggedUser(), LocaleContextHolder.locale, false) + Predicate predicate = QCase.case$.tasks.get("deactivate").isNotNull() + long numberActiveValidations = caseRepository.count(predicate) int pageCount = (int) (numberActiveValidations / PAGE_SIZE) + 1 - pageCount.times { - elasticCaseService.search([request], userService.loggedOrSystem.transformToLoggedUser(), PageRequest.of(it, PAGE_SIZE), LocaleContextHolder.locale, false) + pageCount.times { pageNum -> + caseRepository.findAll(predicate, PageRequest.of(pageNum, PAGE_SIZE)) .getContent() .each { Case validationCase -> validationService.registerValidation( diff --git a/src/main/resources/petriNets/engine-processes/validations/validation.xml b/src/main/resources/petriNets/engine-processes/validations/validation.xml index 68183fdc049..75bbf1c69f4 100644 --- a/src/main/resources/petriNets/engine-processes/validations/validation.xml +++ b/src/main/resources/petriNets/engine-processes/validations/validation.xml @@ -71,32 +71,56 @@ <id>version</id> <title name="version">Version - - active - Is active - false - + + validation_type + Type + + + + + + validation_type_set + + + validation_type: f.validation_type, + validation_definition_groovy: f.validation_definition_groovy, + num_arguments_groovy: f.num_arguments_groovy, + validation_definition_javascript: f.validation_definition_javascript, + num_arguments_javascript: f.num_arguments_javascript, + init_trans: t.init, + detail_trans: t.detail; + + make [validation_definition_groovy, num_arguments_groovy], editable on init_trans when { validation_type.value && validation_type.value.contains("server") } + make [validation_definition_groovy, num_arguments_groovy], visible on detail_trans when { validation_type.value && validation_type.value.contains("server") } + make [validation_definition_groovy, num_arguments_groovy], hidden on transitions when { validation_type.value && validation_type.value.contains("server") } + make [validation_definition_javascript, num_arguments_javascript], editable on transitions when { validation_type.value && validation_type.value.contains("client") } + make [validation_definition_javascript, num_arguments_javascript], visible on detail_trans when { validation_type.value && validation_type.value.contains("server") } + make [validation_definition_javascript, num_arguments_javascript], hidden on transitions when { validation_type.value && validation_type.value.contains("client") } + + + + Meno + Typ Definícia validácie - Groovy Počet argumentov - Groovy Definícia validácie - JavaScript Počet argumentov - JavaScript Verzia - Je aktívny Detail Aktivovať Deaktivovať Name + Typ Validierungsdefinition - Groovy Anzahl der Argumente - Groovy Validierungsdefinition - JavaScript Anzahl der Argumente - JavaScript Ausführung - Ist aktiv Detail Aktivieren Deaktivieren @@ -129,12 +153,11 @@ validation_definition_groovy - editable - required + hidden 0 - 1 + 2 2 4 @@ -144,11 +167,11 @@ validation_definition_javascript - editable + hidden 0 - 4 + 5 2 4 @@ -172,12 +195,11 @@ num_arguments_groovy - editable - required + hidden 0 - 3 + 4 1 2 @@ -187,17 +209,32 @@ num_arguments_javascript - editable + hidden 0 - 6 + 7 1 2 outline + + validation_type + + editable + required + + + 0 + 1 + 1 + 4 + + outline + + init_assign @@ -224,18 +261,17 @@ true true true + true onFinish_activate - + name: f.name, - validation_definition_groovy: f.validation_definition_groovy, - active: f.active; + validation_definition_groovy: f.validation_definition_groovy; validationService.registerValidation(name.rawValue, validation_definition_groovy.rawValue) - change active value { true } @@ -258,11 +294,9 @@ onFinish_deactivate - name: f.name, - active: f.active; + name: f.name; validationService.unregisterValidation(name.rawValue) - change active value { false } @@ -290,20 +324,6 @@ outline - - active - - visible - - - 2 - 1 - 1 - 2 - - outline - - version @@ -321,7 +341,7 @@ validation_definition_javascript - editable + hidden 0 @@ -335,8 +355,7 @@ validation_definition_groovy - editable - required + hidden 0 @@ -350,7 +369,7 @@ num_arguments_groovy - visible + hidden 0 @@ -364,7 +383,7 @@ num_arguments_javascript - visible + hidden 0 @@ -375,6 +394,20 @@ outline + + validation_type + + visible + + + 0 + 1 + 1 + 4 + + outline + + detail_assign 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 deleted file mode 100644 index a3992a8c08a..00000000000 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicValidationPerformanceTest.groovy +++ /dev/null @@ -1,100 +0,0 @@ -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.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 groovy.transform.CompileStatic -import groovy.util.logging.Slf4j -import org.junit.jupiter.api.BeforeEach -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 -import org.springframework.test.context.ActiveProfiles -import org.springframework.test.context.junit.jupiter.SpringExtension - -import java.time.LocalDateTime -import java.time.format.DateTimeFormatter -import java.time.temporal.ChronoUnit - -@Slf4j -@SpringBootTest -@ActiveProfiles(["test"]) -@CompileStatic -@ExtendWith(SpringExtension.class) -class DynamicValidationPerformanceTest { - - @Autowired - private TestHelper testHelper - - @Autowired - private ImportHelper importHelper - - @Autowired - private IPetriNetService petriNetService - - @Autowired - private SuperCreator superCreator - - @Autowired - private IDataService dataService - - @Autowired - private ITaskService taskService - - @Autowired - private IWorkflowService workflowService - - @BeforeEach - void before() { - testHelper.truncateDbs() - } - - @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()) - - def aCase1 = importHelper.createCase("Case 1", optNet1.getNet()) - def aCase2 = importHelper.createCase("Case 2", optNet2.getNet()) - - run(aCase1, aCase2) - run(aCase1, aCase2) - run(aCase1, aCase2) - run(aCase1, aCase2) - run(aCase1, aCase2) - run(aCase1, aCase2) - } - - Map getData(Case useCase) { - Task task = task(useCase) - return dataService.getData(task, useCase, superCreator.getSuperUser()).getData().collectEntries { [(it.fieldId): (it)] } - } - - Task task(Case useCase) { - return taskService.findOne(useCase.getTaskStringId("transition")) - } - - void run(Case first, Case second) { - LocalDateTime pre1 = LocalDateTime.now() - getData(first) - LocalDateTime post1 = LocalDateTime.now() - - LocalDateTime pre2 = LocalDateTime.now() - getData(second) - LocalDateTime post2 = LocalDateTime.now() - - DateTimeFormatter format = DateTimeFormatter.ofPattern("dd.MM.yyyy HH:mm:ss.SSS") - log.info("With dynamic validations: ${pre1.format(format)} - ${post1.format(format)} = ${ChronoUnit.MILLIS.between(pre1, post1)}ms") - log.info("With static validations: ${pre2.format(format)} - ${post2.format(format)} = ${ChronoUnit.MILLIS.between(pre2, post2)}ms") - } -} 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 deleted file mode 100644 index 3f2a1f5479c..00000000000 --- a/src/test/groovy/com/netgrif/application/engine/petrinet/domain/dataset/DynamicValidationTest.groovy +++ /dev/null @@ -1,121 +0,0 @@ -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 -import org.springframework.test.context.ActiveProfiles -import org.springframework.test.context.junit.jupiter.SpringExtension - -@SpringBootTest -@ActiveProfiles(["test"]) -@ExtendWith(SpringExtension.class) -class DynamicValidationTest { - - @Autowired - private TestHelper testHelper - - @Autowired - private ImportHelper importHelper - - @Autowired - private IPetriNetService petriNetService - - @Autowired - private SuperCreator superCreator - - @Autowired - private IDataService dataService - - @Autowired - private ITaskService taskService - - @Autowired - private IWorkflowService workflowService - - @BeforeEach - void before() { - testHelper.truncateDbs(); - } - -// @Test -// @Disabled -// void testValidations() { -// ImportPetriNetEventOutcome optNet = petriNetService.importPetriNet(new FileInputStream("src/test/resources/petriNets/dynamic_validations.xml"), VersionType.MAJOR, superCreator.getLoggedSuper()) -// Case useCase = importHelper.createCase("test", optNet.getNet()) -// Map data = getData(useCase) -// assert (data["number"]).validations[0] instanceof DynamicValidation -// assert (data["number"]).validations[0].compiledRule == ("inrange ${useCase.dataSet["min"].value as Integer},${useCase.dataSet["max"].value as Integer}" as String) -// assert (data["number"]).validations[0].validationMessage.defaultValue == "Number field validation message" -// -// assert (data["text"]).validations[0] instanceof DynamicValidation -// assert (data["text"]).validations[0].compiledRule == ("maxLength ${useCase.dataSet["max"].value as Integer}" as String) -// -// assert (data["date"]).validations[0] instanceof DynamicValidation -// assert (data["date"]).validations[0].compiledRule == ("between past,today-P${useCase.dataSet["max"].value as Integer}D" as String) -// -// SetDataEventOutcome changes = setData(useCase, ["number_valid_switch": ["type": "boolean", "value": true], -// "text_valid_switch" : ["type": "boolean", "value": true]]) -// assert (changes.changedFields["number"].attributes["validations"] as List)[0]["validationRule"] == "odd" -// assert (changes.changedFields["text"].attributes["validations"] as List)[0]["validationRule"] == "email" -// -// useCase = workflowService.findOne(useCase.stringId) -// assert useCase.dataSet["number"].validations[0].validationRule == "odd" -// assert useCase.dataSet["text"].validations[0].validationRule == "email" -// -// data = getData(useCase) -// assert !((data["number"]).validations[0] instanceof DynamicValidation) -// assert (data["number"]).validations[0].validationRule == "odd" -// -// assert !((data["text"]).validations[0] instanceof DynamicValidation) -// assert (data["text"]).validations[0].validationRule == "email" -// -// changes = setData(useCase, ["number_valid_switch": ["type": "boolean", "value": false], -// "text_valid_switch" : ["type": "boolean", "value": false]]) -// assert (changes.changedFields["number"].attributes["validations"] as List)[0]["validationRule"] == ("inrange ${useCase.dataSet["min"].value as Integer},${useCase.dataSet["max"].value as Integer}" as String) -// assert (changes.changedFields["text"].attributes["validations"] as List)[0]["validationRule"] == ("maxLength ${useCase.dataSet["max"].value as Integer}" as String) -// -// setData(useCase, ["min": ["type": "number", "value": "10"], -// "max": ["type": "number", "value": "20"]]) -// -// useCase = workflowService.findOne(useCase.stringId) -// data = getData(useCase) -// assert data["number"].validations[0].compiledRule == ("inrange 10,20" as String) -// assert data["text"].validations[0].compiledRule == ("maxLength 20" as String) -// -// assert useCase.dataSet["number"].validations[0].validationRule == '''inrange ${min.value as Integer},${max.value as Integer}''' -// assert useCase.dataSet["text"].validations[0].validationRule == '''maxLength ${max.value as Integer}''' -// -// assert (useCase.dataSet["number"].validations[0] as DynamicValidation).expression.definition == '''"inrange ${min.value as Integer},${max.value as Integer}"''' -// assert (useCase.dataSet["text"].validations[0] as DynamicValidation).expression.definition == '''"maxLength ${max.value as Integer}"''' -// -// } -// -// Map getData(Case useCase) { -// Task task = task(useCase) -// return dataService.getData(task, useCase).getData().collectEntries { [(it.importId): (it)] } -// } -// -// SetDataEventOutcome setData(Case useCase, Map> values) { -// Task task = task(useCase) -// return dataService.setData(task, ImportHelper.populateDataset(values)) -// } -// -// Task task(Case useCase) { -// return taskService.findOne(useCase.tasks.find { it.transitionId == "transition" }.taskId) -// } -} diff --git a/src/test/groovy/com/netgrif/application/engine/validation/ValidationTestDynamic.groovy b/src/test/groovy/com/netgrif/application/engine/validation/ValidationTestDynamic.groovy index 40d1c5506a4..c6301ec9769 100644 --- a/src/test/groovy/com/netgrif/application/engine/validation/ValidationTestDynamic.groovy +++ b/src/test/groovy/com/netgrif/application/engine/validation/ValidationTestDynamic.groovy @@ -29,7 +29,6 @@ import org.springframework.test.context.junit.jupiter.SpringExtension class ValidationTestDynamic { public static final String VALIDATION_PETRI_NET_IDENTIFIER = "validation" - public static final String VALIDATION_ACTIVE_FIELD_ID = "active" @Autowired private ImportHelper importHelper @@ -88,7 +87,7 @@ class ValidationTestDynamic { } validationCase = workflowService.findOne(validationCase.stringId) - assert validationCase.dataSet.get(VALIDATION_ACTIVE_FIELD_ID).rawValue == active + assert validationCase.tasks.get("deactivate") != null return validationCase } diff --git a/src/test/resources/petriNets/dynamic_validations.xml b/src/test/resources/petriNets/dynamic_validations.xml deleted file mode 100644 index 892960bfa6c..00000000000 --- a/src/test/resources/petriNets/dynamic_validations.xml +++ /dev/null @@ -1,132 +0,0 @@ - - dynamic_validations - dynamic_validations - true - DVT - - - min - Min - - - max - Max - 5 - - - number - Number - - - inrange ${min.value as Integer},${max.value as Integer} - Number field validation message - - - - - text - Text - - - maxLength ${max.value as Integer} - Text field validation message - - - - - date - Date - - - between past,today-P${max.value as Integer}D - Date field validation message - - - - - - number_valid_switch - Switch - - - number_valid_switch: f.number_valid_switch, - number: f.number; - - if (number_valid_switch.value) { - change number validations { "odd" } - } else { - change number validations { dynamicValidation('''inrange ${min.value as Integer},${max.value as Integer}''', - null) } - } - - - - - text_valid_switch - Switch - - - text_valid_switch: f.text_valid_switch, - text: f.text; - - if (text_valid_switch.value) { - change text validations { "email" } - } else { - change text validations { dynamicValidation('''maxLength ${max.value as Integer}''', null) } - } - - - - - transition - 200 - 200 - - auto - - - min - - editable - - - - max - - editable - - - - number - - editable - - - - text - - editable - - - - date - - editable - - - - number_valid_switch - - editable - - - - text_valid_switch - - editable - - - - - \ No newline at end of file diff --git a/src/test/resources/petriNets/dynamic_validations_performance_test.xml b/src/test/resources/petriNets/dynamic_validations_performance_test.xml deleted file mode 100644 index b6fa31f6112..00000000000 --- a/src/test/resources/petriNets/dynamic_validations_performance_test.xml +++ /dev/null @@ -1,3306 +0,0 @@ - - dynamic_validations_performance - dynamic_validations_performance - true - DVT - - - min - Min - - - max - Max - 5 - - - number - Number - - - inrange ${min.value as Integer},${max.value as Integer} - Number field validation message - - - - - text - Text - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_01 - Text 01 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_02 - Text 02 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_03 - Text 03 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_04 - Text 04 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_05 - Text 05 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_06 - Text 06 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_07 - Text 07 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_08 - Text 08 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_09 - Text 09 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_10 - Text 10 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_11 - Text 11 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_12 - Text 12 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_13 - Text 13 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_14 - Text 14 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_15 - Text 15 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_16 - Text 16 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_17 - Text 17 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_18 - Text 18 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_19 - Text 19 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_20 - Text 20 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_21 - Text 21 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_22 - Text 22 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_23 - Text 23 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_24 - Text 24 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_25 - Text 25 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_26 - Text 26 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_27 - Text 27 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_28 - Text 28 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_29 - Text 29 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_30 - Text 30 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_31 - Text 31 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_32 - Text 32 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_33 - Text 33 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_34 - Text 34 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_35 - Text 35 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_36 - Text 36 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_37 - Text 37 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_38 - Text 38 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_39 - Text 39 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_40 - Text 40 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_41 - Text 41 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_42 - Text 42 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_43 - Text 43 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_44 - Text 44 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_45 - Text 45 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_46 - Text 46 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_47 - Text 47 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_48 - Text 48 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_49 - Text 49 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_50 - Text 50 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_51 - Text 51 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_52 - Text 52 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_53 - Text 53 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_54 - Text 54 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_55 - Text 55 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_56 - Text 56 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_57 - Text 57 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_58 - Text 58 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_59 - Text 59 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_60 - Text 60 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_61 - Text 61 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_62 - Text 62 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_63 - Text 63 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_64 - Text 64 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_65 - Text 65 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_66 - Text 66 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_67 - Text 67 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_68 - Text 68 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_69 - Text 69 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_70 - Text 70 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_71 - Text 71 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_72 - Text 72 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_73 - Text 73 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_74 - Text 74 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_75 - Text 75 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_76 - Text 76 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_77 - Text 77 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_78 - Text 78 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_79 - Text 79 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_80 - Text 80 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_81 - Text 81 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_82 - Text 82 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_83 - Text 83 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_84 - Text 84 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_85 - Text 85 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_86 - Text 86 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_87 - Text 87 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_88 - Text 88 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_89 - Text 89 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_90 - Text 90 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_91 - Text 91 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_92 - Text 92 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_93 - Text 93 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_94 - Text 94 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_95 - Text 95 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_96 - Text 96 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_97 - Text 97 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_98 - Text 98 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - text_99 - Text 99 - - - maxLength ${max.value as Integer} - Text field validation message - - - - - number_01 - Text 01 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_02 - Text 02 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_03 - Text 03 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_04 - Text 04 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_05 - Text 05 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_06 - Text 06 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_07 - Text 07 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_08 - Text 08 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_09 - Text 09 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_10 - Text 10 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_11 - Text 11 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_12 - Text 12 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_13 - Text 13 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_14 - Text 14 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_15 - Text 15 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_16 - Text 16 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_17 - Text 17 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_18 - Text 18 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_19 - Text 19 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_20 - Text 20 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_21 - Text 21 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_22 - Text 22 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_23 - Text 23 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_24 - Text 24 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_25 - Text 25 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_26 - Text 26 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_27 - Text 27 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_28 - Text 28 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_29 - Text 29 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_30 - Text 30 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_31 - Text 31 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_32 - Text 32 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_33 - Text 33 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_34 - Text 34 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_35 - Text 35 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_36 - Text 36 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_37 - Text 37 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_38 - Text 38 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_39 - Text 39 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_40 - Text 40 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_41 - Text 41 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_42 - Text 42 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_43 - Text 43 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_44 - Text 44 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_45 - Text 45 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_46 - Text 46 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_47 - Text 47 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_48 - Text 48 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_49 - Text 49 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_50 - Text 50 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_51 - Text 51 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_52 - Text 52 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_53 - Text 53 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_54 - Text 54 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_55 - Text 55 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_56 - Text 56 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_57 - Text 57 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_58 - Text 58 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_59 - Text 59 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_60 - Text 60 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_61 - Text 61 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_62 - Text 62 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_63 - Text 63 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_64 - Text 64 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_65 - Text 65 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_66 - Text 66 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_67 - Text 67 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_68 - Text 68 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_69 - Text 69 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_70 - Text 70 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_71 - Text 71 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_72 - Text 72 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_73 - Text 73 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_74 - Text 74 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_75 - Text 75 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_76 - Text 76 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_77 - Text 77 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_78 - Text 78 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_79 - Text 79 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_80 - Text 80 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_81 - Text 81 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_82 - Text 82 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_83 - Text 83 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_84 - Text 84 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_85 - Text 85 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_86 - Text 86 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_87 - Text 87 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_88 - Text 88 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_89 - Text 89 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_90 - Text 90 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_91 - Text 91 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_92 - Text 92 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_93 - Text 93 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_94 - Text 94 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_95 - Text 95 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_96 - Text 96 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_97 - Text 97 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_98 - Text 98 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - number_99 - Text 99 - - - inrange 0,${max.value as Integer} - Text field validation message - - - - - - date - Date - - - between past,today-P${max.value as Integer}D - Date field validation message - - - - - - number_valid_switch - Switch - - - number_valid_switch: f.number_valid_switch, - number: f.number; - - if (number_valid_switch.value) { - change number validations { "odd" } - } else { - change number validations { new - com.netgrif.application.engine.petrinet.domain.dataset.Validation('''inrange - ${min.value as Integer},${max.value as Integer}''', true) } - } - - - - - text_valid_switch - Switch - - - text_valid_switch: f.text_valid_switch, - text: f.text; - - if (text_valid_switch.value) { - change text validations { "email" } - } else { - change text validations { - new com.netgrif.application.engine.petrinet.domain.dataset.Validation( - '''log.info("running");maxLength ${max.value as Integer}''', - new com.netgrif.application.engine.petrinet.domain.I18nString("")) - } - } - - - - - transition - 200 - 200 - - auto - - - min - - editable - - - - max - - editable - - - - number - - editable - - - - text - - editable - - - - date - - editable - - - - number_valid_switch - - editable - - - - text_valid_switch - - editable - - - - text_01 - - editable - - - - text_02 - - editable - - - - text_03 - - editable - - - - text_04 - - editable - - - - text_05 - - editable - - - - text_06 - - editable - - - - text_07 - - editable - - - - text_08 - - editable - - - - text_09 - - editable - - - - text_10 - - editable - - - - text_11 - - editable - - - - text_12 - - editable - - - - text_13 - - editable - - - - text_14 - - editable - - - - text_15 - - editable - - - - text_16 - - editable - - - - text_17 - - editable - - - - text_18 - - editable - - - - text_19 - - editable - - - - text_20 - - editable - - - - text_21 - - editable - - - - text_22 - - editable - - - - text_23 - - editable - - - - text_24 - - editable - - - - text_25 - - editable - - - - text_26 - - editable - - - - text_27 - - editable - - - - text_28 - - editable - - - - text_29 - - editable - - - - text_30 - - editable - - - - text_31 - - editable - - - - text_32 - - editable - - - - text_33 - - editable - - - - text_34 - - editable - - - - text_35 - - editable - - - - text_36 - - editable - - - - text_37 - - editable - - - - text_38 - - editable - - - - text_39 - - editable - - - - text_40 - - editable - - - - text_41 - - editable - - - - text_42 - - editable - - - - text_43 - - editable - - - - text_44 - - editable - - - - text_45 - - editable - - - - text_46 - - editable - - - - text_47 - - editable - - - - text_48 - - editable - - - - text_49 - - editable - - - - text_50 - - editable - - - - text_51 - - editable - - - - text_52 - - editable - - - - text_53 - - editable - - - - text_54 - - editable - - - - text_55 - - editable - - - - text_56 - - editable - - - - text_57 - - editable - - - - text_58 - - editable - - - - text_59 - - editable - - - - text_60 - - editable - - - - text_61 - - editable - - - - text_62 - - editable - - - - text_63 - - editable - - - - text_64 - - editable - - - - text_65 - - editable - - - - text_66 - - editable - - - - text_67 - - editable - - - - text_68 - - editable - - - - text_69 - - editable - - - - text_70 - - editable - - - - text_71 - - editable - - - - text_72 - - editable - - - - text_73 - - editable - - - - text_74 - - editable - - - - text_75 - - editable - - - - text_76 - - editable - - - - text_77 - - editable - - - - text_78 - - editable - - - - text_79 - - editable - - - - text_80 - - editable - - - - text_81 - - editable - - - - text_82 - - editable - - - - text_83 - - editable - - - - text_84 - - editable - - - - text_85 - - editable - - - - text_86 - - editable - - - - text_87 - - editable - - - - text_88 - - editable - - - - text_89 - - editable - - - - text_90 - - editable - - - - text_91 - - editable - - - - text_92 - - editable - - - - text_93 - - editable - - - - text_94 - - editable - - - - text_95 - - editable - - - - text_96 - - editable - - - - text_97 - - editable - - - - text_98 - - editable - - - - text_99 - - editable - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file diff --git a/src/test/resources/petriNets/dynamic_validations_performance_test_comparison.xml b/src/test/resources/petriNets/dynamic_validations_performance_test_comparison.xml deleted file mode 100644 index 9b1684aed87..00000000000 --- a/src/test/resources/petriNets/dynamic_validations_performance_test_comparison.xml +++ /dev/null @@ -1,3278 +0,0 @@ - - dynamic_validations_performance_comparison - dynamic_validations_performance_comparison - true - DVT - - - min - Min - - - max - Max - 5 - - - number - Number - - - inrange 0,10 - Number field validation message - - - - - text - Text - - - maxLength 10 - Text field validation message - - - - - text_01 - Text 01 - - - maxLength 10 - Text field validation message - - - - - text_02 - Text 02 - - - maxLength 10 - Text field validation message - - - - - text_03 - Text 03 - - - maxLength 10 - Text field validation message - - - - - text_04 - Text 04 - - - maxLength 10 - Text field validation message - - - - - text_05 - Text 05 - - - maxLength 10 - Text field validation message - - - - - text_06 - Text 06 - - - maxLength 10 - Text field validation message - - - - - text_07 - Text 07 - - - maxLength 10 - Text field validation message - - - - - text_08 - Text 08 - - - maxLength 10 - Text field validation message - - - - - text_09 - Text 09 - - - maxLength 10 - Text field validation message - - - - - text_10 - Text 10 - - - maxLength 10 - Text field validation message - - - - - text_11 - Text 11 - - - maxLength 10 - Text field validation message - - - - - text_12 - Text 12 - - - maxLength 10 - Text field validation message - - - - - text_13 - Text 13 - - - maxLength 10 - Text field validation message - - - - - text_14 - Text 14 - - - maxLength 10 - Text field validation message - - - - - text_15 - Text 15 - - - maxLength 10 - Text field validation message - - - - - text_16 - Text 16 - - - maxLength 10 - Text field validation message - - - - - text_17 - Text 17 - - - maxLength 10 - Text field validation message - - - - - text_18 - Text 18 - - - maxLength 10 - Text field validation message - - - - - text_19 - Text 19 - - - maxLength 10 - Text field validation message - - - - - text_20 - Text 20 - - - maxLength 10 - Text field validation message - - - - - text_21 - Text 21 - - - maxLength 10 - Text field validation message - - - - - text_22 - Text 22 - - - maxLength 10 - Text field validation message - - - - - text_23 - Text 23 - - - maxLength 10 - Text field validation message - - - - - text_24 - Text 24 - - - maxLength 10 - Text field validation message - - - - - text_25 - Text 25 - - - maxLength 10 - Text field validation message - - - - - text_26 - Text 26 - - - maxLength 10 - Text field validation message - - - - - text_27 - Text 27 - - - maxLength 10 - Text field validation message - - - - - text_28 - Text 28 - - - maxLength 10 - Text field validation message - - - - - text_29 - Text 29 - - - maxLength 10 - Text field validation message - - - - - text_30 - Text 30 - - - maxLength 10 - Text field validation message - - - - - text_31 - Text 31 - - - maxLength 10 - Text field validation message - - - - - text_32 - Text 32 - - - maxLength 10 - Text field validation message - - - - - text_33 - Text 33 - - - maxLength 10 - Text field validation message - - - - - text_34 - Text 34 - - - maxLength 10 - Text field validation message - - - - - text_35 - Text 35 - - - maxLength 10 - Text field validation message - - - - - text_36 - Text 36 - - - maxLength 10 - Text field validation message - - - - - text_37 - Text 37 - - - maxLength 10 - Text field validation message - - - - - text_38 - Text 38 - - - maxLength 10 - Text field validation message - - - - - text_39 - Text 39 - - - maxLength 10 - Text field validation message - - - - - text_40 - Text 40 - - - maxLength 10 - Text field validation message - - - - - text_41 - Text 41 - - - maxLength 10 - Text field validation message - - - - - text_42 - Text 42 - - - maxLength 10 - Text field validation message - - - - - text_43 - Text 43 - - - maxLength 10 - Text field validation message - - - - - text_44 - Text 44 - - - maxLength 10 - Text field validation message - - - - - text_45 - Text 45 - - - maxLength 10 - Text field validation message - - - - - text_46 - Text 46 - - - maxLength 10 - Text field validation message - - - - - text_47 - Text 47 - - - maxLength 10 - Text field validation message - - - - - text_48 - Text 48 - - - maxLength 10 - Text field validation message - - - - - text_49 - Text 49 - - - maxLength 10 - Text field validation message - - - - - text_50 - Text 50 - - - maxLength 10 - Text field validation message - - - - - text_51 - Text 51 - - - maxLength 10 - Text field validation message - - - - - text_52 - Text 52 - - - maxLength 10 - Text field validation message - - - - - text_53 - Text 53 - - - maxLength 10 - Text field validation message - - - - - text_54 - Text 54 - - - maxLength 10 - Text field validation message - - - - - text_55 - Text 55 - - - maxLength 10 - Text field validation message - - - - - text_56 - Text 56 - - - maxLength 10 - Text field validation message - - - - - text_57 - Text 57 - - - maxLength 10 - Text field validation message - - - - - text_58 - Text 58 - - - maxLength 10 - Text field validation message - - - - - text_59 - Text 59 - - - maxLength 10 - Text field validation message - - - - - text_60 - Text 60 - - - maxLength 10 - Text field validation message - - - - - text_61 - Text 61 - - - maxLength 10 - Text field validation message - - - - - text_62 - Text 62 - - - maxLength 10 - Text field validation message - - - - - text_63 - Text 63 - - - maxLength 10 - Text field validation message - - - - - text_64 - Text 64 - - - maxLength 10 - Text field validation message - - - - - text_65 - Text 65 - - - maxLength 10 - Text field validation message - - - - - text_66 - Text 66 - - - maxLength 10 - Text field validation message - - - - - text_67 - Text 67 - - - maxLength 10 - Text field validation message - - - - - text_68 - Text 68 - - - maxLength 10 - Text field validation message - - - - - text_69 - Text 69 - - - maxLength 10 - Text field validation message - - - - - text_70 - Text 70 - - - maxLength 10 - Text field validation message - - - - - text_71 - Text 71 - - - maxLength 10 - Text field validation message - - - - - text_72 - Text 72 - - - maxLength 10 - Text field validation message - - - - - text_73 - Text 73 - - - maxLength 10 - Text field validation message - - - - - text_74 - Text 74 - - - maxLength 10 - Text field validation message - - - - - text_75 - Text 75 - - - maxLength 10 - Text field validation message - - - - - text_76 - Text 76 - - - maxLength 10 - Text field validation message - - - - - text_77 - Text 77 - - - maxLength 10 - Text field validation message - - - - - text_78 - Text 78 - - - maxLength 10 - Text field validation message - - - - - text_79 - Text 79 - - - maxLength 10 - Text field validation message - - - - - text_80 - Text 80 - - - maxLength 10 - Text field validation message - - - - - text_81 - Text 81 - - - maxLength 10 - Text field validation message - - - - - text_82 - Text 82 - - - maxLength 10 - Text field validation message - - - - - text_83 - Text 83 - - - maxLength 10 - Text field validation message - - - - - text_84 - Text 84 - - - maxLength 10 - Text field validation message - - - - - text_85 - Text 85 - - - maxLength 10 - Text field validation message - - - - - text_86 - Text 86 - - - maxLength 10 - Text field validation message - - - - - text_87 - Text 87 - - - maxLength 10 - Text field validation message - - - - - text_88 - Text 88 - - - maxLength 10 - Text field validation message - - - - - text_89 - Text 89 - - - maxLength 10 - Text field validation message - - - - - text_90 - Text 90 - - - maxLength 10 - Text field validation message - - - - - text_91 - Text 91 - - - maxLength 10 - Text field validation message - - - - - text_92 - Text 92 - - - maxLength 10 - Text field validation message - - - - - text_93 - Text 93 - - - maxLength 10 - Text field validation message - - - - - text_94 - Text 94 - - - maxLength 10 - Text field validation message - - - - - text_95 - Text 95 - - - maxLength 10 - Text field validation message - - - - - text_96 - Text 96 - - - maxLength 10 - Text field validation message - - - - - text_97 - Text 97 - - - maxLength 10 - Text field validation message - - - - - text_98 - Text 98 - - - maxLength 10 - Text field validation message - - - - - text_99 - Text 99 - - - maxLength 10 - Text field validation message - - - - - number_01 - Text 01 - - - inrange 0,5 - Text field validation message - - - - - number_02 - Text 02 - - - inrange 0,5 - Text field validation message - - - - - number_03 - Text 03 - - - inrange 0,5 - Text field validation message - - - - - number_04 - Text 04 - - - inrange 0,5 - Text field validation message - - - - - number_05 - Text 05 - - - inrange 0,5 - Text field validation message - - - - - number_06 - Text 06 - - - inrange 0,5 - Text field validation message - - - - - number_07 - Text 07 - - - inrange 0,5 - Text field validation message - - - - - number_08 - Text 08 - - - inrange 0,5 - Text field validation message - - - - - number_09 - Text 09 - - - inrange 0,5 - Text field validation message - - - - - number_10 - Text 10 - - - inrange 0,5 - Text field validation message - - - - - number_11 - Text 11 - - - inrange 0,5 - Text field validation message - - - - - number_12 - Text 12 - - - inrange 0,5 - Text field validation message - - - - - number_13 - Text 13 - - - inrange 0,5 - Text field validation message - - - - - number_14 - Text 14 - - - inrange 0,5 - Text field validation message - - - - - number_15 - Text 15 - - - inrange 0,5 - Text field validation message - - - - - number_16 - Text 16 - - - inrange 0,5 - Text field validation message - - - - - number_17 - Text 17 - - - inrange 0,5 - Text field validation message - - - - - number_18 - Text 18 - - - inrange 0,5 - Text field validation message - - - - - number_19 - Text 19 - - - inrange 0,5 - Text field validation message - - - - - number_20 - Text 20 - - - inrange 0,5 - Text field validation message - - - - - number_21 - Text 21 - - - inrange 0,5 - Text field validation message - - - - - number_22 - Text 22 - - - inrange 0,5 - Text field validation message - - - - - number_23 - Text 23 - - - inrange 0,5 - Text field validation message - - - - - number_24 - Text 24 - - - inrange 0,5 - Text field validation message - - - - - number_25 - Text 25 - - - inrange 0,5 - Text field validation message - - - - - number_26 - Text 26 - - - inrange 0,5 - Text field validation message - - - - - number_27 - Text 27 - - - inrange 0,5 - Text field validation message - - - - - number_28 - Text 28 - - - inrange 0,5 - Text field validation message - - - - - number_29 - Text 29 - - - inrange 0,5 - Text field validation message - - - - - number_30 - Text 30 - - - inrange 0,5 - Text field validation message - - - - - number_31 - Text 31 - - - inrange 0,5 - Text field validation message - - - - - number_32 - Text 32 - - - inrange 0,5 - Text field validation message - - - - - number_33 - Text 33 - - - inrange 0,5 - Text field validation message - - - - - number_34 - Text 34 - - - inrange 0,5 - Text field validation message - - - - - number_35 - Text 35 - - - inrange 0,5 - Text field validation message - - - - - number_36 - Text 36 - - - inrange 0,5 - Text field validation message - - - - - number_37 - Text 37 - - - inrange 0,5 - Text field validation message - - - - - number_38 - Text 38 - - - inrange 0,5 - Text field validation message - - - - - number_39 - Text 39 - - - inrange 0,5 - Text field validation message - - - - - number_40 - Text 40 - - - inrange 0,5 - Text field validation message - - - - - number_41 - Text 41 - - - inrange 0,5 - Text field validation message - - - - - number_42 - Text 42 - - - inrange 0,5 - Text field validation message - - - - - number_43 - Text 43 - - - inrange 0,5 - Text field validation message - - - - - number_44 - Text 44 - - - inrange 0,5 - Text field validation message - - - - - number_45 - Text 45 - - - inrange 0,5 - Text field validation message - - - - - number_46 - Text 46 - - - inrange 0,5 - Text field validation message - - - - - number_47 - Text 47 - - - inrange 0,5 - Text field validation message - - - - - number_48 - Text 48 - - - inrange 0,5 - Text field validation message - - - - - number_49 - Text 49 - - - inrange 0,5 - Text field validation message - - - - - number_50 - Text 50 - - - inrange 0,5 - Text field validation message - - - - - number_51 - Text 51 - - - inrange 0,5 - Text field validation message - - - - - number_52 - Text 52 - - - inrange 0,5 - Text field validation message - - - - - number_53 - Text 53 - - - inrange 0,5 - Text field validation message - - - - - number_54 - Text 54 - - - inrange 0,5 - Text field validation message - - - - - number_55 - Text 55 - - - inrange 0,5 - Text field validation message - - - - - number_56 - Text 56 - - - inrange 0,5 - Text field validation message - - - - - number_57 - Text 57 - - - inrange 0,5 - Text field validation message - - - - - number_58 - Text 58 - - - inrange 0,5 - Text field validation message - - - - - number_59 - Text 59 - - - inrange 0,5 - Text field validation message - - - - - number_60 - Text 60 - - - inrange 0,5 - Text field validation message - - - - - number_61 - Text 61 - - - inrange 0,5 - Text field validation message - - - - - number_62 - Text 62 - - - inrange 0,5 - Text field validation message - - - - - number_63 - Text 63 - - - inrange 0,5 - Text field validation message - - - - - number_64 - Text 64 - - - inrange 0,5 - Text field validation message - - - - - number_65 - Text 65 - - - inrange 0,5 - Text field validation message - - - - - number_66 - Text 66 - - - inrange 0,5 - Text field validation message - - - - - number_67 - Text 67 - - - inrange 0,5 - Text field validation message - - - - - number_68 - Text 68 - - - inrange 0,5 - Text field validation message - - - - - number_69 - Text 69 - - - inrange 0,5 - Text field validation message - - - - - number_70 - Text 70 - - - inrange 0,5 - Text field validation message - - - - - number_71 - Text 71 - - - inrange 0,5 - Text field validation message - - - - - number_72 - Text 72 - - - inrange 0,5 - Text field validation message - - - - - number_73 - Text 73 - - - inrange 0,5 - Text field validation message - - - - - number_74 - Text 74 - - - inrange 0,5 - Text field validation message - - - - - number_75 - Text 75 - - - inrange 0,5 - Text field validation message - - - - - number_76 - Text 76 - - - inrange 0,5 - Text field validation message - - - - - number_77 - Text 77 - - - inrange 0,5 - Text field validation message - - - - - number_78 - Text 78 - - - inrange 0,5 - Text field validation message - - - - - number_79 - Text 79 - - - inrange 0,5 - Text field validation message - - - - - number_80 - Text 80 - - - inrange 0,5 - Text field validation message - - - - - number_81 - Text 81 - - - inrange 0,5 - Text field validation message - - - - - number_82 - Text 82 - - - inrange 0,5 - Text field validation message - - - - - number_83 - Text 83 - - - inrange 0,5 - Text field validation message - - - - - number_84 - Text 84 - - - inrange 0,5 - Text field validation message - - - - - number_85 - Text 85 - - - inrange 0,5 - Text field validation message - - - - - number_86 - Text 86 - - - inrange 0,5 - Text field validation message - - - - - number_87 - Text 87 - - - inrange 0,5 - Text field validation message - - - - - number_88 - Text 88 - - - inrange 0,5 - Text field validation message - - - - - number_89 - Text 89 - - - inrange 0,5 - Text field validation message - - - - - number_90 - Text 90 - - - inrange 0,5 - Text field validation message - - - - - number_91 - Text 91 - - - inrange 0,5 - Text field validation message - - - - - number_92 - Text 92 - - - inrange 0,5 - Text field validation message - - - - - number_93 - Text 93 - - - inrange 0,5 - Text field validation message - - - - - number_94 - Text 94 - - - inrange 0,5 - Text field validation message - - - - - number_95 - Text 95 - - - inrange 0,5 - Text field validation message - - - - - number_96 - Text 96 - - - inrange 0,5 - Text field validation message - - - - - number_97 - Text 97 - - - inrange 0,5 - Text field validation message - - - - - number_98 - Text 98 - - - inrange 0,5 - Text field validation message - - - - - number_99 - Text 99 - - - inrange 0,5 - Text field validation message - - - - - - date - Date - - - between past,today-P1D - Date field validation message - - - - - - number_valid_switch - Switch - - - - text_valid_switch - Switch - - - - transition - 200 - 200 - - auto - - - min - - editable - - - - max - - editable - - - - number - - editable - - - - text - - editable - - - - date - - editable - - - - number_valid_switch - - editable - - - - text_valid_switch - - editable - - - - text_01 - - editable - - - - text_02 - - editable - - - - text_03 - - editable - - - - text_04 - - editable - - - - text_05 - - editable - - - - text_06 - - editable - - - - text_07 - - editable - - - - text_08 - - editable - - - - text_09 - - editable - - - - text_10 - - editable - - - - text_11 - - editable - - - - text_12 - - editable - - - - text_13 - - editable - - - - text_14 - - editable - - - - text_15 - - editable - - - - text_16 - - editable - - - - text_17 - - editable - - - - text_18 - - editable - - - - text_19 - - editable - - - - text_20 - - editable - - - - text_21 - - editable - - - - text_22 - - editable - - - - text_23 - - editable - - - - text_24 - - editable - - - - text_25 - - editable - - - - text_26 - - editable - - - - text_27 - - editable - - - - text_28 - - editable - - - - text_29 - - editable - - - - text_30 - - editable - - - - text_31 - - editable - - - - text_32 - - editable - - - - text_33 - - editable - - - - text_34 - - editable - - - - text_35 - - editable - - - - text_36 - - editable - - - - text_37 - - editable - - - - text_38 - - editable - - - - text_39 - - editable - - - - text_40 - - editable - - - - text_41 - - editable - - - - text_42 - - editable - - - - text_43 - - editable - - - - text_44 - - editable - - - - text_45 - - editable - - - - text_46 - - editable - - - - text_47 - - editable - - - - text_48 - - editable - - - - text_49 - - editable - - - - text_50 - - editable - - - - text_51 - - editable - - - - text_52 - - editable - - - - text_53 - - editable - - - - text_54 - - editable - - - - text_55 - - editable - - - - text_56 - - editable - - - - text_57 - - editable - - - - text_58 - - editable - - - - text_59 - - editable - - - - text_60 - - editable - - - - text_61 - - editable - - - - text_62 - - editable - - - - text_63 - - editable - - - - text_64 - - editable - - - - text_65 - - editable - - - - text_66 - - editable - - - - text_67 - - editable - - - - text_68 - - editable - - - - text_69 - - editable - - - - text_70 - - editable - - - - text_71 - - editable - - - - text_72 - - editable - - - - text_73 - - editable - - - - text_74 - - editable - - - - text_75 - - editable - - - - text_76 - - editable - - - - text_77 - - editable - - - - text_78 - - editable - - - - text_79 - - editable - - - - text_80 - - editable - - - - text_81 - - editable - - - - text_82 - - editable - - - - text_83 - - editable - - - - text_84 - - editable - - - - text_85 - - editable - - - - text_86 - - editable - - - - text_87 - - editable - - - - text_88 - - editable - - - - text_89 - - editable - - - - text_90 - - editable - - - - text_91 - - editable - - - - text_92 - - editable - - - - text_93 - - editable - - - - text_94 - - editable - - - - text_95 - - editable - - - - text_96 - - editable - - - - text_97 - - editable - - - - text_98 - - editable - - - - text_99 - - editable - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - \ No newline at end of file From 47f762a0471c5f9be957039fac167cba12690ad9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Martin=20=C5=A0ir=C3=A1=C5=88?= Date: Fri, 26 Jul 2024 18:10:57 +0200 Subject: [PATCH 11/12] [NAE-1788] Validation register backend - refactor ValidationExecutioner - fix ValidationRunner predicate - add null check to ValidationService - update validation process - fields behavior, validation type field - add more validation tests --- .../logic/action/ValidationExecutioner.groovy | 26 +-- .../engine/startup/ValidationRunner.groovy | 3 +- .../engine/validations/ValidationService.java | 3 + .../validations/validation.xml | 71 ++++++--- .../validation/ValidationTestDynamic.groovy | 148 +++++++++++++++++- 5 files changed, 218 insertions(+), 33 deletions(-) diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy index dae3e620ce6..5b7f5e7cd9f 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationExecutioner.groovy @@ -31,11 +31,19 @@ abstract class ValidationExecutioner { log.info("Validations: ${validations.collect { it.name }}") ValidationDelegate delegate = initDelegate(useCase, field, validations.collect { it.name }) - for (Validation validation : validations) { - Closure code = initCode(validation, delegate) - if (!code()) { - throw new IllegalArgumentException(validation.message.toString()) - } + validations.each { validation -> + runValidation(field, validation, delegate) + } + } + + protected void runValidation(Field field, Validation validation, ValidationDelegate delegate) { + if (field.rawValue == null) { + return + } + + Closure code = initCode(validation, delegate) + if (!code()) { + throw new IllegalArgumentException(validation.message.toString()) } } @@ -65,9 +73,8 @@ abstract class ValidationExecutioner { delegate.metaClass."$field.importId" = field } - List fieldNames = useCase.dataSet.fields.keySet() as List - validationNames = filterConflictedValidationNames(fieldNames, validationNames) - validationNames.forEach { validationName -> + validationNames = filterConflictedValidationNames(useCase, validationNames) + validationNames.each { validationName -> delegate.metaClass."$validationName" = getValidationCode(validationName) } @@ -75,7 +82,8 @@ abstract class ValidationExecutioner { return delegate } - private List filterConflictedValidationNames(List fieldNames, List validationNames) { + private static List filterConflictedValidationNames(Case useCase, List validationNames) { + List fieldNames = useCase.dataSet.fields.keySet() as List fieldNames.retainAll(validationNames) if (!fieldNames.isEmpty()) { log.warn("Ignoring validations {} for case [{}]: field names are identical with validation names", fieldNames, useCase.stringId) diff --git a/src/main/groovy/com/netgrif/application/engine/startup/ValidationRunner.groovy b/src/main/groovy/com/netgrif/application/engine/startup/ValidationRunner.groovy index 6270f0c9761..be1f8fbcfc8 100644 --- a/src/main/groovy/com/netgrif/application/engine/startup/ValidationRunner.groovy +++ b/src/main/groovy/com/netgrif/application/engine/startup/ValidationRunner.groovy @@ -18,6 +18,7 @@ class ValidationRunner extends AbstractOrderedCommandLineRunner { private static final int PAGE_SIZE = 100 public static final String VALIDATION_FILE_NAME = "engine-processes/validations/validation.xml" public static final String VALIDATION_PETRI_NET_IDENTIFIER = "validation" + public static final String VALIDATION_ACTIVE_PLACE_ID = "active" public static final String VALIDATION_NAME_FIELD_ID = "name" public static final String VALIDATION_GROOVY_DEFINITION_FIELD_ID = "validation_definition_groovy" @@ -38,7 +39,7 @@ class ValidationRunner extends AbstractOrderedCommandLineRunner { log.info("Starting validation runner") helper.upsertNet(VALIDATION_FILE_NAME, VALIDATION_PETRI_NET_IDENTIFIER) - Predicate predicate = QCase.case$.tasks.get("deactivate").isNotNull() + Predicate predicate = QCase.case$.processIdentifier.eq(VALIDATION_PETRI_NET_IDENTIFIER) & QCase.case$.activePlaces.get(VALIDATION_ACTIVE_PLACE_ID).isNotNull() long numberActiveValidations = caseRepository.count(predicate) int pageCount = (int) (numberActiveValidations / PAGE_SIZE) + 1 pageCount.times { pageNum -> diff --git a/src/main/java/com/netgrif/application/engine/validations/ValidationService.java b/src/main/java/com/netgrif/application/engine/validations/ValidationService.java index 0aa8fe955df..d3a8bb57519 100644 --- a/src/main/java/com/netgrif/application/engine/validations/ValidationService.java +++ b/src/main/java/com/netgrif/application/engine/validations/ValidationService.java @@ -45,6 +45,9 @@ public void validateField(Case useCase, Field field) { @Override public void registerValidation(String name, String definition) throws ClassCastException, CompilationFailedException { + if (definition == null) { + throw new IllegalArgumentException("Definition cannot be empty."); + } Closure code = (Closure) this.shellFactory.getGroovyShell().evaluate("{" + definition + "}"); validationRegistry.addValidation(name, code); } diff --git a/src/main/resources/petriNets/engine-processes/validations/validation.xml b/src/main/resources/petriNets/engine-processes/validations/validation.xml index 75bbf1c69f4..b191682f9b7 100644 --- a/src/main/resources/petriNets/engine-processes/validations/validation.xml +++ b/src/main/resources/petriNets/engine-processes/validations/validation.xml @@ -90,12 +90,12 @@ init_trans: t.init, detail_trans: t.detail; - make [validation_definition_groovy, num_arguments_groovy], editable on init_trans when { validation_type.value && validation_type.value.contains("server") } - make [validation_definition_groovy, num_arguments_groovy], visible on detail_trans when { validation_type.value && validation_type.value.contains("server") } - make [validation_definition_groovy, num_arguments_groovy], hidden on transitions when { validation_type.value && validation_type.value.contains("server") } - make [validation_definition_javascript, num_arguments_javascript], editable on transitions when { validation_type.value && validation_type.value.contains("client") } - make [validation_definition_javascript, num_arguments_javascript], visible on detail_trans when { validation_type.value && validation_type.value.contains("server") } - make [validation_definition_javascript, num_arguments_javascript], hidden on transitions when { validation_type.value && validation_type.value.contains("client") } + make [validation_definition_groovy, num_arguments_groovy], editable on init_trans when { validation_type.rawValue && validation_type.rawValue.contains("server") } + make [validation_definition_groovy, num_arguments_groovy], editable on detail_trans when { validation_type.rawValue && validation_type.rawValue.contains("server") } + make [validation_definition_groovy, num_arguments_groovy], hidden on transitions when { !validation_type.rawValue || !validation_type.rawValue.contains("server") } + make [validation_definition_javascript, num_arguments_javascript], editable on init_trans when { validation_type.rawValue && validation_type.rawValue.contains("client") } + make [validation_definition_javascript, num_arguments_javascript], editable on detail_trans when { validation_type.rawValue && validation_type.rawValue.contains("client") } + make [validation_definition_javascript, num_arguments_javascript], hidden on transitions when { !validation_type.rawValue || !validation_type.rawValue.contains("client") } @@ -269,11 +269,29 @@ name: f.name, - validation_definition_groovy: f.validation_definition_groovy; + validation_definition_groovy: f.validation_definition_groovy, + validation_type: f.validation_type; - validationService.registerValidation(name.rawValue, validation_definition_groovy.rawValue) + if (validation_type.rawValue && validation_type.rawValue.contains("server")) { + validationService.registerValidation(name.rawValue, validation_definition_groovy.rawValue) + } + + + validation_type: f.validation_type, + validation_definition_groovy: f.validation_definition_groovy, + num_arguments_groovy: f.num_arguments_groovy, + validation_definition_javascript: f.validation_definition_javascript, + num_arguments_javascript: f.num_arguments_javascript, + detail_trans: t.detail; + + make [validation_definition_groovy, num_arguments_groovy], visible on detail_trans when { validation_type.rawValue && validation_type.rawValue.contains("server") } + make [validation_definition_groovy, num_arguments_groovy], hidden on detail_trans when { !validation_type.rawValue || !validation_type.rawValue.contains("server") } + make [validation_definition_javascript, num_arguments_javascript], visible on detail_trans when { validation_type.rawValue && validation_type.rawValue.contains("client") } + make [validation_definition_javascript, num_arguments_javascript], hidden on detail_trans when { !validation_type.rawValue || !validation_type.rawValue.contains("client") } + + @@ -294,9 +312,22 @@ onFinish_deactivate - name: f.name; + name: f.name, + validation_type: f.validation_type, + validation_definition_groovy: f.validation_definition_groovy, + num_arguments_groovy: f.num_arguments_groovy, + validation_definition_javascript: f.validation_definition_javascript, + num_arguments_javascript: f.num_arguments_javascript, + detail_trans: t.detail; + + make [validation_definition_groovy, num_arguments_groovy], editable on detail_trans when { validation_type.rawValue && validation_type.rawValue.contains("server") } + make [validation_definition_groovy, num_arguments_groovy], hidden on detail_trans when { !validation_type.rawValue || !validation_type.rawValue.contains("server") } + make [validation_definition_javascript, num_arguments_javascript], editable on detail_trans when { validation_type.rawValue && validation_type.rawValue.contains("client") } + make [validation_definition_javascript, num_arguments_javascript], hidden on detail_trans when { !validation_type.rawValue || !validation_type.rawValue.contains("client") } - validationService.unregisterValidation(name.rawValue) + if (validation_type.rawValue && validation_type.rawValue.contains("server")) { + validationService.unregisterValidation(name.rawValue) + } @@ -431,7 +462,7 @@ false - p2 + inactive 420 300 @@ -439,7 +470,7 @@ false - p3 + active 740 300 @@ -447,7 +478,7 @@ false - p5 + initialized 300 180 @@ -465,13 +496,13 @@ a2 regular init - p5 + initialized 1 a3 read - p5 + initialized detail 1 @@ -479,13 +510,13 @@ a5 regular init - p2 + inactive 1 a6 regular - p2 + inactive activate 1 @@ -493,13 +524,13 @@ a7 regular activate - p3 + active 1 a8 regular - p3 + active deactivate 1 @@ -507,7 +538,7 @@ a9 regular deactivate - p2 + inactive 1 \ No newline at end of file diff --git a/src/test/groovy/com/netgrif/application/engine/validation/ValidationTestDynamic.groovy b/src/test/groovy/com/netgrif/application/engine/validation/ValidationTestDynamic.groovy index c6301ec9769..5bad5dee602 100644 --- a/src/test/groovy/com/netgrif/application/engine/validation/ValidationTestDynamic.groovy +++ b/src/test/groovy/com/netgrif/application/engine/validation/ValidationTestDynamic.groovy @@ -4,6 +4,7 @@ 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.Field +import com.netgrif.application.engine.petrinet.domain.dataset.MultichoiceMapField import com.netgrif.application.engine.petrinet.domain.dataset.TextField import com.netgrif.application.engine.petrinet.service.interfaces.IPetriNetService import com.netgrif.application.engine.startup.ImportHelper @@ -29,6 +30,14 @@ import org.springframework.test.context.junit.jupiter.SpringExtension class ValidationTestDynamic { public static final String VALIDATION_PETRI_NET_IDENTIFIER = "validation" + public static final String VALIDATION_NAME_FIELD_ID = "name" + public static final String VALIDATION_VALIDATION_TYPE_FIELD_ID = "validation_type" + public static final String VALIDATION_DEFINITION_GROOVY_FIELD_ID = "validation_definition_groovy" + public static final String VALIDATION_NUM_ARGUMENTS_GROOVY_FIELD_ID = "num_arguments_groovy" + public static final String VALIDATION_DEFINITION_JAVASCRIPT_FIELD_ID = "validation_definition_javascript" + public static final String VALIDATION_NUM_ARGUMENTS_JAVASCRIPT_FIELD_ID = "num_arguments_javascript" + public static final String VALIDATION_INIT_TRANS_ID = "init" + public static final String VALIDATION_DETAIL_TRANS_ID = "detail" @Autowired private ImportHelper importHelper @@ -70,8 +79,9 @@ class ValidationTestDynamic { assert validationTask != null SetDataEventOutcome outcome = importHelper.setTaskData("Init", validationCase.stringId, new DataSet([ - "name": new TextField(rawValue: name), - "validation_definition_groovy": new TextField(rawValue: validationDefinitionGroovy) + (VALIDATION_NAME_FIELD_ID): new TextField(rawValue: name), + (VALIDATION_VALIDATION_TYPE_FIELD_ID): new MultichoiceMapField(rawValue: ["server"]), + (VALIDATION_DEFINITION_GROOVY_FIELD_ID): new TextField(rawValue: validationDefinitionGroovy) ] as Map>)) assert outcome != null @@ -146,7 +156,7 @@ class ValidationTestDynamic { } @Test - void dynamicValidation_importActive() { + void dynamicValidation_process_importActive() { createValidation("test1", "-> thisField.rawValue = 1", true) createValidation("test2", "-> thisField.rawValue = 2", true) createValidation("test3", "-> thisField.rawValue = 3", false) @@ -167,4 +177,136 @@ class ValidationTestDynamic { assert validationService.getValidation("test2") instanceof Closure && validationService.getValidation("test2") != null assert validationService.getValidation("test3") == null } + + @Test + void dynamicValidation_process_behaviors() { + PetriNet net = petriNetService.getNewestVersionByIdentifier(VALIDATION_PETRI_NET_IDENTIFIER) + + Case validationCase = importHelper.createCase("Validation test", net) + assert validationCase != null + + Task validationTask = importHelper.assignTaskToSuper("Init", validationCase.stringId).getTask() + assert validationTask != null + + assert validationCase.dataSet.get(VALIDATION_DEFINITION_GROOVY_FIELD_ID).behaviors.get(VALIDATION_INIT_TRANS_ID).hidden + assert validationCase.dataSet.get(VALIDATION_NUM_ARGUMENTS_GROOVY_FIELD_ID).behaviors.get(VALIDATION_INIT_TRANS_ID).hidden + assert validationCase.dataSet.get(VALIDATION_DEFINITION_GROOVY_FIELD_ID).behaviors.get(VALIDATION_DETAIL_TRANS_ID).hidden + assert validationCase.dataSet.get(VALIDATION_NUM_ARGUMENTS_GROOVY_FIELD_ID).behaviors.get(VALIDATION_DETAIL_TRANS_ID).hidden + assert validationCase.dataSet.get(VALIDATION_DEFINITION_JAVASCRIPT_FIELD_ID).behaviors.get(VALIDATION_INIT_TRANS_ID).hidden + assert validationCase.dataSet.get(VALIDATION_NUM_ARGUMENTS_JAVASCRIPT_FIELD_ID).behaviors.get(VALIDATION_INIT_TRANS_ID).hidden + assert validationCase.dataSet.get(VALIDATION_DEFINITION_JAVASCRIPT_FIELD_ID).behaviors.get(VALIDATION_DETAIL_TRANS_ID).hidden + assert validationCase.dataSet.get(VALIDATION_NUM_ARGUMENTS_JAVASCRIPT_FIELD_ID).behaviors.get(VALIDATION_DETAIL_TRANS_ID).hidden + + SetDataEventOutcome outcome = importHelper.setTaskData("Init", validationCase.stringId, new DataSet([ + (VALIDATION_VALIDATION_TYPE_FIELD_ID): new MultichoiceMapField(rawValue: ["client"]), + ] as Map>)) + assert outcome != null + assert outcome.case.dataSet.get(VALIDATION_DEFINITION_GROOVY_FIELD_ID).behaviors.get(VALIDATION_INIT_TRANS_ID).hidden + assert outcome.case.dataSet.get(VALIDATION_NUM_ARGUMENTS_GROOVY_FIELD_ID).behaviors.get(VALIDATION_INIT_TRANS_ID).hidden + assert outcome.case.dataSet.get(VALIDATION_DEFINITION_GROOVY_FIELD_ID).behaviors.get(VALIDATION_DETAIL_TRANS_ID).hidden + assert outcome.case.dataSet.get(VALIDATION_NUM_ARGUMENTS_GROOVY_FIELD_ID).behaviors.get(VALIDATION_DETAIL_TRANS_ID).hidden + assert outcome.case.dataSet.get(VALIDATION_DEFINITION_JAVASCRIPT_FIELD_ID).behaviors.get(VALIDATION_INIT_TRANS_ID).editable + assert outcome.case.dataSet.get(VALIDATION_NUM_ARGUMENTS_JAVASCRIPT_FIELD_ID).behaviors.get(VALIDATION_INIT_TRANS_ID).editable + assert outcome.case.dataSet.get(VALIDATION_DEFINITION_JAVASCRIPT_FIELD_ID).behaviors.get(VALIDATION_DETAIL_TRANS_ID).editable + assert outcome.case.dataSet.get(VALIDATION_NUM_ARGUMENTS_JAVASCRIPT_FIELD_ID).behaviors.get(VALIDATION_DETAIL_TRANS_ID).editable + + outcome = importHelper.setTaskData("Init", validationCase.stringId, new DataSet([ + (VALIDATION_VALIDATION_TYPE_FIELD_ID): new MultichoiceMapField(rawValue: ["server"]), + ] as Map>)) + assert outcome != null + assert outcome.case.dataSet.get(VALIDATION_DEFINITION_GROOVY_FIELD_ID).behaviors.get(VALIDATION_INIT_TRANS_ID).editable + assert outcome.case.dataSet.get(VALIDATION_NUM_ARGUMENTS_GROOVY_FIELD_ID).behaviors.get(VALIDATION_INIT_TRANS_ID).editable + assert outcome.case.dataSet.get(VALIDATION_DEFINITION_GROOVY_FIELD_ID).behaviors.get(VALIDATION_DETAIL_TRANS_ID).editable + assert outcome.case.dataSet.get(VALIDATION_NUM_ARGUMENTS_GROOVY_FIELD_ID).behaviors.get(VALIDATION_DETAIL_TRANS_ID).editable + assert outcome.case.dataSet.get(VALIDATION_DEFINITION_JAVASCRIPT_FIELD_ID).behaviors.get(VALIDATION_INIT_TRANS_ID).hidden + assert outcome.case.dataSet.get(VALIDATION_NUM_ARGUMENTS_JAVASCRIPT_FIELD_ID).behaviors.get(VALIDATION_INIT_TRANS_ID).hidden + assert outcome.case.dataSet.get(VALIDATION_DEFINITION_JAVASCRIPT_FIELD_ID).behaviors.get(VALIDATION_DETAIL_TRANS_ID).hidden + assert outcome.case.dataSet.get(VALIDATION_NUM_ARGUMENTS_JAVASCRIPT_FIELD_ID).behaviors.get(VALIDATION_DETAIL_TRANS_ID).hidden + + outcome = importHelper.setTaskData("Init", validationCase.stringId, new DataSet([ + (VALIDATION_VALIDATION_TYPE_FIELD_ID): new MultichoiceMapField(rawValue: ["server", "client"]), + ] as Map>)) + assert outcome != null + assert outcome.case.dataSet.get(VALIDATION_DEFINITION_GROOVY_FIELD_ID).behaviors.get(VALIDATION_INIT_TRANS_ID).editable + assert outcome.case.dataSet.get(VALIDATION_NUM_ARGUMENTS_GROOVY_FIELD_ID).behaviors.get(VALIDATION_INIT_TRANS_ID).editable + assert outcome.case.dataSet.get(VALIDATION_DEFINITION_GROOVY_FIELD_ID).behaviors.get(VALIDATION_DETAIL_TRANS_ID).editable + assert outcome.case.dataSet.get(VALIDATION_NUM_ARGUMENTS_GROOVY_FIELD_ID).behaviors.get(VALIDATION_DETAIL_TRANS_ID).editable + assert outcome.case.dataSet.get(VALIDATION_DEFINITION_JAVASCRIPT_FIELD_ID).behaviors.get(VALIDATION_INIT_TRANS_ID).editable + assert outcome.case.dataSet.get(VALIDATION_NUM_ARGUMENTS_JAVASCRIPT_FIELD_ID).behaviors.get(VALIDATION_INIT_TRANS_ID).editable + assert outcome.case.dataSet.get(VALIDATION_DEFINITION_JAVASCRIPT_FIELD_ID).behaviors.get(VALIDATION_DETAIL_TRANS_ID).editable + assert outcome.case.dataSet.get(VALIDATION_NUM_ARGUMENTS_JAVASCRIPT_FIELD_ID).behaviors.get(VALIDATION_DETAIL_TRANS_ID).editable + + outcome = importHelper.setTaskData("Init", validationCase.stringId, new DataSet([ + (VALIDATION_NAME_FIELD_ID): new TextField(rawValue: "test"), + (VALIDATION_VALIDATION_TYPE_FIELD_ID): new MultichoiceMapField(rawValue: ["server"]), + (VALIDATION_DEFINITION_GROOVY_FIELD_ID): new TextField(rawValue: "-> thisField.rawValue == 1") + ] as Map>)) + assert outcome != null + + validationTask = importHelper.finishTaskAsSuper("Init", validationCase.stringId).getTask() + assert validationTask != null + + validationTask = importHelper.assignTaskToSuper("Activate", validationCase.stringId).getTask() + assert validationTask != null + + validationTask = importHelper.finishTaskAsSuper("Activate", validationCase.stringId).getTask() + assert validationTask != null + + validationCase = workflowService.findOne(validationCase.stringId) + + assert validationCase.dataSet.get(VALIDATION_DEFINITION_GROOVY_FIELD_ID).behaviors.get(VALIDATION_DETAIL_TRANS_ID).visible + assert validationCase.dataSet.get(VALIDATION_NUM_ARGUMENTS_GROOVY_FIELD_ID).behaviors.get(VALIDATION_DETAIL_TRANS_ID).visible + assert validationCase.dataSet.get(VALIDATION_DEFINITION_JAVASCRIPT_FIELD_ID).behaviors.get(VALIDATION_DETAIL_TRANS_ID).hidden + assert validationCase.dataSet.get(VALIDATION_NUM_ARGUMENTS_JAVASCRIPT_FIELD_ID).behaviors.get(VALIDATION_DETAIL_TRANS_ID).hidden + + validationTask = importHelper.assignTaskToSuper("Deactivate", validationCase.stringId).getTask() + assert validationTask != null + + validationTask = importHelper.finishTaskAsSuper("Deactivate", validationCase.stringId).getTask() + assert validationTask != null + + validationCase = workflowService.findOne(validationCase.stringId) + + assert validationCase.dataSet.get(VALIDATION_DEFINITION_GROOVY_FIELD_ID).behaviors.get(VALIDATION_DETAIL_TRANS_ID).editable + assert validationCase.dataSet.get(VALIDATION_NUM_ARGUMENTS_GROOVY_FIELD_ID).behaviors.get(VALIDATION_DETAIL_TRANS_ID).editable + assert validationCase.dataSet.get(VALIDATION_DEFINITION_JAVASCRIPT_FIELD_ID).behaviors.get(VALIDATION_DETAIL_TRANS_ID).hidden + assert validationCase.dataSet.get(VALIDATION_NUM_ARGUMENTS_JAVASCRIPT_FIELD_ID).behaviors.get(VALIDATION_DETAIL_TRANS_ID).hidden + } + + @Test + void dynamicValidation_process_create() { + PetriNet net = petriNetService.getNewestVersionByIdentifier(VALIDATION_PETRI_NET_IDENTIFIER) + + Case validationCase = importHelper.createCase("Validation test", net) + assert validationCase != null + + Task validationTask = importHelper.assignTaskToSuper("Init", validationCase.stringId).getTask() + assert validationTask != null + + SetDataEventOutcome outcome = importHelper.setTaskData("Init", validationCase.stringId, new DataSet([ + (VALIDATION_NAME_FIELD_ID): new TextField(rawValue: "test"), + (VALIDATION_VALIDATION_TYPE_FIELD_ID): new MultichoiceMapField(rawValue: ["server"]), + (VALIDATION_DEFINITION_GROOVY_FIELD_ID): new TextField(rawValue: null) + ] as Map>)) + assert outcome != null + + validationTask = importHelper.finishTaskAsSuper("Init", validationCase.stringId).getTask() + assert validationTask != null + + validationTask = importHelper.assignTaskToSuper("Activate", validationCase.stringId).getTask() + assert validationTask != null + + Assertions.assertThrows(IllegalArgumentException.class, () -> { + validationTask = importHelper.finishTaskAsSuper("Activate", validationCase.stringId).getTask() + assert validationTask != null + }) + + outcome = importHelper.setTaskData("Detail", validationCase.stringId, new DataSet([ + (VALIDATION_DEFINITION_GROOVY_FIELD_ID): new TextField(rawValue: "-> thisField.rawValue == 1") + ] as Map>)) + assert outcome != null + + validationTask = importHelper.finishTaskAsSuper("Activate", validationCase.stringId).getTask() + assert validationTask != null + } } From b08edcfc6851fcfbce0caf326fd15b4b3d322756 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Kov=C3=A1=C4=8Dik?= Date: Wed, 12 Mar 2025 10:11:12 +0100 Subject: [PATCH 12/12] [NAE-1770] Validation register frontend - fix validation naming - fix task immediate data --- .../logic/action/ValidationDelegate.groovy | 28 ++++---- .../engine/export/service/ExportService.java | 5 +- .../engine/workflow/domain/Task.java | 6 -- .../engine/workflow/service/DataService.java | 3 +- .../workflow/service/TaskSearchService.java | 11 ++++ .../engine/workflow/service/TaskService.java | 1 - .../web/requestbodies/TaskSearchRequest.java | 3 + .../validations/validation.xml | 66 +++++++++++++++++++ .../petriNets/insurance_portal_demo.xml | 4 +- .../petriNets/insurance_role_test.xml | 4 +- .../BooleanFieldValidationTest.groovy | 8 +-- .../validation/TextFieldValidationTest.groovy | 16 ++--- .../petriNets/validation/valid_boolean.xml | 2 +- .../petriNets/validation/valid_date.xml | 20 ++++++ .../petriNets/validation/valid_number.xml | 8 +++ .../petriNets/validation/valid_regex.xml | 18 +++++ .../petriNets/validation/valid_text.xml | 25 +++++-- 17 files changed, 183 insertions(+), 45 deletions(-) diff --git a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationDelegate.groovy b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationDelegate.groovy index e887fe51afb..255666ba6ea 100644 --- a/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationDelegate.groovy +++ b/src/main/groovy/com/netgrif/application/engine/petrinet/domain/dataset/logic/action/ValidationDelegate.groovy @@ -23,10 +23,10 @@ class ValidationDelegate { // todo NAE-1788: thisField keyword Field thisField - Boolean notempty() { return thisField.rawValue != null } + Boolean notEmpty() { return thisField.rawValue != null } // boolean field validations - Boolean requiredtrue() { return thisField instanceof BooleanField && notempty() && thisField.rawValue == true } + Boolean requiredTrue() { return thisField instanceof BooleanField && notEmpty() && thisField.rawValue == true } // date field validations Boolean between(def from, def to) { @@ -81,10 +81,10 @@ class ValidationDelegate { return true } - Boolean workday() { return (thisField instanceof DateField || thisField instanceof DateTimeField) && notempty() && !thisField.rawValue.dayOfWeek.isWeekend() } + Boolean workday() { return (thisField instanceof DateField || thisField instanceof DateTimeField) && notEmpty() && !thisField.rawValue.dayOfWeek.isWeekend() } - Boolean weekend() { return (thisField instanceof DateField || thisField instanceof DateTimeField) && notempty() && thisField.rawValue.dayOfWeek.isWeekend() } + Boolean weekend() { return (thisField instanceof DateField || thisField instanceof DateTimeField) && notEmpty() && thisField.rawValue.dayOfWeek.isWeekend() } protected static LocalDate parseStringToLocalDate(String stringDate) { if (stringDate == null) { @@ -109,15 +109,15 @@ class ValidationDelegate { } // number field validations - Boolean odd() { return thisField instanceof NumberField && notempty() && thisField.rawValue as Double % 2 != 0 } + Boolean odd() { return thisField instanceof NumberField && notEmpty() && thisField.rawValue as Double % 2 != 0 } - Boolean even() { return thisField instanceof NumberField && notempty() && thisField.rawValue as Double % 2 == 0 } + Boolean even() { return thisField instanceof NumberField && notEmpty() && thisField.rawValue as Double % 2 == 0 } - Boolean positive() { return thisField instanceof NumberField && notempty() && thisField.rawValue >= 0 } + Boolean positive() { return thisField instanceof NumberField && notEmpty() && thisField.rawValue >= 0 } - Boolean negative() { return thisField instanceof NumberField && notempty() && thisField.rawValue <= 0 } + Boolean negative() { return thisField instanceof NumberField && notEmpty() && thisField.rawValue <= 0 } - Boolean decimal() { return thisField instanceof NumberField && notempty() && thisField.rawValue as Double % 1 == 0 } + Boolean decimal() { return thisField instanceof NumberField && notEmpty() && thisField.rawValue as Double % 1 == 0 } Boolean inrange(def from, def to) { @@ -128,17 +128,17 @@ class ValidationDelegate { if (to instanceof String && to.toLowerCase() == INF) { to = Double.MAX_VALUE } - return thisField instanceof NumberField && notempty() && thisField.rawValue >= from as Double && thisField.rawValue <= to as Double + return thisField instanceof NumberField && notEmpty() && thisField.rawValue >= from as Double && thisField.rawValue <= to as Double } // text field validations - Boolean regex(String pattern) { return thisField instanceof TextField && notempty() && thisField.rawValue ==~ pattern } + Boolean regex(String pattern) { return thisField instanceof TextField && notEmpty() && thisField.rawValue ==~ pattern } - Boolean minlength(Integer minLength) { return thisField instanceof TextField && notempty() && (thisField.rawValue as String).length() >= minLength } + Boolean minLength(Integer minLength) { return thisField instanceof TextField && notEmpty() && (thisField.rawValue as String).length() >= minLength } - Boolean maxlength(Integer maxLength) { return thisField instanceof TextField && notempty() && (thisField.rawValue as String).length() <= maxLength } + Boolean maxLength(Integer maxLength) { return thisField instanceof TextField && notEmpty() && (thisField.rawValue as String).length() <= maxLength } - Boolean telnumber() { return regex(TEL_NUMBER_REGEX) } + Boolean telNumber() { return regex(TEL_NUMBER_REGEX) } Boolean email() { return regex(EMAIL_REGEX) } diff --git a/src/main/java/com/netgrif/application/engine/export/service/ExportService.java b/src/main/java/com/netgrif/application/engine/export/service/ExportService.java index 5cb141defb3..c214cfe061d 100644 --- a/src/main/java/com/netgrif/application/engine/export/service/ExportService.java +++ b/src/main/java/com/netgrif/application/engine/export/service/ExportService.java @@ -15,6 +15,7 @@ import com.netgrif.application.engine.workflow.domain.Task; 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.IDataService; import com.netgrif.application.engine.workflow.service.interfaces.ITaskService; import com.netgrif.application.engine.workflow.service.interfaces.IWorkflowService; import com.querydsl.core.types.Predicate; @@ -59,6 +60,8 @@ public class ExportService implements IExportService { @Autowired private IUserService userService; + @Autowired + private IDataService dataService; @Override public Set buildDefaultCsvCaseHeader(List exportCases) { @@ -74,7 +77,7 @@ public Set buildDefaultCsvTaskHeader(List exportTasks) { Set header = new LinkedHashSet<>(); exportTasks.forEach( exportTask -> - header.addAll(exportTask.getImmediateDataFields()) + header.addAll(dataService.getImmediateFields(exportTask).stream().map(Field::getStringId).collect(Collectors.toSet())) ); return header; } diff --git a/src/main/java/com/netgrif/application/engine/workflow/domain/Task.java b/src/main/java/com/netgrif/application/engine/workflow/domain/Task.java index e63f53e91b8..a408cd5e03a 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/domain/Task.java +++ b/src/main/java/com/netgrif/application/engine/workflow/domain/Task.java @@ -111,12 +111,6 @@ public class Task implements Serializable { private String transactionId; - // TODO: release/8.0.0 remove, dynamically load from dataSet - @Getter - @Setter - @JsonIgnore - @Builder.Default - private LinkedHashSet immediateDataFields = new LinkedHashSet<>(); @Getter @Setter @Transient 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 ba0e962afbf..6585fe3bf91 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 @@ -741,7 +741,8 @@ public Page setImmediateFields(Page tasks) { @Override public List> getImmediateFields(Task task) { Case useCase = workflowService.findOne(task.getCaseId()); - List> fields = task.getImmediateDataFields().stream().map(f -> useCase.getDataSet().get(f)).collect(Collectors.toList()); + Transition transition = useCase.getPetriNet().getTransition(task.getTransitionId()); + List> fields = transition.getDataSet().keySet().stream().map(f -> useCase.getDataSet().get(f)).filter(field -> field.getBehaviors().get(task.getTransitionId()).isImmediate()).collect(Collectors.toList()); // TODO: release/8.0.0 order? // LongStream.range(0L, fields.size()).forEach(index -> fields.get((int) index).setOrder(index)); return fields; diff --git a/src/main/java/com/netgrif/application/engine/workflow/service/TaskSearchService.java b/src/main/java/com/netgrif/application/engine/workflow/service/TaskSearchService.java index 363dc7e2a74..05b6ff03eda 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/service/TaskSearchService.java +++ b/src/main/java/com/netgrif/application/engine/workflow/service/TaskSearchService.java @@ -7,6 +7,7 @@ import com.netgrif.application.engine.utils.FullPageRequest; import com.netgrif.application.engine.workflow.domain.QTask; import com.netgrif.application.engine.workflow.domain.Task; +import com.netgrif.application.engine.workflow.domain.State; import com.netgrif.application.engine.workflow.web.requestbodies.TaskSearchRequest; import com.netgrif.application.engine.workflow.web.requestbodies.taskSearch.TaskSearchCaseRequest; import com.querydsl.core.BooleanBuilder; @@ -112,6 +113,7 @@ private Predicate buildSingleQuery(TaskSearchRequest request, LoggedUser user, L buildFullTextQuery(request, builder); buildTransitionQuery(request, builder); buildTagsQuery(request, builder); + buildStateQuery(request, builder); boolean resultAlwaysEmpty = buildGroupQuery(request, user, locale, builder); if (resultAlwaysEmpty) @@ -120,6 +122,15 @@ private Predicate buildSingleQuery(TaskSearchRequest request, LoggedUser user, L return builder; } + private void buildStateQuery(TaskSearchRequest request, BooleanBuilder query) { + if (request.state == null) { + return; + } + BooleanBuilder builder = new BooleanBuilder(); + builder.or(QTask.task.state.eq(request.state)); + query.and(builder); + } + private void buildStringIdQuery(TaskSearchRequest request, BooleanBuilder query) { if (request.stringId == null || request.stringId.isEmpty()) { return; 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 1db3244a080..e459edbe1c0 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 @@ -757,7 +757,6 @@ private Task createFromTransition(Transition transition, Case useCase) { .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()) diff --git a/src/main/java/com/netgrif/application/engine/workflow/web/requestbodies/TaskSearchRequest.java b/src/main/java/com/netgrif/application/engine/workflow/web/requestbodies/TaskSearchRequest.java index b205d45681a..d701ffefdcd 100644 --- a/src/main/java/com/netgrif/application/engine/workflow/web/requestbodies/TaskSearchRequest.java +++ b/src/main/java/com/netgrif/application/engine/workflow/web/requestbodies/TaskSearchRequest.java @@ -6,6 +6,7 @@ import com.netgrif.application.engine.workflow.web.requestbodies.taskSearch.TaskSearchCaseRequest; import lombok.AllArgsConstructor; import lombok.NoArgsConstructor; +import com.netgrif.application.engine.workflow.domain.State; import java.util.List; import java.util.Map; @@ -45,4 +46,6 @@ public class TaskSearchRequest { public List stringId; public Map tags; + + public State state; } \ No newline at end of file diff --git a/src/main/resources/petriNets/engine-processes/validations/validation.xml b/src/main/resources/petriNets/engine-processes/validations/validation.xml index b191682f9b7..87d72bbe9a7 100644 --- a/src/main/resources/petriNets/engine-processes/validations/validation.xml +++ b/src/main/resources/petriNets/engine-processes/validations/validation.xml @@ -345,6 +345,7 @@ name visible + immediate 0 @@ -373,6 +374,7 @@ validation_definition_javascript hidden + immediate 0 @@ -429,6 +431,7 @@ validation_type visible + immediate 0 @@ -453,6 +456,62 @@ detail_delegate + + active_detail + 752 + 208 + + + detail_0 + 4 + grid + + name + + visible + immediate + + + 0 + 0 + 1 + 2 + + outline + + + + validation_definition_javascript + + hidden + immediate + + + 0 + 1 + 2 + 4 + + outline + + + + validation_type + + visible + immediate + + + 0 + 3 + 1 + 4 + + outline + + + + p1 180 @@ -541,4 +600,11 @@ inactive 1 + + a10 + read + active + active_detail + 1 + \ No newline at end of file diff --git a/src/main/resources/petriNets/insurance_portal_demo.xml b/src/main/resources/petriNets/insurance_portal_demo.xml index 2887d9f33f1..65b639a4cbf 100644 --- a/src/main/resources/petriNets/insurance_portal_demo.xml +++ b/src/main/resources/petriNets/insurance_portal_demo.xml @@ -5508,7 +5508,7 @@ Telefónne číslo 109018 Poistník - telnumber + telNumber field: f.109020, @@ -6354,7 +6354,7 @@ Telefónne číslo 109032 Poistený - telnumber + telNumber Email diff --git a/src/main/resources/petriNets/insurance_role_test.xml b/src/main/resources/petriNets/insurance_role_test.xml index ef4cd543430..53594ba16c0 100644 --- a/src/main/resources/petriNets/insurance_role_test.xml +++ b/src/main/resources/petriNets/insurance_role_test.xml @@ -5512,7 +5512,7 @@ Telefónne číslo 109018 Poistník - telnumber + telNumber field: f.109020, @@ -6358,7 +6358,7 @@ Telefónne číslo 109032 Poistený - telnumber + telNumber Email diff --git a/src/test/groovy/com/netgrif/application/engine/validation/BooleanFieldValidationTest.groovy b/src/test/groovy/com/netgrif/application/engine/validation/BooleanFieldValidationTest.groovy index f2672a31e6c..37991006e3a 100644 --- a/src/test/groovy/com/netgrif/application/engine/validation/BooleanFieldValidationTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/validation/BooleanFieldValidationTest.groovy @@ -34,14 +34,14 @@ class BooleanFieldValidationTest { ValidationDelegate delegate = getValidationDelegate() delegate.thisField = new BooleanField(rawValue: true) - assert delegate.requiredtrue() + assert delegate.requiredTrue() } @Test void requiredTrue_fail() { ValidationDelegate delegate = getValidationDelegate() delegate.thisField = new BooleanField(rawValue: false) - assert !delegate.requiredtrue() + assert !delegate.requiredTrue() } @Test @@ -49,7 +49,7 @@ class BooleanFieldValidationTest { ValidationDelegate delegate = getValidationDelegate() delegate.thisField = new BooleanField(rawValue: true) - assert delegate.notempty() + assert delegate.notEmpty() } @Test @@ -57,6 +57,6 @@ class BooleanFieldValidationTest { ValidationDelegate delegate = getValidationDelegate() delegate.thisField = new BooleanField(rawValue: null) - assert !delegate.notempty() + assert !delegate.notEmpty() } } diff --git a/src/test/groovy/com/netgrif/application/engine/validation/TextFieldValidationTest.groovy b/src/test/groovy/com/netgrif/application/engine/validation/TextFieldValidationTest.groovy index 6873268df31..1754bbbd9e2 100644 --- a/src/test/groovy/com/netgrif/application/engine/validation/TextFieldValidationTest.groovy +++ b/src/test/groovy/com/netgrif/application/engine/validation/TextFieldValidationTest.groovy @@ -37,26 +37,26 @@ class TextFieldValidationTest { } @Test - void minlength() { + void minLength() { ValidationDelegate delegate = getValidationDelegate() delegate.thisField = new TextField(rawValue: 'totok') - assert !delegate.minlength(6) + assert !delegate.minLength(6) - assert delegate.minlength(5) + assert delegate.minLength(5) - assert delegate.minlength(4) + assert delegate.minLength(4) } @Test - void maxlength() { + void maxLength() { ValidationDelegate delegate = getValidationDelegate() delegate.thisField = new TextField(rawValue: 'totok') - assert !delegate.maxlength(4) + assert !delegate.maxLength(4) - assert delegate.maxlength(5) + assert delegate.maxLength(5) - assert delegate.maxlength(6) + assert delegate.maxLength(6) } } diff --git a/src/test/resources/petriNets/validation/valid_boolean.xml b/src/test/resources/petriNets/validation/valid_boolean.xml index d0146415816..7d01a695ebb 100644 --- a/src/test/resources/petriNets/validation/valid_boolean.xml +++ b/src/test/resources/petriNets/validation/valid_boolean.xml @@ -11,7 +11,7 @@ <validations> <validation> - <name>requiredtrue</name> + <name>requiredTrue</name> <message>error-boolean</message> </validation> </validations> diff --git a/src/test/resources/petriNets/validation/valid_date.xml b/src/test/resources/petriNets/validation/valid_date.xml index 669003e4c33..95fef4a5b63 100644 --- a/src/test/resources/petriNets/validation/valid_date.xml +++ b/src/test/resources/petriNets/validation/valid_date.xml @@ -17,6 +17,10 @@ <argument>today</argument> <argument>future</argument> </serverArguments> + <clientArguments> + <argument>today</argument> + <argument>future</argument> + </clientArguments> <message>error-date01</message> </validation> </validations> @@ -31,6 +35,10 @@ <argument>past</argument> <argument>today</argument> </serverArguments> + <clientArguments> + <argument>past</argument> + <argument>today</argument> + </clientArguments> <message>error-date02</message> </validation> </validations> @@ -45,6 +53,10 @@ <argument>2020-03-03</argument> <argument>today</argument> </serverArguments> + <clientArguments> + <argument>2020-03-03</argument> + <argument>today</argument> + </clientArguments> <message>error-date03</message> </validation> </validations> @@ -59,6 +71,10 @@ <argument>past</argument> <argument>2020-03-03</argument> </serverArguments> + <clientArguments> + <argument>past</argument> + <argument>2020-03-03</argument> + </clientArguments> <message>error-date04</message> </validation> </validations> @@ -73,6 +89,10 @@ <argument>2020-01-01</argument> <argument>2022-03-03</argument> </serverArguments> + <clientArguments> + <argument>2020-01-01</argument> + <argument>2022-03-03</argument> + </clientArguments> <message>error-date05</message> </validation> </validations> diff --git a/src/test/resources/petriNets/validation/valid_number.xml b/src/test/resources/petriNets/validation/valid_number.xml index 60737623769..1537f66d129 100644 --- a/src/test/resources/petriNets/validation/valid_number.xml +++ b/src/test/resources/petriNets/validation/valid_number.xml @@ -67,6 +67,10 @@ <argument>10</argument> <argument>20</argument> </serverArguments> + <clientArguments> + <argument>10</argument> + <argument>20</argument> + </clientArguments> <message>error-number06</message> </validation> </validations> @@ -86,6 +90,10 @@ <argument>inf</argument> <argument>5</argument> </serverArguments> + <clientArguments> + <argument>inf</argument> + <argument>5</argument> + </clientArguments> <message>error-number07-2</message> </validation> </validations> diff --git a/src/test/resources/petriNets/validation/valid_regex.xml b/src/test/resources/petriNets/validation/valid_regex.xml index 8c3d770c2d3..70c19e7c8e2 100644 --- a/src/test/resources/petriNets/validation/valid_regex.xml +++ b/src/test/resources/petriNets/validation/valid_regex.xml @@ -15,6 +15,9 @@ <serverArguments> <argument>^([0-9]{1,6})$</argument> <!-- Cislo pocet znakov 1-6 --> </serverArguments> + <clientArguments> + <argument>^([0-9]{1,6})$</argument> <!-- Cislo pocet znakov 1-6 --> + </clientArguments> <message>error-regex01</message> </validation> </validations> @@ -28,6 +31,9 @@ <serverArguments> <argument>^([a-zA-Z0-9\-]{10})$</argument> <!-- Cislo alebo pismeno a polcka 10 znakov --> </serverArguments> + <clientArguments> + <argument>^([a-zA-Z0-9\-]{10})$</argument> <!-- Cislo alebo pismeno a polcka 10 znakov --> + </clientArguments> <message>error-regex02</message> </validation> </validations> @@ -41,6 +47,9 @@ <serverArguments> <argument>^(TOTOK[a-zA-Z0-9]{7})$</argument> <!-- Prefix max 12 znakov --> </serverArguments> + <clientArguments> + <argument>^(TOTOK[a-zA-Z0-9]{7})$</argument> <!-- Prefix max 12 znakov --> + </clientArguments> <message>error-regex03</message> </validation> </validations> @@ -54,6 +63,9 @@ <serverArguments> <argument>^([a-zA-Z0-9 ]{1,10})$</argument> <!-- 10 znakov vratane medzeri --> </serverArguments> + <clientArguments> + <argument>^([a-zA-Z0-9 ]{1,10})$</argument> <!-- 10 znakov vratane medzeri --> + </clientArguments> <message>error-regex04</message> </validation> </validations> @@ -67,6 +79,9 @@ <serverArguments> <argument>^([A-ž0-9!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/? ]{1,100})$</argument> <!-- pismena a specialne znaky max100 --> </serverArguments> + <clientArguments> + <argument>^([A-ž0-9!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/? ]{1,100})$</argument> <!-- pismena a specialne znaky max100 --> + </clientArguments> <message>error-regex05</message> </validation> </validations> @@ -80,6 +95,9 @@ <serverArguments> <argument>^[a-zA-Z0-9\._\%\+\-]+@[a-zA-Z0-9\.\-]+\.[a-zA-Z]{2,}$</argument> <!-- E-mail --> </serverArguments> + <clientArguments> + <argument>^[a-zA-Z0-9\._\%\+\-]+@[a-zA-Z0-9\.\-]+\.[a-zA-Z]{2,}$</argument> <!-- E-mail --> + </clientArguments> <message>error-regex06</message> </validation> </validations> diff --git a/src/test/resources/petriNets/validation/valid_text.xml b/src/test/resources/petriNets/validation/valid_text.xml index dc83017552a..d0985c103a4 100644 --- a/src/test/resources/petriNets/validation/valid_text.xml +++ b/src/test/resources/petriNets/validation/valid_text.xml @@ -22,7 +22,7 @@ <title/> <validations> <validation> - <name>telnumber</name> + <name>telNumber</name> <message>error-text02</message> </validation> </validations> @@ -32,10 +32,13 @@ <title/> <validations> <validation> - <name>maxlength</name> + <name>maxLength</name> <serverArguments> <argument>6</argument> </serverArguments> + <clientArguments> + <argument>6</argument> + </clientArguments> <message>error-text03</message> </validation> </validations> @@ -45,10 +48,13 @@ <title/> <validations> <validation> - <name>minlength</name> + <name>minLength</name> <serverArguments> <argument>3</argument> </serverArguments> + <clientArguments> + <argument>3</argument> + </clientArguments> <message>error-text04</message> </validation> </validations> @@ -58,17 +64,23 @@ <title/> <validations> <validation> - <name>minlength</name> + <name>minLength</name> <serverArguments> <argument>3</argument> </serverArguments> + <clientArguments> + <argument>3</argument> + </clientArguments> <message>error-text05</message> </validation> <validation> - <name>maxlength</name> + <name>maxLength</name> <serverArguments> <argument>6</argument> </serverArguments> + <clientArguments> + <argument>6</argument> + </clientArguments> <message>error-text05</message> </validation> </validations> @@ -82,6 +94,9 @@ <serverArguments> <argument dynamic="true">number01.rawValue</argument> </serverArguments> + <clientArguments> + <argument dynamic="true">number01.rawValue</argument> + </clientArguments> <message>error-text06</message> </validation> </validations>