commit ada228d552610589599709bbdaa8b89586ae4b20 Author: LukasJuraczka Date: Mon Sep 22 14:58:41 2025 +0200 initial commit diff --git a/.mvn/wrapper/maven-wrapper.properties b/.mvn/wrapper/maven-wrapper.properties new file mode 100644 index 0000000..44f3cf2 --- /dev/null +++ b/.mvn/wrapper/maven-wrapper.properties @@ -0,0 +1,2 @@ +distributionType=only-script +distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.11/apache-maven-3.9.11-bin.zip diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..bdebaf5 --- /dev/null +++ b/pom.xml @@ -0,0 +1,123 @@ + + + 4.0.0 + + org.springframework.boot + spring-boot-starter-parent + 3.5.5 + + + + com.kapdion.omds + productdefinitions + 0.0.1-SNAPSHOT + + war + productdefinitions + productdefinitions + + + UTF-8 + UTF-8 + 21 + + 2025.27-PRODUKTE-SNAPSHOT + + + + + + at.vvo.omds + OMDSServiceDefinition + ${omds.version} + + + + org.springframework.boot + spring-boot-starter + + + ch.qos.logback + logback-classic + + + + + + org.springframework.boot + spring-boot-starter-web + + + ch.qos.logback + logback-classic + + + + + org.springframework.boot + spring-boot-devtools + runtime + true + + + org.springframework.boot + spring-boot-starter-test + test + + + + + + org.eclipse.rdf4j + rdf4j-model + 5.1.5 + + + + + org.eclipse.rdf4j + rdf4j-rio-turtle + 5.1.5 + + + + + org.eclipse.rdf4j + rdf4j-shacl + 5.1.5 + + + + org.eclipse.rdf4j + rdf4j-rio-jsonld + 5.1.5 + + + + org.projectlombok + lombok + true + + + + + RDFOMDSVertrasgverwaltung + + + + org.springframework.boot + spring-boot-maven-plugin + + + + org.projectlombok + lombok + + + + + + + + diff --git a/src/main/java/com/kapdion/omds/productdefinitions/EndpointsZentralesBOA.java b/src/main/java/com/kapdion/omds/productdefinitions/EndpointsZentralesBOA.java new file mode 100644 index 0000000..2f604c3 --- /dev/null +++ b/src/main/java/com/kapdion/omds/productdefinitions/EndpointsZentralesBOA.java @@ -0,0 +1,30 @@ +package com.kapdion.omds.productdefinitions; + +import at.vvo.omds.types.omds3.r2025_05.common.ProductsRequest; + +import com.kapdion.omds.productdefinitions.apriori.AprioriService; +import com.kapdion.omds.productdefinitions.calculate.CalculateService; +import org.springframework.web.bind.annotation.*; + +import javax.xml.datatype.DatatypeConfigurationException; +import java.io.IOException; + +@RestController +public class EndpointsZentralesBOA { + + @PostMapping("/ProductsRequest") + public String apriori(@RequestBody ProductsRequest productsRequest){ + AprioriService as = new AprioriService(); + String s = as.getProductsResponse(productsRequest); + System.out.println(s); + return s; + }; + + @PostMapping("/CalculateRequest") + public String calc(@RequestBody String calculateRequest) throws IOException, DatatypeConfigurationException { + CalculateService cs = new CalculateService(); + cs.buildResponse(calculateRequest); + return ""; + }; + +} diff --git a/src/main/java/com/kapdion/omds/productdefinitions/ServletInitializer.java b/src/main/java/com/kapdion/omds/productdefinitions/ServletInitializer.java new file mode 100644 index 0000000..4a610b3 --- /dev/null +++ b/src/main/java/com/kapdion/omds/productdefinitions/ServletInitializer.java @@ -0,0 +1,13 @@ +package com.kapdion.omds.productdefinitions; + +import org.springframework.boot.builder.SpringApplicationBuilder; +import org.springframework.boot.web.servlet.support.SpringBootServletInitializer; + +public class ServletInitializer extends SpringBootServletInitializer { + + @Override + protected SpringApplicationBuilder configure(SpringApplicationBuilder application) { + return application.sources(productdefinitionsApplication.class); + } + +} diff --git a/src/main/java/com/kapdion/omds/productdefinitions/apriori/AprioriService.java b/src/main/java/com/kapdion/omds/productdefinitions/apriori/AprioriService.java new file mode 100644 index 0000000..bfd9ce8 --- /dev/null +++ b/src/main/java/com/kapdion/omds/productdefinitions/apriori/AprioriService.java @@ -0,0 +1,79 @@ +package com.kapdion.omds.productdefinitions.apriori; + +import at.vvo.omds.types.omds3.r2025_05.common.ProductsRequest; + +import org.eclipse.rdf4j.model.Model; +import org.eclipse.rdf4j.model.impl.LinkedHashModel; +import org.eclipse.rdf4j.model.vocabulary.XSD; +import org.eclipse.rdf4j.query.GraphQuery; +import org.eclipse.rdf4j.query.GraphQueryResult; +import org.eclipse.rdf4j.repository.Repository; +import org.eclipse.rdf4j.repository.RepositoryConnection; +import org.eclipse.rdf4j.repository.sail.SailRepository; +import org.eclipse.rdf4j.rio.RDFFormat; +import org.eclipse.rdf4j.rio.Rio; +import org.eclipse.rdf4j.sail.memory.MemoryStore; + +import javax.xml.datatype.DatatypeConstants; +import javax.xml.datatype.DatatypeFactory; +import javax.xml.datatype.XMLGregorianCalendar; +import java.io.*; + +public class AprioriService { + + public String getProductsResponse(ProductsRequest productsRequest) { + Repository repo = new SailRepository(new MemoryStore()); + repo.init(); + + try (RepositoryConnection conn = repo.getConnection()) { + conn.add(new File("src/main/resources/data/prodelements.ttl"), RDFFormat.TURTLE); + + String queryString = """ + PREFIX vvo: + + CONSTRUCT { + ?prodelement vvo:ins_id ?ins_id ; + vvo:bez ?bez ; + vvo:created ?created ; + vvo:salesFrom ?salesfrom ; + vvo:salesTo ?salesto; + vvo:minOccurrence ?minOccurrence ; + vvo:maxOccurrence ?maxOccurrence ; + vvo:type ?type ; + vvo:risikoobjektType ?risikoobjektType . + } + WHERE { + ?prodelement a vvo:ProdElement . + OPTIONAL { ?prodelement vvo:ins_id ?ins_id . } + OPTIONAL { ?prodelement vvo:bez ?bez . } + OPTIONAL { ?prodelement vvo:created ?created . } + OPTIONAL { ?prodelement vvo:salesFrom ?salesfrom . } + OPTIONAL { ?prodelement vvo:salesTo ?salesto . } + OPTIONAL { ?prodelement vvo:minOccurrence ?minOccurrence . } + OPTIONAL { ?prodelement vvo:maxOccurrence ?maxOccurrence . } + OPTIONAL { ?prodelement vvo:type ?type . } + OPTIONAL { ?prodelement vvo:risikoobjektType ?risikoobjektType . } + FILTER ( ?salesfrom < ?stichtag && (!BOUND(?salesto) || ?salesto > ?stichtag) ) + } + + """; + + XMLGregorianCalendar stichtagFormated = DatatypeFactory.newInstance().newXMLGregorianCalendarDate(productsRequest.getStichtag().getYear(), productsRequest.getStichtag().getMonth(), productsRequest.getStichtag().getDay(), DatatypeConstants.FIELD_UNDEFINED); + + GraphQuery graphQuery = conn.prepareGraphQuery(queryString); + graphQuery.setBinding("stichtag", conn.getValueFactory().createLiteral(stichtagFormated.toXMLFormat(), XSD.DATE)); + + Model model = new LinkedHashModel(); + try (GraphQueryResult result = graphQuery.evaluate()) { + result.forEach(model::add); + } + + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + Rio.write(model, baos, RDFFormat.JSONLD); + return baos.toString(); + + } catch (Exception e) { + throw new RuntimeException(e); + } + } +} diff --git a/src/main/java/com/kapdion/omds/productdefinitions/calculate/CalculateService.java b/src/main/java/com/kapdion/omds/productdefinitions/calculate/CalculateService.java new file mode 100644 index 0000000..25a8cf3 --- /dev/null +++ b/src/main/java/com/kapdion/omds/productdefinitions/calculate/CalculateService.java @@ -0,0 +1,210 @@ +package com.kapdion.omds.productdefinitions.calculate; + +import at.vvo.omds.types.omds3.r2025_05.common.ProduktAllgemeinType; +import at.vvo.omds.types.omds3.r2025_05.common.ProduktbausteinType; +import at.vvo.omds.types.omds3.r2025_05.common.VerkaufsproduktAllgemeinType; +import at.vvo.omds.types.omds3.r2025_05.common.VerkaufsproduktType; +import org.eclipse.rdf4j.model.*; +import org.eclipse.rdf4j.model.impl.SimpleValueFactory; +import org.eclipse.rdf4j.model.impl.TreeModel; +import org.eclipse.rdf4j.model.util.Models; +import org.eclipse.rdf4j.rio.RDFFormat; +import org.eclipse.rdf4j.rio.Rio; + +import javax.xml.datatype.DatatypeConfigurationException; +import javax.xml.datatype.DatatypeFactory; +import javax.xml.datatype.XMLGregorianCalendar; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.StringReader; + +import static org.eclipse.rdf4j.model.util.Values.iri; + +public class CalculateService { + public String buildResponse(String calculateRequest) throws IOException, DatatypeConfigurationException { + VerkaufsproduktType vp = calculateRequestToVerkaufsprodukt(calculateRequest); + + System.out.println("vp: " + vp.getBezeichnung()); + for (ProduktbausteinType unterbaustein : vp.getBausteine()){ + System.out.println("unterbaustein: " + unterbaustein.getBezeichnung()); + } + validateRequest(vp); + calculate(); + + Model response = createRdfModel(vp); + + + ByteArrayOutputStream baos = new ByteArrayOutputStream(); +// Rio.write(response, baos, RDFFormat.JSONLD); +// return baos.toString(); + return ""; + } + + private VerkaufsproduktType calculateRequestToVerkaufsprodukt(String calculateRequest) throws IOException, DatatypeConfigurationException { + Model model = Rio.parse(new StringReader(calculateRequest), "", RDFFormat.JSONLD); + + + + VerkaufsproduktType verkaufsproduktType = new VerkaufsproduktAllgemeinType(); + + for (Resource iri : Models.subjectIRIs(model)) { + + System.out.println(iri.stringValue()); + ValueFactory vf = SimpleValueFactory.getInstance(); + + + int insId = Integer.parseInt(Models.objectLiteral(model.filter(iri, vf.createIRI( + "http://vvo.pisanoapi.at/ins_id"), null)).map(Literal::getLabel).orElse("-1")); + int maxOccurrence = Integer.parseInt(Models.objectLiteral(model.filter(iri, vf.createIRI( + "http://vvo.pisanoapi.at/maxOccurrence"), null)).map(Literal::getLabel).orElse("-1")); + int minOccurrence = Integer.parseInt(Models.objectLiteral(model.filter(iri, vf.createIRI( + "http://vvo.pisanoapi.at/minOccurrence"), null)).map(Literal::getLabel).orElse("-1")); + String bez = Models.objectLiteral(model.filter(iri, vf.createIRI( + "http://vvo.pisanoapi.at/bez"), null)).map(Literal::getLabel).orElse(null); + String type = Models.objectLiteral(model.filter(iri, vf.createIRI( + "http://vvo.pisanoapi.at/type"), null)).map(Literal::getLabel).orElse(null); + String risikoobjektType = Models.objectLiteral(model.filter(iri, vf.createIRI( + "http://vvo.pisanoapi.at/risikoobjektType"), null)).map(Literal::getLabel).orElse(null); + XMLGregorianCalendar verkaufsoffenVon = Models.objectLiteral(model.filter(iri, vf.createIRI( + "http://vvo.pisanoapi.at/salesFrom"), null)).map(Literal::getLabel).isPresent() ? DatatypeFactory.newInstance().newXMLGregorianCalendar( + Models.objectLiteral(model.filter(iri, vf.createIRI( + "http://vvo.pisanoapi.at/salesFrom"), null)).map(Literal::getLabel).orElse(null)) : null ; + XMLGregorianCalendar verkaufsoffenBis = Models.objectLiteral(model.filter(iri, vf.createIRI( + "http://vvo.pisanoapi.at/salesTo"), null)).map(Literal::getLabel).isPresent() ? DatatypeFactory.newInstance().newXMLGregorianCalendar( + Models.objectLiteral(model.filter(iri, vf.createIRI( + "http://vvo.pisanoapi.at/salesTo"), null)).map(Literal::getLabel).orElse(null)) : null; + + + for (Resource unterbaustein : Models.objectResources(model.filter(iri, vf.createIRI("http://vvo.pisanoapi.at/baustein"), null))){ + ProduktbausteinType baustein = calculateRequestToUnterbaustein(model, unterbaustein); + verkaufsproduktType.getBausteine().add(baustein); + } + + verkaufsproduktType.setId(iri.stringValue().substring(iri.stringValue().length() - 1)); + verkaufsproduktType.setBezeichnung(bez); + verkaufsproduktType.setTyp(type); + verkaufsproduktType.setVerkaufsoffenVon(verkaufsoffenVon); + verkaufsproduktType.setVerkaufsoffenBis(verkaufsoffenBis); + verkaufsproduktType.setMaxVorkommen(maxOccurrence); + verkaufsproduktType.setMinVorkommen(minOccurrence); + verkaufsproduktType.setRisikoobjektErforderlich(risikoobjektType != null); + + break; + } + + return verkaufsproduktType; + } + + private ProduktbausteinType calculateRequestToUnterbaustein(Model model, Resource iriUnterbaustein) throws IOException, DatatypeConfigurationException { + ProduktbausteinType produktbausteinType = new ProduktAllgemeinType(); + + for (Resource iri : Models.subjectIRIs(model)) { + if (iri.equals(iriUnterbaustein)) { + + + System.out.println(iri.stringValue()); + ValueFactory vf = SimpleValueFactory.getInstance(); + + + int insId = Integer.parseInt(Models.objectLiteral(model.filter(iri, vf.createIRI( + "http://vvo.pisanoapi.at/ins_id"), null)).map(Literal::getLabel).orElse("-1")); + int maxOccurrence = Integer.parseInt(Models.objectLiteral(model.filter(iri, vf.createIRI( + "http://vvo.pisanoapi.at/maxOccurrence"), null)).map(Literal::getLabel).orElse("-1")); + int minOccurrence = Integer.parseInt(Models.objectLiteral(model.filter(iri, vf.createIRI( + "http://vvo.pisanoapi.at/minOccurrence"), null)).map(Literal::getLabel).orElse("-1")); + String bez = Models.objectLiteral(model.filter(iri, vf.createIRI( + "http://vvo.pisanoapi.at/bez"), null)).map(Literal::getLabel).orElse(null); + String type = Models.objectLiteral(model.filter(iri, vf.createIRI( + "http://vvo.pisanoapi.at/type"), null)).map(Literal::getLabel).orElse(null); + String risikoobjektType = Models.objectLiteral(model.filter(iri, vf.createIRI( + "http://vvo.pisanoapi.at/risikoobjektType"), null)).map(Literal::getLabel).orElse(null); + XMLGregorianCalendar verkaufsoffenVon = Models.objectLiteral(model.filter(iri, vf.createIRI( + "http://vvo.pisanoapi.at/salesFrom"), null)).map(Literal::getLabel).isPresent() ? DatatypeFactory.newInstance().newXMLGregorianCalendar( + Models.objectLiteral(model.filter(iri, vf.createIRI( + "http://vvo.pisanoapi.at/salesFrom"), null)).map(Literal::getLabel).orElse(null)) : null; + XMLGregorianCalendar verkaufsoffenBis = Models.objectLiteral(model.filter(iri, vf.createIRI( + "http://vvo.pisanoapi.at/salesTo"), null)).map(Literal::getLabel).isPresent() ? DatatypeFactory.newInstance().newXMLGregorianCalendar( + Models.objectLiteral(model.filter(iri, vf.createIRI( + "http://vvo.pisanoapi.at/salesTo"), null)).map(Literal::getLabel).orElse(null)) : null; + + + for (Value unterbaustein : Models.objectResources(model.filter(iri, vf.createIRI("http://vvo.pisanoapi.at/baustein"), null))) { + ProduktbausteinType baustein = calculateRequestToVerkaufsprodukt(unterbaustein.stringValue()); + produktbausteinType.getBausteine().add(baustein); + } + + produktbausteinType.setId(iri.stringValue().substring(iri.stringValue().length() - 1)); + produktbausteinType.setBezeichnung(bez); + produktbausteinType.setTyp(type); + produktbausteinType.setVerkaufsoffenVon(verkaufsoffenVon); + produktbausteinType.setVerkaufsoffenBis(verkaufsoffenBis); + produktbausteinType.setMaxVorkommen(maxOccurrence); + produktbausteinType.setMinVorkommen(minOccurrence); + produktbausteinType.setRisikoobjektErforderlich(risikoobjektType != null); + + break; + } + } + + return produktbausteinType; + } + + //Prüfen, ob sie zu den Werten im Verkaufsprodukt passen. + //Prüfe VuNr exestiert + //Prüfe Verkaufsprodukt verkaufsoffen + //Prüfe auf risikoobjekt fehler + //Wenn Unterbausteine angegeben sind, dann prüfen, ob sie a priori zulässig sind. + //Ergänzen fehlender Bausteine + private void validateRequest(VerkaufsproduktType vp) throws IOException { +// pruefeVUNr(calculateRequest.getVUNr()); + pruefeVerkaufsoffen(vp); + pruefeWerte(vp); + pruefeRisikoobjekt(vp); + pruefeErgaentzungen(vp); + } + + private void pruefeWerte(VerkaufsproduktType verkaufsprodukt) { + } + + private void pruefeErgaentzungen(VerkaufsproduktType verkaufsprodukt) { + } + + private void pruefeRisikoobjekt(VerkaufsproduktType verkaufsprodukt) { + } + + private void pruefeVerkaufsoffen(VerkaufsproduktType verkaufsprodukt) { + } + + private void pruefeVUNr(String vuNr) { + } + + private Model createRdfModel(VerkaufsproduktType vp) { + Model erg = new TreeModel(); + + String baseIri = "http://vvo.pisanoapi.at/"; + + IRI prodelemIri = iri(baseIri + "ProdElement"); + IRI insIdIri = iri(baseIri + "ins_id"); + IRI bezIri = iri(baseIri + "bez"); + IRI createdIri = iri(baseIri + "created"); + IRI salesFromIri = iri(baseIri + "salesFrom"); + IRI salesToIri = iri(baseIri + "salesTo"); + IRI minOccurrenceIri = iri(baseIri + "minOccurrence"); + IRI maxOccurrenceIri = iri(baseIri + "maxOccurrence"); + IRI typeIri = iri(baseIri + "type"); + IRI risikoobjektTypeIri = iri(baseIri + "risikoobjektType"); + IRI bausteinIri = iri(baseIri + "baustein"); + + IRI vpIri = iri(baseIri + "ProdElement" + vp.getId()); + + +// erg.add() + + + + return null; + } + + private void calculate() { + } +} diff --git a/src/main/java/com/kapdion/omds/productdefinitions/productdefinitionsApplication.java b/src/main/java/com/kapdion/omds/productdefinitions/productdefinitionsApplication.java new file mode 100644 index 0000000..cbdeff3 --- /dev/null +++ b/src/main/java/com/kapdion/omds/productdefinitions/productdefinitionsApplication.java @@ -0,0 +1,15 @@ +package com.kapdion.omds.productdefinitions; + +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.boot.context.properties.ConfigurationPropertiesScan; + +@ConfigurationPropertiesScan +@SpringBootApplication +public class productdefinitionsApplication { + + public static void main(String[] args) { + SpringApplication.run(productdefinitionsApplication.class, args); + } + +} diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties new file mode 100644 index 0000000..44ae67b --- /dev/null +++ b/src/main/resources/application.properties @@ -0,0 +1,2 @@ +spring.application.name=productdefinitions +server.port=9090 diff --git a/src/main/resources/banner.txt b/src/main/resources/banner.txt new file mode 100644 index 0000000..725a4c1 --- /dev/null +++ b/src/main/resources/banner.txt @@ -0,0 +1,14 @@ + +======================================================================== +| | +| | +| ____ __ _______ _____ _____ | +| / __ \/ |/ / __ \/ ___/ / ___/___ ______ _____ _____ | +| / / / / /|_/ / / / /\__ \ \__ \/ _ \/ ___/ | / / _ \/ ___/ | +| / /_/ / / / / /_/ /___/ / ___/ / __/ / | |/ / __/ / | +| \____/_/ /_/_____//____/ /____/\___/_/ |___/\___/_/ | +| | +| | +| OMDS Demo Server | +| (c) 2025 Kap Dion GmbH | +======================================================================== diff --git a/src/main/resources/data/prodelements.ttl b/src/main/resources/data/prodelements.ttl new file mode 100644 index 0000000..5c61561 --- /dev/null +++ b/src/main/resources/data/prodelements.ttl @@ -0,0 +1,260 @@ +@prefix rdf: . +@prefix rdfs: . +@prefix vvo: . +@prefix xsd: . + + +vvo:ProdElement1 a vvo:ProdElement ; + vvo:ins_id 1 ; + vvo:bez "Kraftfahrt 2020" ; + vvo:created "2020-01-01T23:59:59.999999"^^xsd:dateTime ; + vvo:salesFrom "2020-01-01"^^xsd:date ; + vvo:salesTo "2021-03-31"^^xsd:date ; + vvo:minOccurrence 1 ; + vvo:maxOccurrence 1 ; + vvo:type "at.vvo.omds.types.omds3.r2025_05.on2antrag.kfz.VerkaufsproduktKfzType" ; + vvo:risikoobjektType "FahrzeugType" . + +vvo:ProdElement2 a vvo:ProdElement ; + vvo:ins_id 1 ; + vvo:bez "Haftpflicht 2020" ; + vvo:created "2020-01-01T23:59:59.999999"^^xsd:dateTime ; + vvo:salesFrom "2020-01-01"^^xsd:date ; + vvo:salesTo "2021-03-31"^^xsd:date ; + vvo:parent vvo:ProdElement1 ; + vvo:minOccurrence 1 ; + vvo:maxOccurrence 1 ; + vvo:type "at.vvo.omds.types.omds3.r2025_05.on2antrag.kfz.HaftpflichtKfzType" . + +vvo:ProdElement3 a vvo:ProdElement ; + vvo:ins_id 1 ; + vvo:bez "Kasko 2020" ; + vvo:created "2020-01-01T23:59:59.999999"^^xsd:dateTime ; + vvo:salesFrom "2020-01-01"^^xsd:date ; + vvo:salesTo "2021-03-31"^^xsd:date ; + vvo:parent vvo:ProdElement1 ; + vvo:minOccurrence 1 ; + vvo:maxOccurrence 1 ; + vvo:type "at.vvo.omds.types.omds3.r2025_05.on2antrag.kfz.VollkaskoKfzType" . + +vvo:ProdElement4 a vvo:ProdElement ; + vvo:ins_id 1 ; + vvo:bez "Insassenunfall 2020" ; + vvo:created "2020-01-01T23:59:59.999999"^^xsd:dateTime ; + vvo:salesFrom "2020-01-01"^^xsd:date ; + vvo:salesTo "2021-03-31"^^xsd:date ; + vvo:parent vvo:ProdElement1 ; + vvo:minOccurrence 1 ; + vvo:maxOccurrence 1 ; + vvo:type "at.vvo.omds.types.omds3.r2025_05.on2antrag.kfz.InsassenUnfallKfzType" . + +vvo:ProdElement5 a vvo:ProdElement ; + vvo:ins_id 1 ; + vvo:bez "Kraftfahrt 2021" ; + vvo:created "2020-01-01T23:59:59.999999"^^xsd:dateTime ; + vvo:salesFrom "2021-01-01"^^xsd:date ; + vvo:salesTo "2021-03-31"^^xsd:date ; + vvo:previous vvo:ProdElement1 ; + vvo:minOccurrence 1 ; + vvo:maxOccurrence 1 ; + vvo:type "at.vvo.omds.types.omds3.r2025_05.on2antrag.kfz.VerkaufsproduktKfzType" ; + vvo:risikoobjektType "FahrzeugType" . + +vvo:ProdElement6 a vvo:ProdElement ; + vvo:ins_id 1 ; + vvo:bez "Haftpflicht 2021" ; + vvo:created "2020-01-01T23:59:59.999999"^^xsd:dateTime ; + vvo:salesFrom "2021-01-01"^^xsd:date ; + vvo:salesTo "2021-03-31"^^xsd:date ; + vvo:parent vvo:ProdElement5 ; + vvo:previous vvo:ProdElement2 ; + vvo:minOccurrence 1 ; + vvo:maxOccurrence 1 ; + vvo:type "at.vvo.omds.types.omds3.r2025_05.on2antrag.kfz.HaftpflichtKfzType" . + +vvo:ProdElement7 a vvo:ProdElement ; + vvo:ins_id 1 ; + vvo:bez "Kasko 2021" ; + vvo:created "2020-01-01T23:59:59.999999"^^xsd:dateTime ; + vvo:salesFrom "2021-01-01"^^xsd:date ; + vvo:salesTo "2021-03-31"^^xsd:date ; + vvo:parent vvo:ProdElement5 ; + vvo:previous vvo:ProdElement3 ; + vvo:minOccurrence 1 ; + vvo:maxOccurrence 1 ; + vvo:type "at.vvo.omds.types.omds3.r2025_05.on2antrag.kfz.VollkaskoKfzType" . + +vvo:ProdElement8 a vvo:ProdElement ; + vvo:ins_id 1 ; + vvo:bez "Insassenunfall 2021" ; + vvo:created "2020-01-01T23:59:59.999999"^^xsd:dateTime ; + vvo:salesFrom "2021-01-01"^^xsd:date ; + vvo:salesTo "2021-03-31"^^xsd:date ; + vvo:parent vvo:ProdElement5 ; + vvo:previous vvo:ProdElement4 ; + vvo:minOccurrence 1 ; + vvo:maxOccurrence 1 ; + vvo:type "at.vvo.omds.types.omds3.r2025_05.on2antrag.kfz.InsassenUnfallKfzType" . + +vvo:ProdElement9 a vvo:ProdElement ; + vvo:ins_id 1 ; + vvo:bez "Assistance 2021" ; + vvo:created "2020-01-01T23:59:59.999999"^^xsd:dateTime ; + vvo:salesFrom "2021-01-01"^^xsd:date ; + vvo:salesTo "2021-03-31"^^xsd:date ; + vvo:parent vvo:ProdElement5 ; + vvo:minOccurrence 1 ; + vvo:maxOccurrence 1 ; + vvo:type "at.vvo.omds.types.omds3.r2025_05.on2antrag.kfz.AssistanceKfzType" . + +vvo:ProdElement10 a vvo:ProdElement ; + vvo:ins_id 1 ; + vvo:bez "Kraftfahrt 2022" ; + vvo:created "2020-01-01T23:59:59.999999"^^xsd:dateTime ; + vvo:salesFrom "2022-01-01"^^xsd:date ; + vvo:previous vvo:ProdElement5 ; + vvo:minOccurrence 1 ; + vvo:maxOccurrence 1 ; + vvo:type "at.vvo.omds.types.omds3.r2025_05.on2antrag.kfz.VerkaufsproduktKfzType" ; + vvo:risikoobjektType "FahrzeugType" . + +vvo:ProdElement11 a vvo:ProdElement ; + vvo:ins_id 1 ; + vvo:bez "Haftpflicht 2022" ; + vvo:created "2020-01-01T23:59:59.999999"^^xsd:dateTime ; + vvo:salesFrom "2022-01-01"^^xsd:date ; + vvo:parent vvo:ProdElement10 ; + vvo:previous vvo:ProdElement6 ; + vvo:minOccurrence 1 ; + vvo:maxOccurrence 1 ; + vvo:type "at.vvo.omds.types.omds3.r2025_05.on2antrag.kfz.HaftpflichtKfzType" . + +vvo:ProdElement12 a vvo:ProdElement ; + vvo:ins_id 1 ; + vvo:bez "Kasko 2022" ; + vvo:created "2020-01-01T23:59:59.999999"^^xsd:dateTime ; + vvo:salesFrom "2022-01-01"^^xsd:date ; + vvo:parent vvo:ProdElement10 ; + vvo:previous vvo:ProdElement7 ; + vvo:minOccurrence 1 ; + vvo:maxOccurrence 1 ; + vvo:type "at.vvo.omds.types.omds3.r2025_05.on2antrag.kfz.VollkaskoKfzType" . + +vvo:ProdElement13 a vvo:ProdElement ; + vvo:ins_id 1 ; + vvo:bez "Assistance 2022" ; + vvo:created "2020-01-01T23:59:59.999999"^^xsd:dateTime ; + vvo:salesFrom "2022-01-01"^^xsd:date ; + vvo:parent vvo:ProdElement10 ; + vvo:previous vvo:ProdElement9 ; + vvo:minOccurrence 1 ; + vvo:maxOccurrence 1 ; + vvo:type "at.vvo.omds.types.omds3.r2025_05.on2antrag.kfz.AssistanceKfzType" . + +vvo:ProdElement14 a vvo:ProdElement ; + vvo:ins_id 1 ; + vvo:bez "Kasko Unterbaustein 2022" ; + vvo:created "2020-01-01T23:59:59.999999"^^xsd:dateTime ; + vvo:salesFrom "2022-01-01"^^xsd:date ; + vvo:parent vvo:ProdElement12 ; + vvo:minOccurrence 1 ; + vvo:maxOccurrence 1 ; + vvo:type "at.vvo.omds.types.omds3.r2025_05.on2antrag.kfz.VollkaskoKfzType" ; + vvo:risikoobjektType "FahrzeugType" . + +vvo:ProdElement15 a vvo:ProdElement ; + vvo:ins_id 1 ; + vvo:bez "Kasko Unterunterbaustein 1 2022" ; + vvo:created "2020-01-01T23:59:59.999999"^^xsd:dateTime ; + vvo:salesFrom "2022-01-01"^^xsd:date ; + vvo:parent vvo:ProdElement14 ; + vvo:minOccurrence 1 ; + vvo:maxOccurrence 1 ; + vvo:type "at.vvo.omds.types.omds3.r2025_05.on2antrag.kfz.VollkaskoKfzType" . + +vvo:ProdElement16 a vvo:ProdElement ; + vvo:ins_id 1 ; + vvo:bez "Kasko Unterunterbaustein 2 2022" ; + vvo:created "2020-01-01T23:59:59.999999"^^xsd:dateTime ; + vvo:salesFrom "2022-01-01"^^xsd:date ; + vvo:parent vvo:ProdElement14 ; + vvo:minOccurrence 1 ; + vvo:maxOccurrence 1 ; + vvo:type "at.vvo.omds.types.omds3.r2025_05.on2antrag.kfz.TeilkaskoKfzType" . + +vvo:ProdElement17 a vvo:ProdElement ; + vvo:ins_id 1 ; + vvo:bez "Kraftfahrt 2022-2" ; + vvo:created "2020-01-01T23:59:59.999999"^^xsd:dateTime ; + vvo:salesFrom "2022-01-01"^^xsd:date ; + vvo:previous vvo:ProdElement5 ; + vvo:minOccurrence 1 ; + vvo:maxOccurrence 1 ; + vvo:type "at.vvo.omds.types.omds3.r2025_05.on2antrag.kfz.VerkaufsproduktKfzType" ; + vvo:risikoobjektType "FahrzeugType" . + +vvo:ElemBoolean1 a vvo:ElemBoolean ; + vvo:bez "TestBooleanElement1" ; + vvo:ProdElement vvo:ProdElement11 ; + vvo:required "true"^^xsd:boolean ; + vvo:default "true"^^xsd:boolean . + +vvo:ElemBoolean2 a vvo:ElemBoolean ; + vvo:bez "TestBooleanElement2" ; + vvo:ProdElement vvo:ProdElement12 ; + vvo:required "true"^^xsd:boolean ; + vvo:default "false"^^xsd:boolean . + +vvo:ElemBoolean3 a vvo:ElemBoolean ; + vvo:bez "TestBooleanElement3" ; + vvo:ProdElement vvo:ProdElement12 ; + vvo:required "false"^^xsd:boolean ; + vvo:default "false"^^xsd:boolean . + +vvo:ElemInt1 a vvo:ElemInt ; + vvo:bez "AnzSitzplaetze" ; + vvo:ProdElement vvo:ProdElement11 ; + vvo:required "true"^^xsd:boolean ; + vvo:max 11 ; + vvo:min 2 ; + vvo:default 5 . + +vvo:ElemDecimal1 a vvo:ElemDecimal ; + vvo:bez "Versicherungssumme" ; + vvo:ProdElement vvo:ProdElement11 ; + vvo:required "true"^^xsd:boolean ; + vvo:max "10000"^^xsd:decimal ; + vvo:min "10"^^xsd:decimal . + +vvo:ElemDecimal2 a vvo:ElemDecimal ; + vvo:bez "Selbstbehalt" ; + vvo:ProdElement vvo:ProdElement11 ; + vvo:required "true"^^xsd:boolean ; + vvo:max "10000.0"^^xsd:decimal ; + vvo:min "10"^^xsd:decimal; + vvo:default "100"^^xsd:decimal . + +vvo:ElemDecimal3 a vvo:ElemDecimal ; + vvo:bez "Wert" ; + vvo:ProdElement vvo:ProdElement12 ; + vvo:required "true"^^xsd:boolean ; + vvo:max "50000"^^xsd:decimal ; + vvo:min "1000"^^xsd:decimal . + +vvo:ElemString1 a vvo:ElemString ; + vvo:bez "TestStringElement1" ; + vvo:ProdElement vvo:ProdElement11 ; + vvo:required "true"^^xsd:boolean ; + vvo:default "TestStringDefaultValue1" . + +vvo:ElemString2 a vvo:ElemString ; + vvo:bez "TestStringElement2" ; + vvo:ProdElement vvo:ProdElement12 ; + vvo:required "false"^^xsd:boolean ; + vvo:default "TestStringDefaultValue2" . + +vvo:ElemString3 a vvo:ElemString ; + vvo:bez "TestStringElement3" ; + vvo:ProdElement vvo:ProdElement11 ; + vvo:required "false"^^xsd:boolean ; + vvo:default "TestStringDefaultValue3" . diff --git a/src/test/java/com/kapdion/omds/productdefinitions/productdefinitionsApplicationTests.java b/src/test/java/com/kapdion/omds/productdefinitions/productdefinitionsApplicationTests.java new file mode 100644 index 0000000..9751dd1 --- /dev/null +++ b/src/test/java/com/kapdion/omds/productdefinitions/productdefinitionsApplicationTests.java @@ -0,0 +1,13 @@ +package com.kapdion.omds.productdefinitions; + +import org.junit.jupiter.api.Test; +import org.springframework.boot.test.context.SpringBootTest; + +@SpringBootTest +class productdefinitionsApplicationTests { + + @Test + void contextLoads() { + } + +}