nosu
/
taskana
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

TSK-283: Root-Classifications should always be false in domain.

This commit is contained in:
Marcel Lengl 2018-02-27 16:08:11 +01:00 committed by Holger Hagen
parent 88e24ed4a0
commit 64af03c368
7 changed files with 201 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
lib/taskana-core/src/main/java/pro/taskana/impl/ClassificationServiceImpl.java
View File

@ -62,7 +62,9 @@ public class ClassificationServiceImpl implements ClassificationService {
classificationMapper.insert(classificationImpl);
LOGGER.debug("Method createClassification created classification {}.", classification);
addClassificationToRootDomain(classificationImpl);
if (!classification.getDomain().isEmpty()) {
addClassificationToRootDomain(classificationImpl);
}
} finally {
taskanaEngine.returnConnection();
LOGGER.debug("exit from createClassification()");
@ -75,8 +77,10 @@ public class ClassificationServiceImpl implements ClassificationService {
boolean doesExist = true;
String idBackup = classificationImpl.getId();
String domainBackup = classificationImpl.getDomain();
boolean isValidInDomainBackup = classificationImpl.getIsValidInDomain();
classificationImpl.setId(IdGenerator.generateWithPrefix(ID_PREFIX_CLASSIFICATION));
classificationImpl.setDomain("");
classificationImpl.setIsValidInDomain(false);
try {
this.getClassification(classificationImpl.getKey(), classificationImpl.getDomain());
throw new ClassificationAlreadyExistException(classificationImpl);
@ -98,6 +102,7 @@ public class ClassificationServiceImpl implements ClassificationService {
}
classificationImpl.setId(idBackup);
classificationImpl.setDomain(domainBackup);
classificationImpl.setIsValidInDomain(isValidInDomainBackup);
}
}
}
@ -194,6 +199,10 @@ public class ClassificationServiceImpl implements ClassificationService {
if (classification.getDomain() == null) {
classification.setDomain("");
}
if (classification.getDomain().isEmpty()) {
classification.setIsValidInDomain(false);
}
}
@Override

143
lib/taskana-core/src/test/java/acceptance/classification/CreateClassificationAccTest.java Normal file
View File

@ -0,0 +1,143 @@
package acceptance.classification;
import static org.hamcrest.core.IsEqual.equalTo;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
import org.h2.store.fs.FileUtils;
import org.junit.AfterClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import acceptance.AbstractAccTest;
import pro.taskana.Classification;
import pro.taskana.ClassificationService;
import pro.taskana.exceptions.ClassificationAlreadyExistException;
import pro.taskana.exceptions.ClassificationNotFoundException;
import pro.taskana.exceptions.NotAuthorizedException;
import pro.taskana.security.JAASRunner;
import pro.taskana.security.WithAccessId;
/**
* Acceptance test for all "create classification" scenarios.
*/
@RunWith(JAASRunner.class)
public class CreateClassificationAccTest extends AbstractAccTest {
private ClassificationService classificationService;
public CreateClassificationAccTest() {
super();
classificationService = taskanaEngine.getClassificationService();
}
@WithAccessId(
userName = "teamlead_1",
groupNames = {"group_1", "businessadmin"})
@Test
public void testCreateRootClassification()
throws ClassificationAlreadyExistException, ClassificationNotFoundException, NotAuthorizedException {
long amountOfClassificationsBefore = classificationService.createClassificationQuery().count();
Classification classification = classificationService.newClassification("Key0", "", "TASK");
classification.setIsValidInDomain(true);
classification = classificationService.createClassification(classification);
// check only 1 created
long amountOfClassificationsAfter = classificationService.createClassificationQuery().count();
assertThat(amountOfClassificationsAfter, equalTo(amountOfClassificationsBefore + 1));
classification = classificationService.getClassification(classification.getId());
assertNotNull(classification);
assertNotNull(classification.getCreated());
assertNotNull(classification.getId());
assertThat(classification.getIsValidInDomain(), equalTo(false));
}
@WithAccessId(
userName = "teamlead_1",
groupNames = {"group_1", "businessadmin"})
@Test
public void testCreateClassificationWithRootCopy()
throws ClassificationAlreadyExistException, ClassificationNotFoundException, NotAuthorizedException {
long amountOfClassificationsBefore = classificationService.createClassificationQuery().count();
Classification classification = classificationService.newClassification("Key1", "Dummy-Domain", "TASK");
classification.setIsValidInDomain(true);
classification = classificationService.createClassification(classification);
// Check returning one is the "original"
assertNotNull(classification.getId());
assertNotNull(classification.getCreated());
assertThat(classification.getIsValidInDomain(), equalTo(true));
assertThat(classification.getDomain(), equalTo("Dummy-Domain"));
// Check 2 new created
long amountOfClassificationsAfter = classificationService.createClassificationQuery().count();
assertThat(amountOfClassificationsAfter, equalTo(amountOfClassificationsBefore + 2));
// Check main
classification = classificationService.getClassification(classification.getId());
assertNotNull(classification);
assertNotNull(classification.getCreated());
assertNotNull(classification.getId());
assertThat(classification.getIsValidInDomain(), equalTo(true));
// Check root-copy
classification = classificationService.getClassification(classification.getKey(), "");
assertNotNull(classification);
assertNotNull(classification.getCreated());
assertNotNull(classification.getId());
assertThat(classification.getIsValidInDomain(), equalTo(false));
}
@WithAccessId(
userName = "teamlead_1",
groupNames = {"group_1", "businessadmin"})
@Test
public void testCreateClassificationWithInvalidValues()
throws ClassificationAlreadyExistException, NotAuthorizedException {
long amountOfClassificationsBefore = classificationService.createClassificationQuery().count();
// Check key NULL
try {
Classification classification = classificationService.newClassification(null, "Dummy-Domain", "TASK");
classification = classificationService.createClassification(classification);
} catch (IllegalStateException e) {
// nothing to do
}
// Check invalid ServiceLevel
try {
Classification classification = classificationService.newClassification("Key2", "Domain", "TASK");
classification.setServiceLevel("abc");
classification = classificationService.createClassification(classification);
} catch (IllegalArgumentException e) {
// nothing to do
}
// Check domain NULL will be replaced ""
Classification classification = classificationService.newClassification("Key2", null, "TASK");
classification = classificationService.createClassification(classification);
long amountOfClassificationsAfter = classificationService.createClassificationQuery().count();
assertThat(amountOfClassificationsAfter, equalTo(amountOfClassificationsBefore + 1));
assertThat(classification.getDomain(), equalTo(""));
assertThat(classification.getParentId(), equalTo(""));
assertThat(classification.getIsValidInDomain(), equalTo(false));
assertNotNull(classification.getCreated());
}
@WithAccessId(
userName = "teamlead_1",
groupNames = {"group_1", "businessadmin"})
@Test(expected = ClassificationAlreadyExistException.class)
public void testCreateClassificationAlreadyExisting()
throws ClassificationAlreadyExistException, NotAuthorizedException {
Classification classification = classificationService.newClassification("Key3", "", "TASK");
classification = classificationService.createClassification(classification);
classification = classificationService.createClassification(classification);
}
@AfterClass
public static void cleanUpClass() {
FileUtils.deleteRecursive("~/data", true);
}
}

2
lib/taskana-core/src/test/java/acceptance/classification/QueryClassificationAccTest.java
View File

@ -186,7 +186,7 @@ public class QueryClassificationAccTest extends AbstractAccTest {
.validInDomainEquals(Boolean.TRUE)
.priorityIn(1, 2, 3)
.list();
assertEquals(23, list.size());
assertEquals(15, list.size());
}

22
lib/taskana-core/src/test/java/pro/taskana/impl/integration/ClassificationServiceImplIntAutoCommitTest.java
View File

@ -189,7 +189,7 @@ public class ClassificationServiceImplIntAutoCommitTest {
public void testInsertAndClassificationMapper()
throws NotAuthorizedException, ClassificationAlreadyExistException, ClassificationNotFoundException,
InvalidArgumentException {
Classification classification = this.createDummyClassificationWithUniqueKey("", "type1");
Classification classification = this.createDummyClassificationWithUniqueKey("UNIQUE-DOMAIN", "type1");
classification = classificationService.createClassification(classification);
List<ClassificationSummary> list = classificationService.createClassificationQuery()
@ -203,7 +203,7 @@ public class ClassificationServiceImplIntAutoCommitTest {
@Test
public void testUpdateAndClassificationMapper()
throws NotAuthorizedException, ClassificationAlreadyExistException, ClassificationNotFoundException {
Classification classification = this.createDummyClassificationWithUniqueKey("", "type1");
Classification classification = this.createDummyClassificationWithUniqueKey("UNIQUE-DOMAIN", "type1");
classification = classificationService.createClassification(classification);
classification.setDescription("description");
classification = classificationService.updateClassification(classification);
@ -216,10 +216,10 @@ public class ClassificationServiceImplIntAutoCommitTest {
classification = classificationService.updateClassification(classification);
list = classificationService.createClassificationQuery()
.list();
Assert.assertEquals(1, list.size());
Assert.assertEquals(2, list.size());
List<ClassificationSummary> allClassifications = classificationService.createClassificationQuery().list();
Assert.assertEquals(1, allClassifications.size());
Assert.assertEquals(2, allClassifications.size());
}
@Test
@ -356,10 +356,10 @@ public class ClassificationServiceImplIntAutoCommitTest {
@Test
public void testDefaultSettingsWithClassificationMapper()
throws NotAuthorizedException, ClassificationAlreadyExistException, ClassificationNotFoundException {
Classification classification = this.createDummyClassificationWithUniqueKey("", "type1");
Classification classification = this.createDummyClassificationWithUniqueKey("UNIQUE-DOMAIN", "type1");
classification = classificationService.createClassification(classification);
Classification classification1 = this.createDummyClassificationWithUniqueKey("", "type1");
Classification classification1 = this.createDummyClassificationWithUniqueKey("UNIQUE-DOMAIN", "type1");
classification1 = classificationService.createClassification(classification1);
classification1.setParentId(classification.getKey());
@ -368,27 +368,27 @@ public class ClassificationServiceImplIntAutoCommitTest {
List<ClassificationSummary> list = classificationService.createClassificationQuery()
.parentIdIn("")
.list();
Assert.assertEquals(1, list.size());
Assert.assertEquals(3, list.size());
list = classificationService.createClassificationQuery()
.list();
Assert.assertEquals(2, list.size());
Assert.assertEquals(4, list.size());
List<ClassificationSummary> listAll = classificationService.createClassificationQuery().list();
list = classificationService.createClassificationQuery().list();
Assert.assertEquals(listAll.size(), list.size());
list = classificationService.createClassificationQuery().validInDomainEquals(true).list();
Assert.assertEquals(listAll.size(), list.size());
Assert.assertEquals(2, list.size());
list = classificationService.createClassificationQuery().createdWithin(today()).list();
Assert.assertEquals(listAll.size(), list.size());
Assert.assertEquals(4, list.size());
list = classificationService.createClassificationQuery().domainIn("domain1").validInDomainEquals(false).list();
Assert.assertEquals(0, list.size());
list = classificationService.createClassificationQuery()
.list();
Assert.assertEquals(2, list.size());
Assert.assertEquals(4, list.size());
}
private TimeInterval today() {

22
lib/taskana-core/src/test/java/pro/taskana/impl/integration/ClassificationServiceImplIntExplicitTest.java
View File

@ -210,7 +210,7 @@ public class ClassificationServiceImplIntExplicitTest {
throws SQLException, ClassificationAlreadyExistException, NotAuthorizedException {
Connection connection = dataSource.getConnection();
taskanaEngineImpl.setConnection(connection);
Classification classification = this.createNewClassificationWithUniqueKey("", "t1");
Classification classification = this.createNewClassificationWithUniqueKey("UNIQUE-DOMAIN", "t1");
classificationService.createClassification(classification);
List<ClassificationSummary> list = classificationService.createClassificationQuery()
.validInDomainEquals(Boolean.TRUE)
@ -224,7 +224,7 @@ public class ClassificationServiceImplIntExplicitTest {
ClassificationAlreadyExistException, ClassificationNotFoundException {
Connection connection = dataSource.getConnection();
taskanaEngineImpl.setConnection(connection);
Classification classification = this.createNewClassificationWithUniqueKey("", "t1");
Classification classification = this.createNewClassificationWithUniqueKey("UNIQUE-DOMAIN", "t1");
classification.setDescription("");
classification = classificationService.createClassification(classification);
classification.setDescription("description");
@ -232,7 +232,7 @@ public class ClassificationServiceImplIntExplicitTest {
List<ClassificationSummary> list = classificationService.createClassificationQuery()
.list();
Assert.assertEquals(1, list.size());
Assert.assertEquals(2, list.size());
list = classificationService.createClassificationQuery().validInDomainEquals(true).list();
Assert.assertEquals(1, list.size());
classification = classificationService.getClassification(classification.getKey(), classification.getDomain());
@ -241,10 +241,10 @@ public class ClassificationServiceImplIntExplicitTest {
classification = classificationService.updateClassification(classification);
list = classificationService.createClassificationQuery()
.list();
Assert.assertEquals(1, list.size());
Assert.assertEquals(2, list.size());
List<ClassificationSummary> allClassifications = classificationService.createClassificationQuery().list();
Assert.assertEquals(1, allClassifications.size());
Assert.assertEquals(2, allClassifications.size());
connection.commit();
}
@ -397,10 +397,10 @@ public class ClassificationServiceImplIntExplicitTest {
ClassificationAlreadyExistException, ClassificationNotFoundException, InvalidArgumentException {
Connection connection = dataSource.getConnection();
taskanaEngineImpl.setConnection(connection);
Classification classification = this.createNewClassificationWithUniqueKey("", "type1");
Classification classification = this.createNewClassificationWithUniqueKey("UNIQUE-DOMAIN", "type1");
classification = classificationService.createClassification(classification);
Classification classification1 = this.createNewClassificationWithUniqueKey("", "type1");
Classification classification1 = this.createNewClassificationWithUniqueKey("UNIQUE-DOMAIN", "type1");
classification1 = classificationService.createClassification(classification1);
classification1.setParentId(classification.getId());
classification1 = classificationService.updateClassification(classification1);
@ -408,22 +408,22 @@ public class ClassificationServiceImplIntExplicitTest {
List<ClassificationSummary> list = classificationService.createClassificationQuery()
.parentIdIn("")
.list();
Assert.assertEquals(1, list.size());
Assert.assertEquals(3, list.size());
list = classificationService.createClassificationQuery()
.list();
Assert.assertEquals(2, list.size());
Assert.assertEquals(4, list.size());
connection.commit();
list = classificationService.createClassificationQuery().validInDomainEquals(true).list();
Assert.assertEquals(2, list.size());
list = classificationService.createClassificationQuery().createdWithin(today()).list();
Assert.assertEquals(2, list.size());
Assert.assertEquals(4, list.size());
list = classificationService.createClassificationQuery().domainIn("domain1").validInDomainEquals(false).list();
Assert.assertEquals(0, list.size());
list = classificationService.createClassificationQuery()
.keyIn(classification1.getKey())
.list();
Assert.assertEquals(1, list.size());
Assert.assertEquals(2, list.size());
list = classificationService.createClassificationQuery()
.parentIdIn(classification.getId())

26
lib/taskana-core/src/test/resources/sql/classification.sql
View File

@ -1,18 +1,18 @@
-- ID, KEY, PARENT_ID, CATEGORY, TYPE, DOMAIN, VALID_IN_DOMAIN, CREATED, NAME, DESCRIPTION, PRIORITY, SERVICE_LEVEL, APPLICATION_ENTRY_POINT, CUSTOM_1 - 8
-- ROOT CLASSIFICATIONS
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000001', 'L10000', '', 'EXTERN', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'OLD-Leistungsfall', 'OLD-Leistungsfall', 999, 'P1D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000002', 'L10303', '', 'EXTERN', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'Beratungsprotokoll', 'Beratungsprotokoll', 1, 'P1D', '', 'VNR,RVNR,KOLVNR, ANR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000003', 'L1050', '', 'EXTERN', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'Widerruf', 'Widerruf', 1, 'P1D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000004', 'L11010', '', 'EXTERN', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'Dynamikänderung', 'Dynamikänderung', 1, 'P1D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000005', 'L110102', 'CLI:000000000000000000000000000000000004', 'EXTERN', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'Dynamik-Ablehnung', 'Dynamik-Ablehnung', 5, 'P5D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000006', 'L110105', 'CLI:000000000000000000000000000000000004', 'EXTERN', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'Dynamik-Ausschluss', 'Dynamik-Ausschluss', 5, 'P5D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000007', 'L110107', 'CLI:000000000000000000000000000000000004', 'EXTERN', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'Dynamik-Einschluss/Änd.', 'Dynamik-Einschluss/Änd.', 5, 'P5D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000008', 'L12010', '', 'EXTERN', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'Gewährung-Policendarlehen', 'Gewährung-Policendarlehen', 1, 'P1D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000009', 'L140101', '', 'EXTERN', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'Zustimmungserklärung', 'Zustimmungserklärung', 2, 'P2D', '', 'VNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000010', 'T2100', '', 'MANUAL', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'T-Vertragstermin VERA', 'T-Vertragstermin VERA', 2, 'P2D', '', 'VNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000011', 'T6310', '', 'AUTOMATIC', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'T-GUK Honorarrechnung erstellen', 'Generali Unterstützungskasse Honorar wird fällig', 2, 'P2D', '', 'VNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000013', 'DOCTYPE_DEFAULT', '', 'EXTERN', 'DOCUMENT', '', TRUE, CURRENT_TIMESTAMP, 'EP allgemein', 'EP allgemein', 99, 'P2000D', '', 'VNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000017', 'L1060', '', 'EXTERN', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'Widerruf neu', 'Widerruf neu', 1, 'P1D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000001', 'L10000', '', 'EXTERN', 'TASK', '', FALSE, CURRENT_TIMESTAMP, 'OLD-Leistungsfall', 'OLD-Leistungsfall', 999, 'P1D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000002', 'L10303', '', 'EXTERN', 'TASK', '', FALSE, CURRENT_TIMESTAMP, 'Beratungsprotokoll', 'Beratungsprotokoll', 1, 'P1D', '', 'VNR,RVNR,KOLVNR, ANR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000003', 'L1050', '', 'EXTERN', 'TASK', '', FALSE, CURRENT_TIMESTAMP, 'Widerruf', 'Widerruf', 1, 'P1D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000004', 'L11010', '', 'EXTERN', 'TASK', '', FALSE, CURRENT_TIMESTAMP, 'Dynamikänderung', 'Dynamikänderung', 1, 'P1D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000005', 'L110102', 'CLI:000000000000000000000000000000000004', 'EXTERN', 'TASK', '', FALSE, CURRENT_TIMESTAMP, 'Dynamik-Ablehnung', 'Dynamik-Ablehnung', 5, 'P5D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000006', 'L110105', 'CLI:000000000000000000000000000000000004', 'EXTERN', 'TASK', '', FALSE, CURRENT_TIMESTAMP, 'Dynamik-Ausschluss', 'Dynamik-Ausschluss', 5, 'P5D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000007', 'L110107', 'CLI:000000000000000000000000000000000004', 'EXTERN', 'TASK', '', FALSE, CURRENT_TIMESTAMP, 'Dynamik-Einschluss/Änd.', 'Dynamik-Einschluss/Änd.', 5, 'P5D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000008', 'L12010', '', 'EXTERN', 'TASK', '', FALSE, CURRENT_TIMESTAMP, 'Gewährung-Policendarlehen', 'Gewährung-Policendarlehen', 1, 'P1D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000009', 'L140101', '', 'EXTERN', 'TASK', '', FALSE, CURRENT_TIMESTAMP, 'Zustimmungserklärung', 'Zustimmungserklärung', 2, 'P2D', '', 'VNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000010', 'T2100', '', 'MANUAL', 'TASK', '', FALSE, CURRENT_TIMESTAMP, 'T-Vertragstermin VERA', 'T-Vertragstermin VERA', 2, 'P2D', '', 'VNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000011', 'T6310', '', 'AUTOMATIC', 'TASK', '', FALSE, CURRENT_TIMESTAMP, 'T-GUK Honorarrechnung erstellen', 'Generali Unterstützungskasse Honorar wird fällig', 2, 'P2D', '', 'VNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000013', 'DOCTYPE_DEFAULT', '', 'EXTERN', 'DOCUMENT', '', FALSE, CURRENT_TIMESTAMP, 'EP allgemein', 'EP allgemein', 99, 'P2000D', '', 'VNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000017', 'L1060', '', 'EXTERN', 'TASK', '', FALSE, CURRENT_TIMESTAMP, 'Widerruf neu', 'Widerruf neu', 1, 'P1D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
-- DOMAIN_A CLASSIFICATIONS
INSERT INTO CLASSIFICATION VALUES('CLI:100000000000000000000000000000000002', 'L10303', '', 'EXTERN', 'TASK', 'DOMAIN_A', TRUE, CURRENT_TIMESTAMP, 'Beratungsprotokoll', 'Beratungsprotokoll', 1, 'P1D', '', 'VNR,RVNR,KOLVNR, ANR', '', '', '', '', '', '', '');

24
rest/src/main/resources/sql/sample-data/classification.sql
View File

@ -1,17 +1,17 @@
-- ID, KEY, PARENT_ID, CATEGORY, TYPE, DOMAIN, VALID_IN_DOMAIN, CREATED, NAME, DESCRIPTION, PRIORITY, SERVICE_LEVEL, APPLICATION_ENTRY_POINT, CUSTOM_1 - 8
-- ROOT CLASSIFICATIONS
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000001', 'L10000', '', 'EXTERN', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'OLD-Leistungsfall', 'OLD-Leistungsfall', 999, 'P1D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000002', 'L10303', '', 'EXTERN', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'Beratungsprotokoll', 'Beratungsprotokoll', 1, 'P1D', '', 'VNR,RVNR,KOLVNR, ANR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000003', 'L1050', '', 'EXTERN', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'Widerruf', 'Widerruf', 1, 'P1D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000004', 'L11010', '', 'EXTERN', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'Dynamikänderung', 'Dynamikänderung', 1, 'P1D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000005', 'L110102', 'CLI:000000000000000000000000000000000004', 'EXTERN', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'Dynamik-Ablehnung', 'Dynamik-Ablehnung', 5, 'P5D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000006', 'L110105', 'CLI:000000000000000000000000000000000004', 'EXTERN', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'Dynamik-Ausschluss', 'Dynamik-Ausschluss', 5, 'P5D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000007', 'L110107', 'CLI:000000000000000000000000000000000004', 'EXTERN', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'Dynamik-Einschluss/Änd.', 'Dynamik-Einschluss/Änd.', 5, 'P5D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000008', 'L12010', '', 'EXTERN', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'Gewährung-Policendarlehen', 'Gewährung-Policendarlehen', 1, 'P1D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000009', 'L140101', '', 'EXTERN', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'Zustimmungserklärung', 'Zustimmungserklärung', 2, 'P2D', '', 'VNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000010', 'T2100', '', 'MANUAL', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'T-Vertragstermin VERA', 'T-Vertragstermin VERA', 2, 'P2D', '', 'VNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000011', 'T6310', '', 'AUTOMATIC', 'TASK', '', TRUE, CURRENT_TIMESTAMP, 'T-GUK Honorarrechnung erstellen', 'Generali Unterstützungskasse Honorar wird fällig', 2, 'P2D', '', 'VNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000013', 'DOCTYPE_DEFAULT', '', 'EXTERN', 'DOCUMENT', '', TRUE, CURRENT_TIMESTAMP, 'EP allgemein', 'EP allgemein', 99, 'P2000D', '', 'VNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000001', 'L10000', '', 'EXTERN', 'TASK', '', FALSE, CURRENT_TIMESTAMP, 'OLD-Leistungsfall', 'OLD-Leistungsfall', 999, 'P1D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000002', 'L10303', '', 'EXTERN', 'TASK', '', FALSE, CURRENT_TIMESTAMP, 'Beratungsprotokoll', 'Beratungsprotokoll', 1, 'P1D', '', 'VNR,RVNR,KOLVNR, ANR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000003', 'L1050', '', 'EXTERN', 'TASK', '', FALSE, CURRENT_TIMESTAMP, 'Widerruf', 'Widerruf', 1, 'P1D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000004', 'L11010', '', 'EXTERN', 'TASK', '', FALSE, CURRENT_TIMESTAMP, 'Dynamikänderung', 'Dynamikänderung', 1, 'P1D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000005', 'L110102', 'CLI:000000000000000000000000000000000004', 'EXTERN', 'TASK', '', FALSE, CURRENT_TIMESTAMP, 'Dynamik-Ablehnung', 'Dynamik-Ablehnung', 5, 'P5D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000006', 'L110105', 'CLI:000000000000000000000000000000000004', 'EXTERN', 'TASK', '', FALSE, CURRENT_TIMESTAMP, 'Dynamik-Ausschluss', 'Dynamik-Ausschluss', 5, 'P5D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000007', 'L110107', 'CLI:000000000000000000000000000000000004', 'EXTERN', 'TASK', '', FALSE, CURRENT_TIMESTAMP, 'Dynamik-Einschluss/Änd.', 'Dynamik-Einschluss/Änd.', 5, 'P5D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000008', 'L12010', '', 'EXTERN', 'TASK', '', FALSE, CURRENT_TIMESTAMP, 'Gewährung-Policendarlehen', 'Gewährung-Policendarlehen', 1, 'P1D', '', 'VNR,RVNR,KOLVNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000009', 'L140101', '', 'EXTERN', 'TASK', '', FALSE, CURRENT_TIMESTAMP, 'Zustimmungserklärung', 'Zustimmungserklärung', 2, 'P2D', '', 'VNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000010', 'T2100', '', 'MANUAL', 'TASK', '', FALSE, CURRENT_TIMESTAMP, 'T-Vertragstermin VERA', 'T-Vertragstermin VERA', 2, 'P2D', '', 'VNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000011', 'T6310', '', 'AUTOMATIC', 'TASK', '', FALSE, CURRENT_TIMESTAMP, 'T-GUK Honorarrechnung erstellen', 'Generali Unterstützungskasse Honorar wird fällig', 2, 'P2D', '', 'VNR', '', '', '', '', '', '', '');
INSERT INTO CLASSIFICATION VALUES('CLI:000000000000000000000000000000000013', 'DOCTYPE_DEFAULT', '', 'EXTERN', 'DOCUMENT', '', FALSE, CURRENT_TIMESTAMP, 'EP allgemein', 'EP allgemein', 99, 'P2000D', '', 'VNR', '', '', '', '', '', '', '');
-- DOMAIN_A CLASSIFICATIONS
INSERT INTO CLASSIFICATION VALUES('CLI:100000000000000000000000000000000002', 'L10303', '', 'EXTERN', 'TASK', 'DOMAIN_A', TRUE, CURRENT_TIMESTAMP, 'Beratungsprotokoll', 'Beratungsprotokoll', 1, 'P1D', '', 'VNR,RVNR,KOLVNR, ANR', '', '', '', '', '', '', '');