diff --git a/Jenkinsfile b/Jenkinsfile
index 13a8ec027e00c9f9177d830ffe6a467074fd33c6..2d2b8428ddba5668d101555dc3aae8ca1a19c026 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -144,6 +144,11 @@ pipeline {
sh 'mvn --no-transfer-progress -s $MAVEN_SETTINGS sonar:sonar'
}
}
+ dir('alfa-xdomea'){
+ withSonarQubeEnv('sonarqube-ozg-sh'){
+ sh 'mvn --no-transfer-progress -s $MAVEN_SETTINGS sonar:sonar'
+ }
+ }
}
catch (Exception e) {
unstable("SonarQube failed")
diff --git a/alfa-server/pom.xml b/alfa-server/pom.xml
index 395a93395a2c9011c8e0c5f17ce437fced4d31a8..5e51365a7d41f0fcd9ef379a087e14e8dfc61a90 100644
--- a/alfa-server/pom.xml
+++ b/alfa-server/pom.xml
@@ -24,6 +24,11 @@
<artifactId>alfa-service</artifactId>
<version>${project.version}</version>
</dependency>
+ <dependency>
+ <groupId>de.ozgcloud.alfa</groupId>
+ <artifactId>alfa-xdomea</artifactId>
+ <version>${project.version}</version>
+ </dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
diff --git a/alfa-server/src/main/resources/application-local.yml b/alfa-server/src/main/resources/application-local.yml
index 55772b0d1f753624c45b82c5f343f689cdf96eb7..1dd7f05bdf4e5d54519327679cc70546b1ec6edb 100644
--- a/alfa-server/src/main/resources/application-local.yml
+++ b/alfa-server/src/main/resources/application-local.yml
@@ -16,8 +16,6 @@ grpc:
negotiationType: PLAINTEXT
zufi-manager:
negotiationType: PLAINTEXT
- archive-manager:
- negotiationType: PLAINTEXT
ozgcloud:
feature:
diff --git a/alfa-server/src/main/resources/application.yml b/alfa-server/src/main/resources/application.yml
index aaf3f0290c0eb6de18d5e6e208c4b7886e463486..f5642fefecceda5c3f88a333ad14c835c5394bc1 100644
--- a/alfa-server/src/main/resources/application.yml
+++ b/alfa-server/src/main/resources/application.yml
@@ -66,9 +66,6 @@ grpc:
zufi-manager:
address: static://127.0.0.1:9190
negotiationType: TLS
- archive-manager:
- address: static://127.0.0.1:9090
- negotiationType: TLS
ozgcloud:
auth:
diff --git a/alfa-service/pom.xml b/alfa-service/pom.xml
index 544b215e4e6c71ebf477ae61bdccbed75fa89f4b..1065a01112aada11a850d06625ae570b63e78207 100644
--- a/alfa-service/pom.xml
+++ b/alfa-service/pom.xml
@@ -135,10 +135,6 @@
<groupId>de.ozgcloud.zufi</groupId>
<artifactId>zufi-manager-interface</artifactId>
</dependency>
- <dependency>
- <groupId>de.ozgcloud.archive</groupId>
- <artifactId>archive-manager-interface</artifactId>
- </dependency>
<!-- tools -->
<dependency>
diff --git a/alfa-service/src/main/java/de/ozgcloud/alfa/common/GrpcUtil.java b/alfa-service/src/main/java/de/ozgcloud/alfa/common/GrpcUtil.java
index 610a0cc4324df0ed3d3a7bd110b4a13b2b7ebfe3..fc033f658d18ce1a5726b631e32ab7b591c5817f 100644
--- a/alfa-service/src/main/java/de/ozgcloud/alfa/common/GrpcUtil.java
+++ b/alfa-service/src/main/java/de/ozgcloud/alfa/common/GrpcUtil.java
@@ -40,8 +40,6 @@ public class GrpcUtil {
public static final String ZUFI_MANAGER_GRPC_CLIENT = "zufi-manager";
- public static final String ARCHIVE_MANAGER_GRPC_CLIENT = "archive-manager";
-
public static final String SERVICE_KEY = "GRPC_SERVICE";
public static Key<String> keyOfString(String key) {
diff --git a/alfa-service/src/main/java/de/ozgcloud/alfa/export/ExportRemoteService.java b/alfa-service/src/main/java/de/ozgcloud/alfa/export/ExportRemoteService.java
deleted file mode 100644
index a4c82201787069c1c46f7f8d265181feef7230de..0000000000000000000000000000000000000000
--- a/alfa-service/src/main/java/de/ozgcloud/alfa/export/ExportRemoteService.java
+++ /dev/null
@@ -1,20 +0,0 @@
-package de.ozgcloud.alfa.export;
-
-import org.springframework.stereotype.Service;
-
-import de.ozgcloud.alfa.common.GrpcUtil;
-import de.ozgcloud.archive.grpc.export.ExportServiceGrpc.ExportServiceBlockingStub;
-import de.ozgcloud.archive.grpc.export.GrpcExportVorgangRequest;
-import net.devh.boot.grpc.client.inject.GrpcClient;
-
-@Service
-class ExportRemoteService {
-
- @GrpcClient(GrpcUtil.ARCHIVE_MANAGER_GRPC_CLIENT)
- private ExportServiceBlockingStub exportServiceStub;
-
- public ExportedVorgangFile exportVorgang(String vorgangId) {
- var responseIterator = exportServiceStub.exportVorgang(GrpcExportVorgangRequest.newBuilder().setVorgangId(vorgangId).build());
- return new StreamedExportedVorgangFile(responseIterator);
- }
-}
diff --git a/alfa-service/src/main/java/de/ozgcloud/alfa/export/ExportedVorgangFile.java b/alfa-service/src/main/java/de/ozgcloud/alfa/export/ExportedVorgangFile.java
deleted file mode 100644
index e778a5a905885776809922c99ca8c27a5f595f92..0000000000000000000000000000000000000000
--- a/alfa-service/src/main/java/de/ozgcloud/alfa/export/ExportedVorgangFile.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package de.ozgcloud.alfa.export;
-
-import java.io.IOException;
-import java.io.OutputStream;
-
-interface ExportedVorgangFile {
-
- String getFileName();
-
- void writeToOutputStream(OutputStream outputStream) throws IOException;
-}
diff --git a/alfa-service/src/main/java/de/ozgcloud/alfa/export/StreamedExportedVorgangFile.java b/alfa-service/src/main/java/de/ozgcloud/alfa/export/StreamedExportedVorgangFile.java
deleted file mode 100644
index 4e87099e63b8e3c896b37f8ddf3728b3f2a1dbda..0000000000000000000000000000000000000000
--- a/alfa-service/src/main/java/de/ozgcloud/alfa/export/StreamedExportedVorgangFile.java
+++ /dev/null
@@ -1,35 +0,0 @@
-package de.ozgcloud.alfa.export;
-
-import java.io.IOException;
-import java.io.OutputStream;
-import java.util.Iterator;
-
-import de.ozgcloud.archive.grpc.export.GrpcExportVorgangResponse;
-import de.ozgcloud.common.errorhandling.TechnicalException;
-import lombok.Getter;
-
-class StreamedExportedVorgangFile implements ExportedVorgangFile {
-
- @Getter
- private final String fileName;
- private final Iterator<GrpcExportVorgangResponse> responseIterator;
-
- public StreamedExportedVorgangFile(Iterator<GrpcExportVorgangResponse> responseIterator) {
- this.fileName = getFileNameFrom(responseIterator);
- this.responseIterator = responseIterator;
- }
-
- static String getFileNameFrom(Iterator<GrpcExportVorgangResponse> responseIterator) {
- if (!responseIterator.hasNext()) {
- throw new TechnicalException("Response is empty");
- }
- return responseIterator.next().getVorgangFile().getFileName();
- }
-
- @Override
- public void writeToOutputStream(OutputStream outputStream) throws IOException {
- while (responseIterator.hasNext()) {
- outputStream.write(responseIterator.next().getVorgangFile().getFileContent().toByteArray());
- }
- }
-}
diff --git a/alfa-service/src/test/java/de/ozgcloud/alfa/export/ExportRemoteServiceTest.java b/alfa-service/src/test/java/de/ozgcloud/alfa/export/ExportRemoteServiceTest.java
deleted file mode 100644
index e2d36e6134f13ed1a8377584aaf555daeb23bc20..0000000000000000000000000000000000000000
--- a/alfa-service/src/test/java/de/ozgcloud/alfa/export/ExportRemoteServiceTest.java
+++ /dev/null
@@ -1,68 +0,0 @@
-package de.ozgcloud.alfa.export;
-
-import static org.assertj.core.api.Assertions.*;
-import static org.mockito.Mockito.*;
-
-import java.util.Iterator;
-
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Nested;
-import org.junit.jupiter.api.Test;
-import org.mockito.ArgumentMatcher;
-import org.mockito.InjectMocks;
-import org.mockito.Mock;
-import org.mockito.MockedStatic;
-import org.mockito.Spy;
-
-import de.ozgcloud.alfa.vorgang.VorgangHeaderTestFactory;
-import de.ozgcloud.archive.grpc.export.ExportServiceGrpc.ExportServiceBlockingStub;
-import de.ozgcloud.archive.grpc.export.GrpcExportVorgangRequest;
-import de.ozgcloud.archive.grpc.export.GrpcExportVorgangResponse;
-
-class ExportRemoteServiceTest {
-
- @Spy
- @InjectMocks
- private ExportRemoteService service;
- @Mock
- private ExportServiceBlockingStub exportServiceStub;
-
- @Nested
- class TestExportVorgang {
-
- public static final String VORGANG_ID = VorgangHeaderTestFactory.ID;
-
- private static final ArgumentMatcher<GrpcExportVorgangRequest> HAS_VORGANG_ID = request -> request.getVorgangId().equals(VorgangHeaderTestFactory.ID);
-
- @Mock
- private Iterator<GrpcExportVorgangResponse> responseIterator;
- private MockedStatic<StreamedExportedVorgangFile> mockedStaticExportedFile;
-
- @BeforeEach
- void init() {
- mockedStaticExportedFile = mockStatic(StreamedExportedVorgangFile.class);
- mockedStaticExportedFile.when(() -> StreamedExportedVorgangFile.getFileNameFrom(responseIterator)).thenReturn(GrpcFileTestFactory.FILE_NAME);
- when(exportServiceStub.exportVorgang(any(GrpcExportVorgangRequest.class))).thenReturn(responseIterator);
- }
-
- @AfterEach
- void cleanup() {
- mockedStaticExportedFile.close();
- }
-
- @Test
- void shouldExportVorgang() {
- service.exportVorgang(VORGANG_ID);
-
- verify(exportServiceStub).exportVorgang(argThat(HAS_VORGANG_ID));
- }
-
- @Test
- void shouldReturnExportedVorgangFile() {
- var exportedVorgangFile = service.exportVorgang(VORGANG_ID);
-
- assertThat(exportedVorgangFile).isInstanceOf(StreamedExportedVorgangFile.class).extracting("responseIterator").isEqualTo(responseIterator);
- }
- }
-}
diff --git a/alfa-service/src/test/java/de/ozgcloud/alfa/export/GrpcExportVorgangResponseTestFactory.java b/alfa-service/src/test/java/de/ozgcloud/alfa/export/GrpcExportVorgangResponseTestFactory.java
deleted file mode 100644
index 6fb86287921347fa6d9eaecdb12e20ca5450a3bb..0000000000000000000000000000000000000000
--- a/alfa-service/src/test/java/de/ozgcloud/alfa/export/GrpcExportVorgangResponseTestFactory.java
+++ /dev/null
@@ -1,22 +0,0 @@
-package de.ozgcloud.alfa.export;
-
-import de.ozgcloud.archive.grpc.export.GrpcExportVorgangResponse;
-import de.ozgcloud.archive.grpc.export.GrpcFile;
-
-class GrpcExportVorgangResponseTestFactory {
-
- public static final GrpcFile VORGANG_FILE_WITH_NAME = GrpcFileTestFactory.createWithName();
- public static final GrpcFile VORGANG_FILE_WITH_CONTENT = GrpcFileTestFactory.createWithContent();
-
- public static GrpcExportVorgangResponse createWithName() {
- return createBuilder().setVorgangFile(VORGANG_FILE_WITH_NAME).build();
- }
-
- public static GrpcExportVorgangResponse createWithContent() {
- return createBuilder().setVorgangFile(VORGANG_FILE_WITH_CONTENT).build();
- }
-
- public static GrpcExportVorgangResponse.Builder createBuilder() {
- return GrpcExportVorgangResponse.newBuilder();
- }
-}
diff --git a/alfa-service/src/test/java/de/ozgcloud/alfa/export/GrpcFileTestFactory.java b/alfa-service/src/test/java/de/ozgcloud/alfa/export/GrpcFileTestFactory.java
deleted file mode 100644
index 2d07f97a0e54a5d6484ecd24c6a872037124b517..0000000000000000000000000000000000000000
--- a/alfa-service/src/test/java/de/ozgcloud/alfa/export/GrpcFileTestFactory.java
+++ /dev/null
@@ -1,24 +0,0 @@
-package de.ozgcloud.alfa.export;
-
-import com.google.protobuf.ByteString;
-import com.thedeanda.lorem.LoremIpsum;
-
-import de.ozgcloud.archive.grpc.export.GrpcFile;
-
-class GrpcFileTestFactory {
-
- public static final String FILE_NAME = LoremIpsum.getInstance().getName();
- public static final ByteString FILE_CONTENT = ByteString.copyFromUtf8(LoremIpsum.getInstance().getWords(10));
-
- public static GrpcFile createWithName() {
- return createBuilder().setFileName(FILE_NAME).build();
- }
-
- public static GrpcFile createWithContent() {
- return createBuilder().setFileContent(FILE_CONTENT).build();
- }
-
- public static GrpcFile.Builder createBuilder() {
- return GrpcFile.newBuilder();
- }
-}
diff --git a/alfa-service/src/test/java/de/ozgcloud/alfa/export/StreamedExportedVorgangFileTest.java b/alfa-service/src/test/java/de/ozgcloud/alfa/export/StreamedExportedVorgangFileTest.java
deleted file mode 100644
index 293aa49bce8008b40bd9f52e38ad0335bdf5e735..0000000000000000000000000000000000000000
--- a/alfa-service/src/test/java/de/ozgcloud/alfa/export/StreamedExportedVorgangFileTest.java
+++ /dev/null
@@ -1,153 +0,0 @@
-package de.ozgcloud.alfa.export;
-
-import static org.assertj.core.api.Assertions.*;
-import static org.mockito.Mockito.*;
-
-import java.io.IOException;
-import java.io.OutputStream;
-import java.util.Iterator;
-
-import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Nested;
-import org.junit.jupiter.api.Test;
-import org.mockito.Mock;
-import org.mockito.MockedStatic;
-
-import com.google.protobuf.ByteString;
-import com.thedeanda.lorem.LoremIpsum;
-
-import de.ozgcloud.archive.grpc.export.GrpcExportVorgangResponse;
-import de.ozgcloud.common.errorhandling.TechnicalException;
-
-class StreamedExportedVorgangFileTest {
-
- @Mock
- private Iterator<GrpcExportVorgangResponse> responseIterator;
-
- @Nested
- class TestContructor {
-
- private MockedStatic<StreamedExportedVorgangFile> mockedStatic;
-
- @BeforeEach
- void init() {
- mockedStatic = mockStatic(StreamedExportedVorgangFile.class);
- mockedStatic.when(() -> StreamedExportedVorgangFile.getFileNameFrom(responseIterator)).thenReturn(GrpcFileTestFactory.FILE_NAME);
- }
-
- @AfterEach
- void cleanup() {
- mockedStatic.close();
- }
-
- @Test
- void shouldGetFileNameFromResponseIterator() {
- new StreamedExportedVorgangFile(responseIterator);
-
- mockedStatic.verify(() -> StreamedExportedVorgangFile.getFileNameFrom(responseIterator));
- }
-
- @Test
- void shouldSetFileName() {
- var exportedVorgangFile = new StreamedExportedVorgangFile(responseIterator);
-
- assertThat(exportedVorgangFile.getFileName()).isEqualTo(GrpcFileTestFactory.FILE_NAME);
- }
- }
-
- @Nested
- class TestGetFileNameFrom {
-
- @Nested
- class OnEmptyResponse {
-
- @BeforeEach
- void init() {
- when(responseIterator.hasNext()).thenReturn(false);
- }
-
- @Test
- void shouldThrowException() {
- assertThatExceptionOfType(TechnicalException.class).isThrownBy(TestGetFileNameFrom.this::callTestedMethod);
- }
- }
-
- @Nested
- class OnNotEmptyResponse {
-
- @BeforeEach
- void init() {
- when(responseIterator.hasNext()).thenReturn(true);
- when(responseIterator.next()).thenReturn(GrpcExportVorgangResponseTestFactory.createWithName());
- }
-
- @Test
- void shouldCallHasNext() {
- callTestedMethod();
-
- verify(responseIterator).hasNext();
- }
-
- @Test
- void shouldCallNextOnce() {
- callTestedMethod();
-
- verify(responseIterator, times(1)).next();
- }
-
- @Test
- void shouldReturnFileName() {
- var fileName = callTestedMethod();
-
- assertThat(fileName).isEqualTo(GrpcFileTestFactory.FILE_NAME);
- }
- }
-
- private String callTestedMethod() {
- return StreamedExportedVorgangFile.getFileNameFrom(responseIterator);
- }
- }
-
- @Nested
- class TestWriteToOutputStream {
-
- public static final ByteString FILE_CONTENT_1 = GrpcFileTestFactory.FILE_CONTENT;
- public static final ByteString FILE_CONTENT_2 = ByteString.copyFromUtf8(LoremIpsum.getInstance().getWords(8));
-
- @Mock
- private OutputStream outputStream;
-
- private MockedStatic<StreamedExportedVorgangFile> mockedStatic;
-
- @BeforeEach
- void init() {
- mockedStatic = mockStatic(StreamedExportedVorgangFile.class);
- mockedStatic.when(() -> StreamedExportedVorgangFile.getFileNameFrom(responseIterator)).thenReturn(GrpcFileTestFactory.FILE_NAME);
- when(responseIterator.hasNext())
- .thenReturn(true)
- .thenReturn(true)
- .thenReturn(false);
- when(responseIterator.next())
- .thenReturn(GrpcExportVorgangResponseTestFactory.createWithContent())
- .thenReturn(GrpcExportVorgangResponseTestFactory.createBuilder().setVorgangFile(
- GrpcFileTestFactory.createBuilder().setFileContent(FILE_CONTENT_2).build()
- ).build());
- }
-
- @AfterEach
- void cleanup() {
- mockedStatic.close();
- }
-
- @Test
- void shouldWriteFileContentInOrder() throws IOException {
- var orderVerifier = inOrder(outputStream);
-
- new StreamedExportedVorgangFile(responseIterator).writeToOutputStream(outputStream);
-
- orderVerifier.verify(outputStream).write(FILE_CONTENT_1.toByteArray());
- orderVerifier.verify(outputStream).write(FILE_CONTENT_2.toByteArray());
- }
- }
-}
diff --git a/alfa-xdomea/pom.xml b/alfa-xdomea/pom.xml
new file mode 100644
index 0000000000000000000000000000000000000000..d263dd38d2a153faa29682be9c8031a3423c79b6
--- /dev/null
+++ b/alfa-xdomea/pom.xml
@@ -0,0 +1,133 @@
+<?xml version="1.0"?>
+<!--
+
+ Copyright (C) 2023 Das Land Schleswig-Holstein vertreten durch den
+ Ministerpräsidenten des Landes Schleswig-Holstein
+ Staatskanzlei
+ Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
+
+ Lizenziert unter der EUPL, Version 1.2 oder - sobald
+ diese von der Europäischen Kommission genehmigt wurden -
+ Folgeversionen der EUPL ("Lizenz");
+ Sie dürfen dieses Werk ausschließlich gemäß
+ dieser Lizenz nutzen.
+ Eine Kopie der Lizenz finden Sie hier:
+
+ https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+
+ Sofern nicht durch anwendbare Rechtsvorschriften
+ gefordert oder in schriftlicher Form vereinbart, wird
+ die unter der Lizenz verbreitete Software "so wie sie
+ ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
+ ausdrücklich oder stillschweigend - verbreitet.
+ Die sprachspezifischen Genehmigungen und Beschränkungen
+ unter der Lizenz sind dem Lizenztext zu entnehmen.
+
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+
+ <modelVersion>4.0.0</modelVersion>
+
+ <parent>
+ <groupId>de.ozgcloud.alfa</groupId>
+ <artifactId>alfa</artifactId>
+ <version>2.16.0-SNAPSHOT</version>
+ </parent>
+
+ <artifactId>alfa-xdomea</artifactId>
+ <name>Alfa xdomea</name>
+ <description>Alfa xdomea implementation</description>
+ <packaging>jar</packaging>
+
+ <properties>
+ <maven.compiler.source>${java.version}</maven.compiler.source>
+ <maven.compiler.target>${java.version}</maven.compiler.target>
+ <jaxb2-maven-plugin.version>3.1.0</jaxb2-maven-plugin.version>
+ </properties>
+
+ <dependencies>
+ <dependency>
+ <groupId>de.ozgcloud.alfa</groupId>
+ <artifactId>alfa-service</artifactId>
+ <version>${project.version}</version>
+ </dependency>
+ <dependency>
+ <groupId>jakarta.xml.bind</groupId>
+ <artifactId>jakarta.xml.bind-api</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.glassfish.jaxb</groupId>
+ <artifactId>jaxb-runtime</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.mapstruct</groupId>
+ <artifactId>mapstruct</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>org.springframework</groupId>
+ <artifactId>spring-oxm</artifactId>
+ </dependency>
+ <dependency>
+ <groupId>de.ozgcloud.alfa</groupId>
+ <artifactId>alfa-service</artifactId>
+ <version>${project.version}</version>
+ <type>test-jar</type>
+ <scope>test</scope>
+ </dependency>
+ </dependencies>
+
+ <build>
+ <plugins>
+ <plugin>
+ <groupId>org.codehaus.mojo</groupId>
+ <artifactId>jaxb2-maven-plugin</artifactId>
+ <version>${jaxb2-maven-plugin.version}</version>
+ <executions>
+ <execution>
+ <id>xjc</id>
+ <goals>
+ <goal>xjc</goal>
+ </goals>
+ </execution>
+ </executions>
+ <configuration>
+ <sources>
+ <source>src/main/resources/ozgcloud_XML-Schemata</source>
+ </sources>
+ <packageName>de.xoev.xdomea</packageName>
+ </configuration>
+ </plugin>
+ <plugin>
+ <groupId>org.springframework.boot</groupId>
+ <artifactId>spring-boot-maven-plugin</artifactId>
+ <configuration>
+ <skip>true</skip>
+ </configuration>
+ </plugin>
+ <plugin>
+ <groupId>org.jacoco</groupId>
+ <artifactId>jacoco-maven-plugin</artifactId>
+ </plugin>
+
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-surefire-plugin</artifactId>
+ </plugin>
+
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-failsafe-plugin</artifactId>
+ </plugin>
+
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-compiler-plugin</artifactId>
+ </plugin>
+ </plugins>
+ <resources>
+ <resource>
+ <directory>${project.build.directory}/generated-resources/jaxb</directory>
+ </resource>
+ </resources>
+ </build>
+</project>
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/bescheid/BescheidExportData.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/bescheid/BescheidExportData.java
new file mode 100644
index 0000000000000000000000000000000000000000..ece5ee2c105749cdd5dbf2059d6ae969e8abfb35
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/bescheid/BescheidExportData.java
@@ -0,0 +1,19 @@
+package de.ozgcloud.alfa.bescheid;
+
+import java.util.List;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.xoev.xdomea.DokumentType;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Singular;
+
+@Builder
+@Getter
+public class BescheidExportData {
+
+ @Singular
+ private List<DokumentType> dokumentTypes;
+ @Singular
+ private List<OzgFile> files;
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/bescheid/BescheidExportInput.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/bescheid/BescheidExportInput.java
new file mode 100644
index 0000000000000000000000000000000000000000..aa25d85adf81618ded8e2c62097275c011c90313
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/bescheid/BescheidExportInput.java
@@ -0,0 +1,10 @@
+package de.ozgcloud.alfa.bescheid;
+
+import java.util.List;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+import lombok.Builder;
+
+@Builder
+record BescheidExportInput(Bescheid bescheid, String organisationseinheitenId, List<OzgFile> files) {
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/bescheid/DokumentTypeBuilder.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/bescheid/DokumentTypeBuilder.java
new file mode 100644
index 0000000000000000000000000000000000000000..4a049e49cd45a920d3f64a456ace9351348bc4a3
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/bescheid/DokumentTypeBuilder.java
@@ -0,0 +1,83 @@
+package de.ozgcloud.alfa.bescheid;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import org.apache.commons.lang3.StringUtils;
+
+import de.ozgcloud.alfa.common.AnlageDokumentTypeBuilder;
+import de.ozgcloud.alfa.common.DateConverter;
+import de.ozgcloud.alfa.common.IdentifikationObjektTypeBuilder;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.xoev.xdomea.AllgemeineMetadatenType;
+import de.xoev.xdomea.AnlageDokumentType;
+import de.xoev.xdomea.DokumentType;
+import de.xoev.xdomea.HistorienProtokollInformationType;
+
+class DokumentTypeBuilder {
+ private static final String TYP = "Bescheid";
+ private static final Map<Boolean, String> BEMERKUNG = Map.of(true, "Bescheid wurde genehmigt.", false, "Bescheid wurde abgelehnt.");
+ private static final Map<SendBy, String> AKTION = Map.of(SendBy.MANUAL, "Bescheid gespeichert", SendBy.NACHRICHT,
+ "Bescheid an Antragsteller gesendet");
+
+ private Bescheid bescheid;
+ private String organisationsEinheitenId;
+ private String fullName;
+ private List<OzgFile> files;
+
+ public static DokumentTypeBuilder builder() {
+ return new DokumentTypeBuilder();
+ }
+
+ public DokumentTypeBuilder withBescheid(Bescheid bescheid) {
+ this.bescheid = bescheid;
+ return this;
+ }
+
+ public DokumentTypeBuilder withOrganisationseinheitenId(String organisationsEinheitenId) {
+ this.organisationsEinheitenId = organisationsEinheitenId;
+ return this;
+ }
+
+ public DokumentTypeBuilder withFullName(String fullName) {
+ this.fullName = fullName;
+ return this;
+ }
+
+ public DokumentTypeBuilder withFiles(List<OzgFile> files) {
+ this.files = files;
+ return this;
+ }
+
+ public DokumentType build() {
+ var dokumentType = new DokumentType();
+ dokumentType.setIdentifikation(IdentifikationObjektTypeBuilder.builder().withObjectID(bescheid.getId()).build());
+ dokumentType.setTyp(TYP);
+ dokumentType.setBezug(StringUtils.defaultString(bescheid.getNachrichtSubject()));
+ dokumentType.setAllgemeineMetadaten(createAllgemeineMetadaten());
+ dokumentType.getHistorienProtokollInformation().add(createHistorienProtokollInformation());
+ Optional.ofNullable(files).orElseGet(Collections::emptyList).stream().map(this::createAnlage).forEach(dokumentType.getAnlage()::add);
+ return dokumentType;
+ }
+
+ AllgemeineMetadatenType createAllgemeineMetadaten() {
+ var metadaten = new AllgemeineMetadatenType();
+ metadaten.setBemerkung(BEMERKUNG.get(bescheid.getBewilligt()));
+ return metadaten;
+ }
+
+ HistorienProtokollInformationType createHistorienProtokollInformation() {
+ var protokollInfo = new HistorienProtokollInformationType();
+ protokollInfo.setMetadatumName(StringUtils.defaultString(bescheid.getNachrichtText()));
+ protokollInfo.setAkteur(fullName + "; " + organisationsEinheitenId);
+ protokollInfo.setDatumUhrzeit(DateConverter.toXmlGregorianCalendar(bescheid.getSentInfo().getSentAt()));
+ protokollInfo.setAktion(AKTION.get(bescheid.getSendBy()));
+ return protokollInfo;
+ }
+
+ AnlageDokumentType createAnlage(OzgFile ozgFile) {
+ return AnlageDokumentTypeBuilder.builder().withOzgFile(ozgFile).build();
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/bescheid/ExportBescheidService.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/bescheid/ExportBescheidService.java
new file mode 100644
index 0000000000000000000000000000000000000000..7c34e61f09d3074a2ff398de69ea7ee338c3b8cb
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/bescheid/ExportBescheidService.java
@@ -0,0 +1,67 @@
+package de.ozgcloud.alfa.bescheid;
+
+import java.util.stream.Stream;
+
+import org.springframework.stereotype.Service;
+
+import de.ozgcloud.alfa.common.binaryfile.BinaryFileService;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.user.UserService;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.xoev.xdomea.DokumentType;
+import lombok.RequiredArgsConstructor;
+
+@Service
+@RequiredArgsConstructor
+public class ExportBescheidService {
+ private final BescheidService bescheidService;
+ private final BinaryFileService binaryFileService;
+ private final DocumentService documentService;
+ private final UserService userService;
+
+ public BescheidExportData createExportData(VorgangWithEingang vorgang) {
+ var builder = BescheidExportData.builder();
+ getBescheids(vorgang.getId())
+ .forEach(bescheid -> addBescheidExportData(createBescheidExportInput(bescheid, vorgang), builder));
+ return builder.build();
+ }
+
+ Stream<Bescheid> getBescheids(String vorgangId) {
+ return bescheidService.findByVorgangIdSorted(vorgangId).filter(bescheid -> BescheidStatus.SENT == bescheid.getStatus());
+ }
+
+ BescheidExportInput createBescheidExportInput(Bescheid bescheid, VorgangWithEingang vorgang) {
+ return BescheidExportInput.builder()
+ .bescheid(bescheid)
+ .organisationseinheitenId(vorgang.getOrganisationseinheitenID())
+ .files(Stream.concat(Stream.of(getDocument(bescheid)), getAttachments(bescheid)).toList()).build();
+ }
+
+ Stream<OzgFile> getAttachments(Bescheid bescheid) {
+ return binaryFileService.getFiles(bescheid.getAttachments());
+ }
+
+ void addBescheidExportData(BescheidExportInput input, BescheidExportData.BescheidExportDataBuilder builder) {
+ builder.dokumentType(buildDokumentType(input))
+ .files(input.files());
+ }
+
+ OzgFile getDocument(Bescheid bescheid) {
+ var document = documentService.getDocument(bescheid.getBescheidDocument());
+ return binaryFileService.getFile(document.getFileId());
+ }
+
+ DokumentType buildDokumentType(BescheidExportInput input) {
+ var builder = DokumentTypeBuilder.builder();
+ builder.withBescheid(input.bescheid())
+ .withFiles(input.files())
+ .withFullName(getFullName(input.bescheid()))
+ .withOrganisationseinheitenId(input.organisationseinheitenId());
+ return builder.build();
+ }
+
+ String getFullName(Bescheid bescheid) {
+ return userService.getById(bescheid.getSentInfo().getSentBy()).getFullName();
+ }
+
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/AnlageDokumentTypeBuilder.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/AnlageDokumentTypeBuilder.java
new file mode 100644
index 0000000000000000000000000000000000000000..593a6057fb57b48524006a1929bbadfff7e10fd6
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/AnlageDokumentTypeBuilder.java
@@ -0,0 +1,37 @@
+package de.ozgcloud.alfa.common;
+
+import java.time.ZonedDateTime;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.xoev.xdomea.AnlageDokumentType;
+
+public class AnlageDokumentTypeBuilder {
+ private OzgFile ozgFile;
+ private ZonedDateTime createdAt;
+
+ public static AnlageDokumentTypeBuilder builder() {
+ return new AnlageDokumentTypeBuilder();
+ }
+
+ public AnlageDokumentTypeBuilder withOzgFile(OzgFile ozgFile) {
+ this.ozgFile = ozgFile;
+ return this;
+ }
+
+ public AnlageDokumentTypeBuilder withCreatedAt(ZonedDateTime createdAt) {
+ this.createdAt = createdAt;
+ return this;
+ }
+
+ public AnlageDokumentType build() {
+ var anlage = new AnlageDokumentType();
+ anlage.setIdentifikation(IdentifikationObjektTypeBuilder.builder()
+ .withObjectID(ozgFile.getId().toString())
+ .build());
+ anlage.getVersion().add(VersionTypeBuilder.builder()
+ .withCreatedAt(createdAt)
+ .withOzgFile(ozgFile).build());
+ return anlage;
+ }
+
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/DateConverter.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/DateConverter.java
new file mode 100644
index 0000000000000000000000000000000000000000..bce094fc04399c0c5202ada3250837afdaf7b38e
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/DateConverter.java
@@ -0,0 +1,60 @@
+package de.ozgcloud.alfa.common;
+
+import static java.util.Objects.*;
+
+import java.time.LocalDate;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.GregorianCalendar;
+import java.util.Locale;
+import java.util.Optional;
+
+import javax.xml.datatype.DatatypeConfigurationException;
+import javax.xml.datatype.DatatypeFactory;
+import javax.xml.datatype.XMLGregorianCalendar;
+
+import de.ozgcloud.common.errorhandling.TechnicalException;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+import lombok.extern.log4j.Log4j2;
+
+@Log4j2
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public class DateConverter {
+
+ private static final DateTimeFormatter DATE_TIME_FORMATTER = DateTimeFormatter.ofPattern("dd.MM.yyyy", Locale.GERMAN);
+
+ public static Optional<XMLGregorianCalendar> convertGermanFormatToISO(String dateStr) {
+ try {
+ if (nonNull(dateStr)) {
+ return Optional.of(createDatatypeFactory().newXMLGregorianCalendar(LocalDate.parse(dateStr, DATE_TIME_FORMATTER).toString()));
+ }
+ } catch (Exception e) {
+ LOG.warn("Date '{}' cannot be converted to ISO format.", dateStr, e);
+ }
+ return Optional.empty();
+ }
+
+ public static XMLGregorianCalendar toXmlGregorianCalendar(ZonedDateTime date) {
+ try {
+ if (nonNull(date)) {
+ return createDatatypeFactory().newXMLGregorianCalendar(GregorianCalendar.from(date));
+ }
+ } catch (Exception e) {
+ LOG.warn("Date '{}' cannot be converted to ISO format.", date, e);
+ }
+ return null;
+ }
+
+ public static XMLGregorianCalendar createEmpty() {
+ return DateConverter.createDatatypeFactory().newXMLGregorianCalendar();
+ }
+
+ static DatatypeFactory createDatatypeFactory() {
+ try {
+ return DatatypeFactory.newInstance();
+ } catch (DatatypeConfigurationException e) {
+ throw new TechnicalException("Error creating datatype factory.", e);
+ }
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/DateiformatCode.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/DateiformatCode.java
new file mode 100644
index 0000000000000000000000000000000000000000..d91a9e7f9e406ce57e3c5c2b8e12e0307136603d
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/DateiformatCode.java
@@ -0,0 +1,85 @@
+package de.ozgcloud.alfa.common;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+import org.apache.commons.lang3.StringUtils;
+
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public final class DateiformatCode {
+
+ static final String SONSTIGES_CODE = "100";
+
+ // MIME type -> file extension -> xdomea code
+ private static final Map<String, Map<String, String>> mimeTypesMapping = new HashMap<>();
+
+ static {
+ mimeTypesMapping.put("image/bmp", Map.of("bmp", "001"));
+ mimeTypesMapping.put("text/csv", Map.of("csv", "002"));
+ mimeTypesMapping.put("application/msword", Map.of("doc", "003", "dot", "032"));
+ mimeTypesMapping.put("message/rfc822", Map.of("eml", "006"));
+ mimeTypesMapping.put("text/html", Map.of("htm", "007", "html", "008"));
+ mimeTypesMapping.put("image/jpeg", Map.of("jpe", "009", "jpeg", "010", "jpg", "011"));
+ mimeTypesMapping.put("application/vnd.ms-outlook", Map.of("msg", "012"));
+ mimeTypesMapping.put("application/vnd.oasis.opendocument.presentation", Map.of("odp", "013"));
+ mimeTypesMapping.put("application/vnd.oasis.opendocument.spreadsheet", Map.of("ods", "014"));
+ mimeTypesMapping.put("application/vnd.oasis.opendocument.text", Map.of("odt", "015"));
+ mimeTypesMapping.put("application/vnd.oasis.opendocument.presentation-template", Map.of("otp", "016"));
+ mimeTypesMapping.put("application/vnd.oasis.opendocument.spreadsheet-template", Map.of("ots", "017"));
+ mimeTypesMapping.put("application/pdf", Map.of("pdf", "018"));
+ mimeTypesMapping.put("image/png", Map.of("png", "019"));
+ mimeTypesMapping.put("application/vnd.ms-powerpoint", Map.of("ppt", "020", "pot", "033"));
+ mimeTypesMapping.put("application/postscript", Map.of("ps", "021"));
+ mimeTypesMapping.put("application/rtf", Map.of("rtf", "022"));
+ mimeTypesMapping.put("image/tiff", Map.of("tif", "023", "tiff", "024"));
+ mimeTypesMapping.put("application/vnd.ms-works", Map.of("wps", "025"));
+ mimeTypesMapping.put("application/vnd.ms-excel", Map.of("xlc", "026", "xlm", "027", "xls", "028", "xlw", "029", "xlt", "034"));
+ mimeTypesMapping.put("application/xml", Map.of("xml", "030", "xsd", "031"));
+ mimeTypesMapping.put("text/xml", Map.of("xml", "030", "xsd", "031"));
+ mimeTypesMapping.put("application/vnd.openxmlformats-officedocument.wordprocessingml.document", Map.of("docx", "035"));
+ mimeTypesMapping.put("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", Map.of("xlsx", "036"));
+ mimeTypesMapping.put("application/vnd.openxmlformats-officedocument.presentationml.presentation", Map.of("pptx", "037"));
+ mimeTypesMapping.put("application/vnd.openxmlformats-officedocument.wordprocessingml.template", Map.of("dotx", "038"));
+ mimeTypesMapping.put("application/vnd.openxmlformats-officedocument.spreadsheetml.template", Map.of("xltx", "039"));
+ mimeTypesMapping.put("application/vnd.openxmlformats-officedocument.presentationml.template", Map.of("potx", "040"));
+ mimeTypesMapping.put("application/xml-dtd", Map.of("dtd", "041"));
+ mimeTypesMapping.put("application/vnd.ms-project", Map.of("mpp", "042"));
+ mimeTypesMapping.put("application/vnd.oasis.opendocument.text-template", Map.of("ott", "043"));
+ mimeTypesMapping.put("text/plain", Map.of("txt", "045"));
+ mimeTypesMapping.put("application/x-pkcs7-certificates", Map.of("p7b", "046"));
+ mimeTypesMapping.put("application/pkcs7-mime", Map.of("p7c", "047", "p7m", "048"));
+ mimeTypesMapping.put("application/pkcs7-signature", Map.of("p7s", "049"));
+ mimeTypesMapping.put("application/vnd.etsi.asic-s+zip", Map.of("asics", "050"));
+ mimeTypesMapping.put("application/scvp-cv-response", Map.of("scs", "051"));
+ }
+
+ public static String getXdomeaCode(String mimeType, String extension) {
+ var fileExtensionToCodeMapping = getFileExtensionToCodeMapping(mimeType);
+ if (hasSingleExtensionMapping(fileExtensionToCodeMapping)) {
+ return getCodeOrDefault(fileExtensionToCodeMapping);
+ }
+ return getCodeForExtensionOrDefault(extension, fileExtensionToCodeMapping);
+ }
+
+ private static Map<String, String> getFileExtensionToCodeMapping(String mimeType) {
+ return mimeTypesMapping.getOrDefault(Objects.requireNonNullElse(mimeType, StringUtils.EMPTY), Collections.emptyMap());
+ }
+
+ private static boolean hasSingleExtensionMapping(Map<String, String> fileExtensionToCodeMapping) {
+ return fileExtensionToCodeMapping.entrySet().size() == 1;
+ }
+
+ private static String getCodeOrDefault(Map<String, String> fileExtensionToCodeMapping) {
+ return fileExtensionToCodeMapping.values().stream().findFirst().orElse(SONSTIGES_CODE);
+ }
+
+ private static String getCodeForExtensionOrDefault(String extension, Map<String, String> fileExtensionToCodeMapping) {
+ return fileExtensionToCodeMapping.getOrDefault(Objects.requireNonNullElse(extension, StringUtils.EMPTY), SONSTIGES_CODE);
+ }
+
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/DatentypCode.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/DatentypCode.java
new file mode 100644
index 0000000000000000000000000000000000000000..3ba6ce26689cb4351cfadb74573181ff22d73846
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/DatentypCode.java
@@ -0,0 +1,15 @@
+package de.ozgcloud.alfa.common;
+
+public enum DatentypCode {
+ STRING("038"), DATE("005");
+
+ private String code;
+
+ DatentypCode(String code) {
+ this.code = code;
+ }
+
+ public String getCode() {
+ return code;
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/ExportFilenameGenerator.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/ExportFilenameGenerator.java
new file mode 100644
index 0000000000000000000000000000000000000000..069f37f3027879d431531ef82ed09efec33a473d
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/ExportFilenameGenerator.java
@@ -0,0 +1,13 @@
+package de.ozgcloud.alfa.common;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public class ExportFilenameGenerator {
+
+ public static String generateExportFilename(OzgFile ozgFile) {
+ return String.format("%s_%s", UUIDConverter.fromObjectId(ozgFile.getId().toString()), ozgFile.getName());
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/IdentifikationObjektTypeBuilder.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/IdentifikationObjektTypeBuilder.java
new file mode 100644
index 0000000000000000000000000000000000000000..7eceb19c8d3d952a79d179f0ef6c9e1edb515860
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/IdentifikationObjektTypeBuilder.java
@@ -0,0 +1,29 @@
+package de.ozgcloud.alfa.common;
+
+import de.xoev.xdomea.IdentifikationObjektType;
+
+public class IdentifikationObjektTypeBuilder {
+ private String objectID;
+ private Long ordinalNumber;
+
+ public static IdentifikationObjektTypeBuilder builder() {
+ return new IdentifikationObjektTypeBuilder();
+ }
+
+ public IdentifikationObjektTypeBuilder withObjectID(String objectID) {
+ this.objectID = objectID;
+ return this;
+ }
+
+ public IdentifikationObjektTypeBuilder withOrdinalNumber(Long ordinalNumber) {
+ this.ordinalNumber = ordinalNumber;
+ return this;
+ }
+
+ public IdentifikationObjektType build() {
+ var identifikation = new IdentifikationObjektType();
+ identifikation.setID(UUIDConverter.fromObjectId(objectID));
+ identifikation.setNummerImUebergeordnetenContainer(ordinalNumber);
+ return identifikation;
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/PrimaerdokumentTypeBuilder.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/PrimaerdokumentTypeBuilder.java
new file mode 100644
index 0000000000000000000000000000000000000000..17fc5d419308757c806d8a615e9b8ab2479b8c74
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/PrimaerdokumentTypeBuilder.java
@@ -0,0 +1,45 @@
+package de.ozgcloud.alfa.common;
+
+import java.time.ZonedDateTime;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.xoev.xdomea.PrimaerdokumentType;
+
+public class PrimaerdokumentTypeBuilder {
+
+ private OzgFile ozgFile;
+ private String ersteller;
+ private ZonedDateTime createdAt;
+
+ public static PrimaerdokumentTypeBuilder builder() {
+ return new PrimaerdokumentTypeBuilder();
+ }
+
+ public PrimaerdokumentTypeBuilder withOzgFile(OzgFile ozgFile) {
+ this.ozgFile = ozgFile;
+ return this;
+ }
+
+ public PrimaerdokumentTypeBuilder withErsteller(String ersteller) {
+ this.ersteller = ersteller;
+ return this;
+ }
+
+ public PrimaerdokumentTypeBuilder withCreatedAt(ZonedDateTime createdAt) {
+ this.createdAt = createdAt;
+ return this;
+ }
+
+ public PrimaerdokumentType build() {
+ if (ozgFile == null) {
+ throw new IllegalStateException("Can not build Primaerdokument when ozg file is null");
+ }
+
+ var primaerdokument = new PrimaerdokumentType();
+ primaerdokument.setDateiname(ExportFilenameGenerator.generateExportFilename(ozgFile));
+ primaerdokument.setDateinameOriginal(ozgFile.getName());
+ primaerdokument.setErsteller(ersteller);
+ primaerdokument.setDatumUhrzeit(DateConverter.toXmlGregorianCalendar(createdAt));
+ return primaerdokument;
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/UUIDConverter.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/UUIDConverter.java
new file mode 100644
index 0000000000000000000000000000000000000000..85c84b421c0cf3d916e3ba2c70a372abd268d5d5
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/UUIDConverter.java
@@ -0,0 +1,25 @@
+package de.ozgcloud.alfa.common;
+
+import java.util.regex.Pattern;
+
+import org.apache.commons.lang3.StringUtils;
+
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public class UUIDConverter {
+
+ private static final Pattern UUID_SPLIT_PATTERN = Pattern.compile(
+ "^([a-fA-F0-9]{8})([a-fA-F0-9]{4})([a-fA-F0-9]{4})([a-fA-F0-9]{4})([a-fA-F0-9]+)$");
+
+ public static String fromObjectId(String objectId) {
+ var matcher = UUID_SPLIT_PATTERN.matcher(objectId);
+ if (matcher.find()) {
+ var lastGroup = StringUtils.leftPad(matcher.group(5), 12, "0");
+ return String.format("%s-%s-%s-%s-%s", matcher.group(1), matcher.group(2), matcher.group(3), matcher.group(4), lastGroup);
+ }
+ throw new IllegalArgumentException(String.format("Invalid object id %s", objectId));
+ }
+
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/VersionTypeBuilder.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/VersionTypeBuilder.java
new file mode 100644
index 0000000000000000000000000000000000000000..3937b36d4eb85deb773eac2dcd0d1cad63a098c7
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/common/VersionTypeBuilder.java
@@ -0,0 +1,73 @@
+package de.ozgcloud.alfa.common;
+
+import java.time.ZonedDateTime;
+
+import org.apache.commons.io.FilenameUtils;
+import org.apache.commons.lang3.StringUtils;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.xoev.xdomea.DateiformatCodeType;
+import de.xoev.xdomea.FormatType;
+import de.xoev.xdomea.VersionType;
+
+public class VersionTypeBuilder {
+ public static final String VERSION_NUMMER = "1";
+ public static final String DATEI_FORMAT_LIST_URI = "urn:xoev-de:xdomea:codeliste:dateiformat";
+ public static final String LIST_VERSION_ID = "2.0";
+ private OzgFile ozgFile;
+ private ZonedDateTime createdAt;
+ private String ersteller;
+ private String sonstigerName;
+
+ public static VersionTypeBuilder builder() {
+ return new VersionTypeBuilder();
+ }
+
+ public VersionTypeBuilder withOzgFile(OzgFile ozgFile) {
+ this.ozgFile = ozgFile;
+ return this;
+ }
+
+ public VersionTypeBuilder withCreatedAt(ZonedDateTime createdAt) {
+ this.createdAt = createdAt;
+ return this;
+ }
+
+ public VersionTypeBuilder withErsteller(String ersteller) {
+ this.ersteller = ersteller;
+ return this;
+ }
+
+ public VersionTypeBuilder withSonstigerName(String sonstigerName) {
+ this.sonstigerName = sonstigerName;
+ return this;
+ }
+
+ public VersionType build() {
+ var versionType = new VersionType();
+ versionType.setNummer(VERSION_NUMMER);
+ versionType.getFormat().add(createFormatType());
+ return versionType;
+ }
+
+ FormatType createFormatType() {
+ var formatType = new FormatType();
+ formatType.setName(createDateiformatCodeType());
+ formatType.setVersion(StringUtils.EMPTY);
+ formatType.setSonstigerName(sonstigerName);
+ formatType.setPrimaerdokument(PrimaerdokumentTypeBuilder.builder()
+ .withCreatedAt(createdAt)
+ .withErsteller(ersteller)
+ .withOzgFile(ozgFile)
+ .build());
+ return formatType;
+ }
+
+ DateiformatCodeType createDateiformatCodeType() {
+ var dateiformatCode = new DateiformatCodeType();
+ dateiformatCode.setCode(DateiformatCode.getXdomeaCode(ozgFile.getContentType(), FilenameUtils.getExtension(ozgFile.getName()).toLowerCase()));
+ dateiformatCode.setListURI(DATEI_FORMAT_LIST_URI);
+ dateiformatCode.setListVersionID(LIST_VERSION_ID);
+ return dateiformatCode;
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/ExportConfiguration.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/ExportConfiguration.java
new file mode 100644
index 0000000000000000000000000000000000000000..1ad1ea37461edf34756e2f478e3b56cc74e2bd88
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/ExportConfiguration.java
@@ -0,0 +1,43 @@
+package de.ozgcloud.alfa.export;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.oxm.jaxb.Jaxb2Marshaller;
+import org.springframework.validation.Validator;
+
+import jakarta.xml.bind.Marshaller;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor
+@Configuration
+class ExportConfiguration {
+
+ static final boolean JAXB_FORMATTED_OUTPUT = true;
+ static final String PROPERTY_NAMESPACE_PREFIX_MAPPER = "org.glassfish.jaxb.namespacePrefixMapper";
+ static final String CONTEXT_PATH = "de.xoev.xdomea";
+
+ private final XdomeaNamespacePrefixMapper prefixMapper;
+
+ @Bean
+ static Validator configurationPropertiesValidator() {
+ return new XdomeaPropertiesValidator();
+ }
+
+ @Bean
+ Jaxb2Marshaller marshaller() {
+ var marshaller = new Jaxb2Marshaller();
+ marshaller.setContextPaths(CONTEXT_PATH);
+ marshaller.setMarshallerProperties(createMarshallerProperties());
+ return marshaller;
+ }
+
+ Map<String, Object> createMarshallerProperties() {
+ var props = new HashMap<String, Object>();
+ props.put(Marshaller.JAXB_FORMATTED_OUTPUT, JAXB_FORMATTED_OUTPUT);
+ props.put(PROPERTY_NAMESPACE_PREFIX_MAPPER, prefixMapper);
+ return props;
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/ExportData.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/ExportData.java
new file mode 100644
index 0000000000000000000000000000000000000000..bea5d003d18ce25769862c1f57f22e92584e469e
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/ExportData.java
@@ -0,0 +1,21 @@
+package de.ozgcloud.alfa.export;
+
+import java.util.Set;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.xoev.xdomea.AbgabeAbgabe0401;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+
+@Builder
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+@Getter
+class ExportData {
+
+ private String exportFilename;
+ private AbgabeAbgabe0401 abgabe;
+ private Set<OzgFile> exportFiles;
+
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/ExportService.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/ExportService.java
new file mode 100644
index 0000000000000000000000000000000000000000..65de7b375a079150afa974bd1dfc23ea0607b598
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/ExportService.java
@@ -0,0 +1,140 @@
+package de.ozgcloud.alfa.export;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+
+import de.ozgcloud.alfa.bescheid.ExportBescheidService;
+import de.ozgcloud.alfa.common.ExportFilenameGenerator;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.file.ExportFileService;
+import de.ozgcloud.alfa.historie.ExportHistorieService;
+import de.ozgcloud.alfa.kommentar.ExportKommentarService;
+import de.ozgcloud.alfa.postfach.ExportNachrichtService;
+import de.ozgcloud.alfa.vorgang.Eingang;
+import de.ozgcloud.alfa.vorgang.EingangHeader;
+import de.ozgcloud.alfa.vorgang.ExportVorgangService;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.ozgcloud.common.binaryfile.TempFileUtils;
+import de.ozgcloud.common.errorhandling.TechnicalException;
+import de.xoev.xdomea.AbgabeAbgabe0401;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor
+@Service
+class ExportService {
+
+ static final String EXPORT_FILENAME_SUFFIX = "_Abgabe.Abgabe.0401.xml";
+ private static final String EXPORT_FILENAME_TEMPLATE = "%s" + EXPORT_FILENAME_SUFFIX;
+
+ private final XdomeaXmlMarshaller xDomeaXmlMarshaller;
+
+ private final ExportFileService exportFileService;
+ private final ExportVorgangService exportVorgangService;
+ private final ExportHistorieService exportHistorieService;
+ private final ExportKommentarService exportKommentarService;
+ private final ExportNachrichtService exportNachrichtService;
+ private final ExportBescheidService exportBescheidService;
+
+ public void writeExport(String vorgangId, String filenameId, OutputStream out) {
+ var exportData = collectExportData(vorgangId, filenameId);
+ var zipFile = createZipFile(exportData);
+ writeZipFileContent(zipFile, out);
+ }
+
+ ExportData collectExportData(String vorgangId, String filenameId) {
+ var vorgang = exportVorgangService.getVorgang(vorgangId);
+ var kommentarsData = exportKommentarService.createExportData(vorgang);
+ var postfachMailData = exportNachrichtService.createExportData(vorgang);
+ var bescheidData = exportBescheidService.createExportData(vorgang);
+ var representations = exportFileService.getRepresentations(vorgang).toList();
+ var attachments = exportFileService.getAttachments(vorgang).toList();
+ var formEngineName = getFormEngineName(vorgang);
+ var abgabe = XdomeaNachrichtBuilder.builder()
+ .withKopf(exportVorgangService.createKopf(vorgang))
+ .withVorgang(exportVorgangService.createVorgangType(vorgang))
+ .withAktenzeichen(exportVorgangService.createAkteType(vorgang))
+ .withRepresentations(exportFileService.createDokumentTypes(representations, formEngineName).toList())
+ .withAttachments(exportFileService.createDokumentTypes(attachments, formEngineName).toList())
+ .withHistorie(exportHistorieService.createHistorienProtokollInformationTypes(vorgang).toList())
+ .withKommentare(kommentarsData.getDokumentTypes())
+ .withPostfachMails(postfachMailData.getDokumentTypes())
+ .withBescheids(bescheidData.getDokumentTypes())
+ .build();
+ var exportFiles = Stream
+ .of(representations.stream(), attachments.stream(),
+ kommentarsData.getAttachments().stream(),
+ postfachMailData.getAttachments().stream(),
+ bescheidData.getFiles().stream())
+ .flatMap(s -> s)
+ .collect(Collectors.toSet());
+ return ExportData.builder().abgabe(abgabe).exportFilename(buildXmlFilename(filenameId)).exportFiles(exportFiles).build();
+ }
+
+ String getFormEngineName(VorgangWithEingang vorgang) {
+ return Optional.ofNullable(vorgang.getEingang())
+ .map(Eingang::getHeader)
+ .map(EingangHeader::getFormEngineName).orElse(StringUtils.EMPTY);
+ }
+
+ String buildXmlFilename(String filenameId) {
+ return String.format(EXPORT_FILENAME_TEMPLATE, filenameId);
+ }
+
+ String createXmlContent(AbgabeAbgabe0401 abgabe) {
+ return xDomeaXmlMarshaller.marshal(abgabe);
+ }
+
+ File createZipFile(ExportData exportData) {
+ var file = TempFileUtils.createTmpFile().toFile();
+ try (var zipOutputStream = new ZipOutputStream(new FileOutputStream(file))) {
+ putZipEntry(exportData.getExportFilename(), createXmlContent(exportData.getAbgabe()), zipOutputStream);
+ putFilesIntoZip(exportData.getExportFiles(), zipOutputStream);
+ return file;
+ } catch (Exception e) {
+ throw new TechnicalException("Error creating xdomea zip file", e);
+ }
+ }
+
+ void putZipEntry(String fileName, String fileData, ZipOutputStream zipOutputStream) throws IOException {
+ var entry = new ZipEntry(fileName);
+ zipOutputStream.putNextEntry(entry);
+ zipOutputStream.write(fileData.getBytes(StandardCharsets.UTF_8));
+ zipOutputStream.closeEntry();
+ }
+
+ private void putFilesIntoZip(Set<OzgFile> ozgFiles, ZipOutputStream zipOutputStream) {
+ ozgFiles.forEach(ozgFile -> putOzgFileIntoZip(ozgFile, zipOutputStream));
+ }
+
+ void putOzgFileIntoZip(OzgFile ozgFile, ZipOutputStream zipOutputStream) {
+ try {
+ var entry = new ZipEntry(ExportFilenameGenerator.generateExportFilename(ozgFile));
+ zipOutputStream.putNextEntry(entry);
+ exportFileService.writeOzgFile(ozgFile.getId(), zipOutputStream);
+ zipOutputStream.closeEntry();
+ } catch (IOException e) {
+ throw new TechnicalException("Cannot add file to ZIP.", e);
+ }
+ }
+
+ void writeZipFileContent(File file, OutputStream outputStream) {
+ try (var fileInputStream = new FileInputStream(file)) {
+ fileInputStream.transferTo(outputStream);
+ } catch (Exception e) {
+ throw new TechnicalException("Error writing xdomea zip file to output stream", e);
+ }
+ }
+}
diff --git a/alfa-service/src/main/java/de/ozgcloud/alfa/export/ExportVorgangController.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/ExportVorgangController.java
similarity index 64%
rename from alfa-service/src/main/java/de/ozgcloud/alfa/export/ExportVorgangController.java
rename to alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/ExportVorgangController.java
index abd43c474649b916f33e8992f21d44784bb332ff..052b36cd92c182aad9838aefe8f108b358af4e65 100644
--- a/alfa-service/src/main/java/de/ozgcloud/alfa/export/ExportVorgangController.java
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/ExportVorgangController.java
@@ -1,5 +1,7 @@
package de.ozgcloud.alfa.export;
+import java.util.UUID;
+
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
@@ -11,21 +13,27 @@ import org.springframework.web.servlet.mvc.method.annotation.StreamingResponseBo
import lombok.RequiredArgsConstructor;
+@RequiredArgsConstructor
@RestController
@RequestMapping(ExportVorgangController.PATH)
-@RequiredArgsConstructor
public class ExportVorgangController {
static final String PATH = "/api/vorgangs"; // NOSONAR
- private final ExportRemoteService exportRemoteService;
+ private static final String EXPORT_FILENAME_TEMPLATE = "%s_Abgabe.Abgabe.0401.xdomea";
+
+ private final ExportService xDomeaService;
@GetMapping(value = "{vorgangId}", produces = MediaType.APPLICATION_OCTET_STREAM_VALUE)
- public ResponseEntity<StreamingResponseBody> exportVorgang(@PathVariable String vorgangId) {
- var exportedVorgangFile = exportRemoteService.exportVorgang(vorgangId);
+ public ResponseEntity<StreamingResponseBody> exportToXdomea(@PathVariable String vorgangId) {
+ var filenameId = UUID.randomUUID().toString();
return ResponseEntity.ok()
- .header(HttpHeaders.CONTENT_DISPOSITION, String.format("attachment; filename=%s", exportedVorgangFile.getFileName()))
+ .header(HttpHeaders.CONTENT_DISPOSITION, String.format("attachment; filename=%s", buildZipFilename(filenameId)))
.contentType(MediaType.APPLICATION_OCTET_STREAM)
- .body(exportedVorgangFile::writeToOutputStream);
+ .body(out -> xDomeaService.writeExport(vorgangId, filenameId, out));
+ }
+
+ String buildZipFilename(String filenameId) {
+ return String.format(EXPORT_FILENAME_TEMPLATE, filenameId);
}
}
diff --git a/alfa-service/src/main/java/de/ozgcloud/alfa/export/ExportVorgangProcessor.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/ExportVorgangProcessor.java
similarity index 96%
rename from alfa-service/src/main/java/de/ozgcloud/alfa/export/ExportVorgangProcessor.java
rename to alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/ExportVorgangProcessor.java
index 8c570cff79bdad0796683d6ecaf92888c841138f..b7621e342cb52f19593b07ee03384b25285feb6e 100644
--- a/alfa-service/src/main/java/de/ozgcloud/alfa/export/ExportVorgangProcessor.java
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/ExportVorgangProcessor.java
@@ -33,7 +33,7 @@ class ExportVorgangProcessor implements RepresentationModelProcessor<EntityModel
return ModelBuilder.fromModel(model)
.ifMatch(IS_VORGANG_ABGESCHLOSSEN)
- .addLink(linkTo(methodOn(ExportVorgangController.class).exportVorgang(vorgang.getId())).withRel(REL_EXPORT))
+ .addLink(linkTo(methodOn(ExportVorgangController.class).exportToXdomea(vorgang.getId())).withRel(REL_EXPORT))
.buildModel();
}
}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XdomeaMedienart.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XdomeaMedienart.java
new file mode 100644
index 0000000000000000000000000000000000000000..42338a5e6befc601a62735b18d700dfee7fcc795
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XdomeaMedienart.java
@@ -0,0 +1,16 @@
+package de.ozgcloud.alfa.export;
+
+enum XdomeaMedienart {
+
+ ELEKTRONISCHES_DOKUMENT("001");
+
+ private String code;
+
+ XdomeaMedienart(String code) {
+ this.code = code;
+ }
+
+ public String getCode() {
+ return code;
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XdomeaNachrichtBuilder.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XdomeaNachrichtBuilder.java
new file mode 100644
index 0000000000000000000000000000000000000000..644265c961a0a0d943d721d12d5f1c5c9d33d067
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XdomeaNachrichtBuilder.java
@@ -0,0 +1,115 @@
+package de.ozgcloud.alfa.export;
+
+import java.util.Collections;
+import java.util.List;
+
+import de.xoev.xdomea.AbgabeAbgabe0401;
+import de.xoev.xdomea.AbgabeAbgabe0401.Schriftgutobjekt;
+import de.xoev.xdomea.AkteType;
+import de.xoev.xdomea.DokumentType;
+import de.xoev.xdomea.HistorienProtokollInformationType;
+import de.xoev.xdomea.NkAbgabeType;
+import de.xoev.xdomea.VorgangType;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+class XdomeaNachrichtBuilder {
+
+ private VorgangType vorgang;
+ private NkAbgabeType kopf;
+ private AkteType aktenzeichen;
+ private List<DokumentType> representations = Collections.emptyList();
+ private List<DokumentType> attachments = Collections.emptyList();
+ private List<DokumentType> kommentare = Collections.emptyList();
+ private List<DokumentType> postfachMails = Collections.emptyList();
+ private List<DokumentType> bescheids = Collections.emptyList();
+ private List<HistorienProtokollInformationType> historie = Collections.emptyList();
+
+ public static XdomeaNachrichtBuilder builder() {
+ return new XdomeaNachrichtBuilder();
+ }
+
+ public XdomeaNachrichtBuilder withKopf(NkAbgabeType kopf) {
+ this.kopf = kopf;
+ return this;
+ }
+
+ public XdomeaNachrichtBuilder withVorgang(VorgangType vorgangType) {
+ this.vorgang = vorgangType;
+ return this;
+ }
+
+ public XdomeaNachrichtBuilder withAktenzeichen(AkteType akteType) {
+ this.aktenzeichen = akteType;
+ return this;
+ }
+
+ public XdomeaNachrichtBuilder withRepresentations(List<DokumentType> representations) {
+ this.representations = representations;
+ return this;
+ }
+
+ public XdomeaNachrichtBuilder withAttachments(List<DokumentType> attachments) {
+ this.attachments = attachments;
+ return this;
+ }
+
+ public XdomeaNachrichtBuilder withHistorie(List<HistorienProtokollInformationType> historie) {
+ this.historie = historie;
+ return this;
+ }
+
+ public XdomeaNachrichtBuilder withKommentare(List<DokumentType> kommentare) {
+ this.kommentare = kommentare;
+ return this;
+ }
+
+ public XdomeaNachrichtBuilder withPostfachMails(List<DokumentType> postfachMails) {
+ this.postfachMails = postfachMails;
+ return this;
+ }
+
+ public XdomeaNachrichtBuilder withBescheids(List<DokumentType> bescheids) {
+ this.bescheids = bescheids;
+ return this;
+ }
+
+ public AbgabeAbgabe0401 build() {
+ addVorgangDokumente();
+ addVorgangChangeHistory();
+ return createAbgabeType();
+ }
+
+ void addVorgangDokumente() {
+ representations.forEach(vorgang.getDokument()::add);
+ attachments.forEach(vorgang.getDokument()::add);
+ kommentare.forEach(vorgang.getDokument()::add);
+ postfachMails.forEach(vorgang.getDokument()::add);
+ bescheids.forEach(vorgang.getDokument()::add);
+ }
+
+ void addVorgangChangeHistory() {
+ historie.forEach(vorgang.getHistorienProtokollInformation()::add);
+ }
+
+ AbgabeAbgabe0401 createAbgabeType() {
+ var abgabeType = new AbgabeAbgabe0401();
+ abgabeType.setKopf(kopf);
+ abgabeType.getSchriftgutobjekt().add(createSchriftgutobjektVorgang());
+ abgabeType.getSchriftgutobjekt().add(createSchriftgutobjektAkte());
+ return abgabeType;
+ }
+
+ private Schriftgutobjekt createSchriftgutobjektVorgang() {
+ var schriftgutobjekt = new Schriftgutobjekt();
+ schriftgutobjekt.setVorgang(vorgang);
+ return schriftgutobjekt;
+ }
+
+ private Schriftgutobjekt createSchriftgutobjektAkte() {
+ var schriftgutobjekt = new Schriftgutobjekt();
+ schriftgutobjekt.setAkte(aktenzeichen);
+ return schriftgutobjekt;
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XdomeaNamespacePrefixMapper.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XdomeaNamespacePrefixMapper.java
new file mode 100644
index 0000000000000000000000000000000000000000..08894a2387b574d9616faebb9eac3d15603f772c
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XdomeaNamespacePrefixMapper.java
@@ -0,0 +1,47 @@
+package de.ozgcloud.alfa.export;
+
+import java.util.Map;
+
+import org.glassfish.jaxb.runtime.marshaller.NamespacePrefixMapper;
+import org.springframework.stereotype.Component;
+
+@Component
+class XdomeaNamespacePrefixMapper extends NamespacePrefixMapper {
+
+ static final String XDOMEA_NAMESPACE_URI = "urn:xoev-de:xdomea:schema:3.0.0";
+ static final String XDOMEA_NAMESPACE_PREFIX = "xdomea";
+
+ static final String XDOMEA_NAMESPACE_DINSPEC = "dinspec91379";
+ static final String XDOMEA_NAMESPACE_DINSPEC_URI = "urn:xoev-de:kosit:xoev:datentyp:din-spec-91379_2019-03";
+
+ static final String XDOMEA_NAMESPACE_GML = "gml";
+ static final String XDOMEA_NAMESPACE_GML_URI = "http://www.opengis.net/gml/3.2";
+
+ static final String XDOMEA_NAMESPACE_XOEV_CODE = "xoev-code";
+ static final String XDOMEA_NAMESPACE_XOEV_CODE_URI = "http://xoev.de/schemata/code/1_0";
+
+ static final String XDOMEA_NAMESPACE_XOEV_LC = "xoev-lc";
+ static final String XDOMEA_NAMESPACE_XOEV_LC_URI = "http://xoev.de/latinchars/1_1/datatypes";
+
+ private static final Map<String, String> NAMESPACE_MAP = Map.of(
+ XDOMEA_NAMESPACE_URI, XDOMEA_NAMESPACE_PREFIX,
+ XDOMEA_NAMESPACE_DINSPEC_URI, XDOMEA_NAMESPACE_DINSPEC,
+ XDOMEA_NAMESPACE_GML_URI, XDOMEA_NAMESPACE_GML,
+ XDOMEA_NAMESPACE_XOEV_CODE_URI, XDOMEA_NAMESPACE_XOEV_CODE,
+ XDOMEA_NAMESPACE_XOEV_LC_URI, XDOMEA_NAMESPACE_XOEV_LC);
+
+ @Override
+ public String getPreferredPrefix(String namespaceUri, String suggestion, boolean requirePrefix) {
+ return NAMESPACE_MAP.getOrDefault(namespaceUri, suggestion);
+ }
+
+ @Override
+ public String[] getPreDeclaredNamespaceUris() {
+ return new String[] {
+ XDOMEA_NAMESPACE_DINSPEC_URI,
+ XDOMEA_NAMESPACE_GML_URI,
+ XDOMEA_NAMESPACE_XOEV_CODE_URI,
+ XDOMEA_NAMESPACE_XOEV_LC_URI
+ };
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XdomeaProperties.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XdomeaProperties.java
new file mode 100644
index 0000000000000000000000000000000000000000..2d2157c690d1b1c354875b477ec6163752cc1234
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XdomeaProperties.java
@@ -0,0 +1,26 @@
+package de.ozgcloud.alfa.export;
+
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.validation.annotation.Validated;
+
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+
+@Configuration
+@ConfigurationProperties("ozgcloud.xdomea")
+@Validated
+@Builder
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+public class XdomeaProperties {
+
+ private String behoerdenschluessel;
+ private String behoerdenschluesselUri;
+ private String behoerdenschluesselVersion;
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XdomeaPropertiesValidator.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XdomeaPropertiesValidator.java
new file mode 100644
index 0000000000000000000000000000000000000000..8cc320ecb6346fbc79bd42a2826b08bec38aaff3
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XdomeaPropertiesValidator.java
@@ -0,0 +1,44 @@
+package de.ozgcloud.alfa.export;
+
+import org.apache.commons.beanutils.BeanUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.validation.Errors;
+import org.springframework.validation.Validator;
+
+import de.ozgcloud.common.errorhandling.TechnicalException;
+
+public class XdomeaPropertiesValidator implements Validator {
+
+ @Override
+ public boolean supports(Class<?> clazz) {
+ return XdomeaProperties.class.isAssignableFrom(clazz);
+ }
+
+ @Override
+ public void validate(Object target, Errors errors) {
+ var properties = (XdomeaProperties) target;
+ validateBehoerdenschluesselProperties(errors, properties);
+ }
+
+ private void validateBehoerdenschluesselProperties(Errors errors, XdomeaProperties properties) {
+ if (StringUtils.isNotBlank(properties.getBehoerdenschluessel())) {
+ validateNotBlank("behoerdenschluesselUri", properties, errors);
+ validateNotBlank("behoerdenschluesselVersion", properties, errors);
+ }
+ }
+
+ private void validateNotBlank(String propertyName, XdomeaProperties properties, Errors errors) {
+ getPropertyValue(propertyName, properties);
+ if (StringUtils.isBlank(getPropertyValue(propertyName, properties))) {
+ errors.rejectValue(propertyName, String.format("ozgcloud.xdomea.%s.empty", propertyName), String.format("%s must be set", propertyName));
+ }
+ }
+
+ private static String getPropertyValue(String fieldName, XdomeaProperties properties) {
+ try {
+ return BeanUtils.getSimpleProperty(properties, fieldName);
+ } catch (Exception e) {
+ throw new TechnicalException("Property does not exist", e);
+ }
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XdomeaXmlMarshaller.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XdomeaXmlMarshaller.java
new file mode 100644
index 0000000000000000000000000000000000000000..441bd579380934ebdfe3d26a587d92afe4f711b5
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/export/XdomeaXmlMarshaller.java
@@ -0,0 +1,24 @@
+package de.ozgcloud.alfa.export;
+
+import java.io.StringWriter;
+
+import javax.xml.transform.stream.StreamResult;
+
+import org.springframework.oxm.jaxb.Jaxb2Marshaller;
+import org.springframework.stereotype.Component;
+
+import de.xoev.xdomea.AbgabeAbgabe0401;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor
+@Component
+public class XdomeaXmlMarshaller {
+
+ private final Jaxb2Marshaller marshaller;
+
+ public String marshal(AbgabeAbgabe0401 abgabe) {
+ var stringWriter = new StringWriter();
+ marshaller.marshal(abgabe, new StreamResult(stringWriter));
+ return stringWriter.toString();
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/file/DokumentTypeBuilder.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/file/DokumentTypeBuilder.java
new file mode 100644
index 0000000000000000000000000000000000000000..f0a11becc28fcd9642d620b1298f5d59ead96e1a
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/file/DokumentTypeBuilder.java
@@ -0,0 +1,82 @@
+package de.ozgcloud.alfa.file;
+
+import org.apache.commons.lang3.StringUtils;
+
+import de.ozgcloud.alfa.common.IdentifikationObjektTypeBuilder;
+import de.ozgcloud.alfa.common.VersionTypeBuilder;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.xoev.xdomea.AllgemeineMetadatenType;
+import de.xoev.xdomea.DokumentType;
+import de.xoev.xdomea.IdentifikationObjektType;
+import de.xoev.xdomea.MediumCodeType;
+import de.xoev.xdomea.VersionType;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+public class DokumentTypeBuilder {
+
+ static final String VERSION_NUMMER = "1";
+ static final String ALLGEMEINE_METADATEN_MEDIUM_CODE = "001";
+
+ private Long ordinalNumber;
+ private String formEngineName;
+ private OzgFile ozgFile;
+
+ public static DokumentTypeBuilder builder() {
+ return new DokumentTypeBuilder();
+ }
+
+ public DokumentTypeBuilder withOrdinalNumber(Long ordinalNumber) {
+ this.ordinalNumber = ordinalNumber;
+ return this;
+ }
+
+ public DokumentTypeBuilder withFormEngineName(String formEngineName) {
+ this.formEngineName = formEngineName;
+ return this;
+ }
+
+ public DokumentTypeBuilder withOzgFile(OzgFile ozgFile) {
+ this.ozgFile = ozgFile;
+ return this;
+ }
+
+ public DokumentType build() {
+ var dokumentType = new DokumentType();
+ dokumentType.setIdentifikation(createIdentifikation());
+ dokumentType.setAllgemeineMetadaten(createAllgemeineMetadaten());
+ dokumentType.getVersion().add(createVersionType());
+ return dokumentType;
+ }
+
+ VersionType createVersionType() {
+ return VersionTypeBuilder.builder()
+ .withOzgFile(ozgFile)
+ .withErsteller(formEngineName)
+ .withSonstigerName(StringUtils.EMPTY)
+ .build();
+ }
+
+ IdentifikationObjektType createIdentifikation() {
+ return IdentifikationObjektTypeBuilder.builder()
+ .withObjectID(ozgFile.getId().toString())
+ .withOrdinalNumber(ordinalNumber)
+ .build();
+ }
+
+ AllgemeineMetadatenType createAllgemeineMetadaten() {
+ var allgemeineMetadaten = new AllgemeineMetadatenType();
+ allgemeineMetadaten.setBetreff(ozgFile.getName());
+ allgemeineMetadaten.setKennzeichen(StringUtils.EMPTY);
+ allgemeineMetadaten.setBemerkung(StringUtils.EMPTY);
+ allgemeineMetadaten.setMedium(createMediumCode());
+ return allgemeineMetadaten;
+ }
+
+ private MediumCodeType createMediumCode() {
+ var mediumCode = new MediumCodeType();
+ mediumCode.setCode(ALLGEMEINE_METADATEN_MEDIUM_CODE);
+ return mediumCode;
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/file/ExportFileService.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/file/ExportFileService.java
new file mode 100644
index 0000000000000000000000000000000000000000..fd7442319cbf13109c91a94e72a04cc5d5af764d
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/file/ExportFileService.java
@@ -0,0 +1,46 @@
+package de.ozgcloud.alfa.file;
+
+import java.io.OutputStream;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.stream.Stream;
+
+import org.springframework.stereotype.Service;
+
+import de.ozgcloud.alfa.common.binaryfile.BinaryFileService;
+import de.ozgcloud.alfa.common.binaryfile.FileId;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileService;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.xoev.xdomea.DokumentType;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor
+@Service
+public class ExportFileService {
+
+ private final OzgFileService ozgFileService;
+ private final BinaryFileService binaryFileService;
+
+ public Stream<OzgFile> getRepresentations(VorgangWithEingang vorgang) {
+ return ozgFileService.getRepresentations(vorgang.getId());
+ }
+
+ public Stream<OzgFile> getAttachments(VorgangWithEingang vorgang) {
+ return ozgFileService.getAttachments(vorgang.getId());
+ }
+
+ public Stream<DokumentType> createDokumentTypes(List<OzgFile> ozgFiles, String formEngineName) {
+ var ordinalNumberGenerator = new AtomicLong(1);
+ return ozgFiles.stream().map(ozgFile -> DokumentTypeBuilder.builder()
+ .withOrdinalNumber(ordinalNumberGenerator.getAndIncrement())
+ .withFormEngineName(formEngineName)
+ .withOzgFile(ozgFile)
+ .build());
+ }
+
+ public void writeOzgFile(FileId fileId, OutputStream outputStream) {
+ binaryFileService.writeFileContent(fileId, outputStream);
+ }
+
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/historie/ExportHistorieService.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/historie/ExportHistorieService.java
new file mode 100644
index 0000000000000000000000000000000000000000..4f3e62cffd7e5a5e07f7dccc55a2f8ca59e092f7
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/historie/ExportHistorieService.java
@@ -0,0 +1,66 @@
+package de.ozgcloud.alfa.historie;
+
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+
+import de.ozgcloud.alfa.common.DateConverter;
+import de.ozgcloud.alfa.common.command.CommandOrder;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.xoev.xdomea.HistorienProtokollInformationType;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor
+@Service
+public class ExportHistorieService {
+
+ private final VorgangChangeHistoryService vorgangChangeHistoryService;
+
+ public Stream<HistorienProtokollInformationType> createHistorienProtokollInformationTypes(VorgangWithEingang vorgang) {
+ var history = vorgangChangeHistoryService.createVorgangChangeHistory(vorgang);
+ return Stream.of(
+ history.getStatusChangeHistory().stream().map(this::createHistorienProtokollInformationType),
+ history.getAktenzeichenChangeHistory().stream().map(this::createHistorienProtokollInformationType),
+ history.getAssignedUserChangeHistory().stream().map(this::createHistorienProtokollInformationType))
+ .flatMap(Function.identity());
+ }
+
+ HistorienProtokollInformationType createHistorienProtokollInformationType(VorgangChange vorgangChange) {
+ var historienProtokollInformationType = new HistorienProtokollInformationType();
+ historienProtokollInformationType.setMetadatumAlterWert(createValueBeforeChange(vorgangChange));
+ historienProtokollInformationType.setMetadatumNeuerWert(createValueAfterChange(vorgangChange));
+ historienProtokollInformationType.setAkteur(createAkteur(vorgangChange));
+ historienProtokollInformationType.setDatumUhrzeit(DateConverter.toXmlGregorianCalendar(vorgangChange.getFinishedAt()));
+ historienProtokollInformationType.setAktion(vorgangChange.getOrder());
+ return historienProtokollInformationType;
+ }
+
+ String createAkteur(VorgangChange vorgangChange) {
+ return appendOrganisationseinheitenID(vorgangChange.getAuthorFullName(), vorgangChange.getOrganisationseinheitenID());
+ }
+
+ String createValueBeforeChange(VorgangChange vorgangChange) {
+ return createValueChange(vorgangChange, vorgangChange.getValueBeforeChange());
+ }
+
+ String createValueAfterChange(VorgangChange vorgangChange) {
+ return createValueChange(vorgangChange, vorgangChange.getValueAfterChange());
+ }
+
+ private String createValueChange(VorgangChange vorgangChange, String valueChange) {
+ if (isAssignUserOrder(vorgangChange)) {
+ return appendOrganisationseinheitenID(valueChange, vorgangChange.getOrganisationseinheitenID());
+ }
+ return valueChange;
+ }
+
+ private boolean isAssignUserOrder(VorgangChange vorgangChange) {
+ return vorgangChange.getOrder().equals(CommandOrder.ASSIGN_USER.name());
+ }
+
+ String appendOrganisationseinheitenID(String text, String organisationseinheitenID) {
+ return StringUtils.isNotBlank(text) ? text + "; " + organisationseinheitenID : StringUtils.EMPTY;
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/kommentar/DokumentTypeBuilder.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/kommentar/DokumentTypeBuilder.java
new file mode 100644
index 0000000000000000000000000000000000000000..26ca34e45be143fbd7aa2d46c5cd21f223416835
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/kommentar/DokumentTypeBuilder.java
@@ -0,0 +1,79 @@
+package de.ozgcloud.alfa.kommentar;
+
+import java.util.Collections;
+import java.util.List;
+
+import de.ozgcloud.alfa.common.AnlageDokumentTypeBuilder;
+import de.ozgcloud.alfa.common.DateConverter;
+import de.ozgcloud.alfa.common.IdentifikationObjektTypeBuilder;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.xoev.xdomea.AnlageDokumentType;
+import de.xoev.xdomea.DokumentType;
+import de.xoev.xdomea.HistorienProtokollInformationType;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+class DokumentTypeBuilder {
+
+ static final String TYP = "Notiz";
+ static final String AKTION = "CREATE_KOMMENTAR";
+
+ private Kommentar kommentar;
+ private List<OzgFile> kommentarAttachments = Collections.emptyList();
+ private String authorFullName;
+ private String organisationseinheitenID;
+
+ public static DokumentTypeBuilder builder() {
+ return new DokumentTypeBuilder();
+ }
+
+ public DokumentTypeBuilder withKommentar(Kommentar kommentar) {
+ this.kommentar = kommentar;
+ return this;
+ }
+
+ public DokumentTypeBuilder withKommentarAttachments(List<OzgFile> kommentarAttachments) {
+ this.kommentarAttachments = kommentarAttachments;
+ return this;
+ }
+
+ public DokumentTypeBuilder withAuthorFullName(String authorFullName) {
+ this.authorFullName = authorFullName;
+ return this;
+ }
+
+ public DokumentTypeBuilder withOrganisationseinheitenID(String organisationseinheitenID) {
+ this.organisationseinheitenID = organisationseinheitenID;
+ return this;
+ }
+
+ public DokumentType build() {
+ var dokumentType = new DokumentType();
+ dokumentType.setIdentifikation(IdentifikationObjektTypeBuilder.builder()
+ .withObjectID(kommentar.getId())
+ .build());
+ dokumentType.setTyp(TYP);
+ dokumentType.getHistorienProtokollInformation().add(createHistorie());
+ kommentarAttachments.stream().map(this::createAnlage).forEach(dokumentType.getAnlage()::add);
+ return dokumentType;
+ }
+
+ AnlageDokumentType createAnlage(OzgFile ozgFile) {
+ return AnlageDokumentTypeBuilder.builder().withOzgFile(ozgFile).build();
+ }
+
+ HistorienProtokollInformationType createHistorie() {
+ var historienProtokollInformationType = new HistorienProtokollInformationType();
+ historienProtokollInformationType.setMetadatumName(kommentar.getText());
+ historienProtokollInformationType.setAkteur(createAkteur());
+ historienProtokollInformationType.setDatumUhrzeit(DateConverter.toXmlGregorianCalendar(kommentar.getCreatedAt()));
+ historienProtokollInformationType.setAktion(AKTION);
+ return historienProtokollInformationType;
+ }
+
+ String createAkteur() {
+ return this.authorFullName + "; " + this.organisationseinheitenID;
+ }
+
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/kommentar/ExportKommentarService.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/kommentar/ExportKommentarService.java
new file mode 100644
index 0000000000000000000000000000000000000000..1d4d9e209314cb629342e45e5c0ca18ab9e57fb1
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/kommentar/ExportKommentarService.java
@@ -0,0 +1,67 @@
+package de.ozgcloud.alfa.kommentar;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+import org.springframework.stereotype.Service;
+
+import de.ozgcloud.alfa.common.binaryfile.BinaryFileService;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.user.UserId;
+import de.ozgcloud.alfa.common.user.UserService;
+import de.ozgcloud.alfa.kommentar.KommentarsExportData.KommentarsExportDataBuilder;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor
+@Service
+public class ExportKommentarService {
+
+ private final KommentarService kommentarService;
+ private final BinaryFileService binaryFileService;
+ private final UserService userService;
+
+ public KommentarsExportData createExportData(VorgangWithEingang vorgang) {
+ KommentarsExportDataBuilder builder = KommentarsExportData.builder();
+ getKommentare(vorgang)
+ .map(kommentar -> createKommentarExportData(vorgang, kommentar))
+ .forEach(kommentarExportData -> addKommentarExportData(kommentarExportData, builder));
+ return builder.build();
+ }
+
+ KommentarExportData createKommentarExportData(VorgangWithEingang vorgang, Kommentar kommentar){
+ return new KommentarExportData(vorgang.getOrganisationseinheitenID(), kommentar);
+ }
+
+ void addKommentarExportData(KommentarExportData kommentarExportData, KommentarsExportDataBuilder builder) {
+ List<OzgFile> attachments = getAttachments(kommentarExportData.kommentar);
+
+ var dokumentType = DokumentTypeBuilder.builder()
+ .withKommentarAttachments(attachments)
+ .withKommentar(kommentarExportData.kommentar)
+ .withOrganisationseinheitenID(kommentarExportData.organisationsEinheitenID)
+ .withAuthorFullName(getAuthorFullName(kommentarExportData.kommentar))
+ .build();
+
+ builder.dokumentType(dokumentType);
+ builder.attachments(attachments);
+ }
+
+ List<OzgFile> getAttachments(Kommentar kommentar) {
+ return binaryFileService.getFiles(kommentar.getAttachments()).toList();
+ }
+
+ String getAuthorFullName(Kommentar kommentar) {
+ return userService.getById(UserId.from(kommentar.getCreatedBy())).getFullName();
+ }
+
+ Stream<Kommentar> getKommentare(VorgangWithEingang vorgang) {
+ return kommentarService.findByVorgangId(vorgang.getId());
+ }
+
+ record KommentarExportData(
+ String organisationsEinheitenID,
+ Kommentar kommentar
+ ) {
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/kommentar/KommentarsExportData.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/kommentar/KommentarsExportData.java
new file mode 100644
index 0000000000000000000000000000000000000000..a550d397e705d277af24be94fa742681a792997f
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/kommentar/KommentarsExportData.java
@@ -0,0 +1,22 @@
+package de.ozgcloud.alfa.kommentar;
+
+import java.util.List;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.xoev.xdomea.DokumentType;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Singular;
+
+@Builder
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+@Getter
+public class KommentarsExportData {
+
+ @Singular
+ private List<DokumentType> dokumentTypes;
+ @Singular
+ private List<OzgFile> attachments;
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/postfach/DokumentTypeBuilder.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/postfach/DokumentTypeBuilder.java
new file mode 100644
index 0000000000000000000000000000000000000000..1a82477373682b64b4581952fb28345ac655937c
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/postfach/DokumentTypeBuilder.java
@@ -0,0 +1,93 @@
+package de.ozgcloud.alfa.postfach;
+
+import java.time.ZonedDateTime;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import de.ozgcloud.alfa.common.AnlageDokumentTypeBuilder;
+import de.ozgcloud.alfa.common.DateConverter;
+import de.ozgcloud.alfa.common.IdentifikationObjektTypeBuilder;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.user.UserProfile;
+import de.ozgcloud.alfa.postfach.PostfachMail.Direction;
+import de.xoev.xdomea.AnlageDokumentType;
+import de.xoev.xdomea.DokumentType;
+import de.xoev.xdomea.HistorienProtokollInformationType;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+class DokumentTypeBuilder {
+ private static final String TYP = "Nachricht";
+ private static final String ANTRAGSTELLER = "Antragsteller";
+ private final Map<Direction, String> mapDirectionToString = Map.of(
+ Direction.IN, "Nachricht empfangen",
+ Direction.OUT, "Nachricht gesendet");
+
+ private PostfachMail postfachMail;
+ private List<OzgFile> ozgFileAttachments;
+ private UserProfile userProfile;
+ private String organisationseinheitenId;
+
+ public static DokumentTypeBuilder builder() {
+ return new DokumentTypeBuilder();
+ }
+
+ public DokumentTypeBuilder withPostfachMail(PostfachMail postfachMail) {
+ this.postfachMail = postfachMail;
+ return this;
+ }
+
+ public DokumentTypeBuilder withOzgFiles(List<OzgFile> ozgFiles) {
+ this.ozgFileAttachments = ozgFiles;
+ return this;
+ }
+
+ public DokumentTypeBuilder withUserProfile(UserProfile userProfile) {
+ this.userProfile = userProfile;
+ return this;
+ }
+
+ public DokumentTypeBuilder withOrganisationseinheitenId(String organisationseinheitenId) {
+ this.organisationseinheitenId = organisationseinheitenId;
+ return this;
+ }
+
+ public DokumentType build() {
+ var dokumentType = new DokumentType();
+ dokumentType.setIdentifikation(IdentifikationObjektTypeBuilder.builder()
+ .withObjectID(postfachMail.getId())
+ .build());
+ dokumentType.setTyp(TYP);
+ dokumentType.getHistorienProtokollInformation().add(createHistorienProtokollInformation());
+ Optional.ofNullable(ozgFileAttachments).orElseGet(Collections::emptyList).stream().map(this::createAnlage)
+ .forEach(dokumentType.getAnlage()::add);
+ return dokumentType;
+ }
+
+ AnlageDokumentType createAnlage(OzgFile ozgFile) {
+ return AnlageDokumentTypeBuilder.builder().withOzgFile(ozgFile).build();
+ }
+
+ HistorienProtokollInformationType createHistorienProtokollInformation() {
+ var historienInformation = new HistorienProtokollInformationType();
+ historienInformation.setMetadatumName(postfachMail.getMailBody());
+ historienInformation.setAkteur(getAkteur());
+ historienInformation.setDatumUhrzeit(DateConverter.toXmlGregorianCalendar(getSentTime()));
+ historienInformation.setAktion(mapDirectionToString.get(postfachMail.getDirection()));
+ return historienInformation;
+ }
+
+ String getAkteur() {
+ return Optional.ofNullable(userProfile)
+ .map(user -> user.getFullName() + "; " + organisationseinheitenId)
+ .orElse(ANTRAGSTELLER);
+ }
+
+ ZonedDateTime getSentTime() {
+ return postfachMail.getDirection() == Direction.IN ? postfachMail.getCreatedAt() : postfachMail.getSentAt();
+ }
+
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/postfach/ExportNachrichtService.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/postfach/ExportNachrichtService.java
new file mode 100644
index 0000000000000000000000000000000000000000..40dfc97e8ef03910763677008b0468fb2c5044fa
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/postfach/ExportNachrichtService.java
@@ -0,0 +1,62 @@
+package de.ozgcloud.alfa.postfach;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import org.springframework.stereotype.Service;
+
+import de.ozgcloud.alfa.common.binaryfile.BinaryFileService;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.user.UserProfile;
+import de.ozgcloud.alfa.common.user.UserService;
+import de.ozgcloud.alfa.postfach.PostfachMailExportData.PostfachMailExportDataBuilder;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.xoev.xdomea.DokumentType;
+import lombok.RequiredArgsConstructor;
+
+@Service
+@RequiredArgsConstructor
+public class ExportNachrichtService {
+ private final PostfachMailService postfachMailService;
+ private final BinaryFileService binaryFileService;
+ private final UserService userService;
+
+ public PostfachMailExportData createExportData(VorgangWithEingang vorgang) {
+ var builder = PostfachMailExportData.builder();
+ getPostfachMails(vorgang.getId())
+ .forEach(mail -> addPostfachMailExportData(
+ new PostfachMailExportInput(mail, getOrganisationseinheitenId(vorgang), getAttachments(mail)), builder));
+ return builder.build();
+ }
+
+ public Stream<PostfachMail> getPostfachMails(String vorgangId) {
+ return postfachMailService.getAll(vorgangId);
+ }
+
+ private String getOrganisationseinheitenId(VorgangWithEingang vorgang) {
+ return vorgang.getEingang().getZustaendigeStelle().getOrganisationseinheitenId();
+ }
+
+ List<OzgFile> getAttachments(PostfachMail postfachMail) {
+ return binaryFileService.getFiles(postfachMail.getAttachments()).toList();
+ }
+
+ void addPostfachMailExportData(PostfachMailExportInput postfachMailExportInput, PostfachMailExportDataBuilder builder) {
+ builder.attachments(postfachMailExportInput.attachments());
+ builder.dokumentType(buildDokumentType(postfachMailExportInput));
+ }
+
+ DokumentType buildDokumentType(PostfachMailExportInput postfachMailExportInput) {
+ return DokumentTypeBuilder.builder()
+ .withPostfachMail(postfachMailExportInput.postfachMail())
+ .withOzgFiles(postfachMailExportInput.attachments())
+ .withUserProfile(getUserProfile(postfachMailExportInput.postfachMail()).orElse(null))
+ .withOrganisationseinheitenId(postfachMailExportInput.organisationseinheitenId())
+ .build();
+ }
+
+ Optional<UserProfile> getUserProfile(PostfachMail postfachMail) {
+ return Optional.ofNullable(postfachMail.getCreatedBy()).map(userService::getById);
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/postfach/PostfachMailExportData.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/postfach/PostfachMailExportData.java
new file mode 100644
index 0000000000000000000000000000000000000000..7c359508b96cd8a6471be34307bd77b0044da3c7
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/postfach/PostfachMailExportData.java
@@ -0,0 +1,23 @@
+package de.ozgcloud.alfa.postfach;
+
+import java.util.List;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.xoev.xdomea.DokumentType;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Getter;
+import lombok.Singular;
+
+@Builder
+@Getter
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class PostfachMailExportData {
+
+ @Singular
+ private List<DokumentType> dokumentTypes;
+ @Singular
+ private List<OzgFile> attachments;
+
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/postfach/PostfachMailExportInput.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/postfach/PostfachMailExportInput.java
new file mode 100644
index 0000000000000000000000000000000000000000..07ce2b45857e032667efbbd9d0c75a1497c6f95e
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/postfach/PostfachMailExportInput.java
@@ -0,0 +1,8 @@
+package de.ozgcloud.alfa.postfach;
+
+import java.util.List;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+
+record PostfachMailExportInput(PostfachMail postfachMail, String organisationseinheitenId, List<OzgFile> attachments) {
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/AnwendungsspezifischeErweiterungTypeCreator.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/AnwendungsspezifischeErweiterungTypeCreator.java
new file mode 100644
index 0000000000000000000000000000000000000000..05b2f17709d3e4c2a8c26d1fbce3c7315a20b078
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/AnwendungsspezifischeErweiterungTypeCreator.java
@@ -0,0 +1,27 @@
+package de.ozgcloud.alfa.vorgang;
+
+import java.util.Collections;
+
+import org.springframework.stereotype.Component;
+
+import de.xoev.xdomea.AnwendungsspezifischeErweiterungType;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor
+@Component
+class AnwendungsspezifischeErweiterungTypeCreator {
+
+ static final String KENNUNG = "IDOZGCloud1234567";
+ static final String NAME = "Anwendungsspezifische Erweiterung OZGCloud Basis";
+
+ private final FeldGruppeTypeCreator feldGruppeTypeCreator;
+
+ public AnwendungsspezifischeErweiterungType create(VorgangWithEingang vorgang) {
+ var ozgcloudErweiterungType = new AnwendungsspezifischeErweiterungType();
+ ozgcloudErweiterungType.setKennung(KENNUNG);
+ ozgcloudErweiterungType.setName(NAME);
+ ozgcloudErweiterungType.getFeldgruppe().addAll(Collections.singleton(feldGruppeTypeCreator.create(vorgang)));
+ return ozgcloudErweiterungType;
+ }
+
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/AnwendungsspezifischeErweiterungXMLTypeCreator.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/AnwendungsspezifischeErweiterungXMLTypeCreator.java
new file mode 100644
index 0000000000000000000000000000000000000000..2af8e7cd35c3b5eac78704fa035c3a9aece954e6
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/AnwendungsspezifischeErweiterungXMLTypeCreator.java
@@ -0,0 +1,19 @@
+package de.ozgcloud.alfa.vorgang;
+
+import org.springframework.stereotype.Component;
+
+import de.xoev.xdomea.AnwendungsspezifischeErweiterungXMLType;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor
+@Component
+public class AnwendungsspezifischeErweiterungXMLTypeCreator {
+
+ private final FormDataMapper formDataMapper;
+
+ public AnwendungsspezifischeErweiterungXMLType create(VorgangWithEingang vorgang) {
+ var erweiterungXmlType = new AnwendungsspezifischeErweiterungXMLType();
+ erweiterungXmlType.getAny().add(formDataMapper.toAntragsdaten(vorgang));
+ return erweiterungXmlType;
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/DatatypeMapper.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/DatatypeMapper.java
new file mode 100644
index 0000000000000000000000000000000000000000..9a740682a45f0793f2926172b98212060617c603
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/DatatypeMapper.java
@@ -0,0 +1,44 @@
+package de.ozgcloud.alfa.vorgang;
+
+import static java.util.Objects.*;
+
+import java.time.LocalDate;
+import java.time.ZonedDateTime;
+import java.util.Collection;
+
+import org.springframework.stereotype.Component;
+
+import de.xoev.xdomea.DatatypeType;
+
+@Component
+class DatatypeMapper {
+
+ public DatatypeType from(Object object) {
+ if (isNull(object)) {
+ return DatatypeType.STRING;
+ }
+ var objectClass = object.getClass();
+ if (String.class.equals(objectClass)) {
+ return DatatypeType.STRING;
+ }
+ if (Integer.class.equals(objectClass)) {
+ return DatatypeType.INTEGER;
+ }
+ if (Boolean.class.equals(objectClass)) {
+ return DatatypeType.BOOLEAN;
+ }
+ if (LocalDate.class.equals(objectClass)) {
+ return DatatypeType.DATE;
+ }
+ if (ZonedDateTime.class.equals(objectClass)) {
+ return DatatypeType.DATETIME;
+ }
+ if (Float.class.equals(objectClass)) {
+ return DatatypeType.FLOAT;
+ }
+ if (object instanceof Collection<?> collection && !collection.isEmpty()) {
+ return from(collection.iterator().next());
+ }
+ return DatatypeType.STRING;
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/ExportFelder.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/ExportFelder.java
new file mode 100644
index 0000000000000000000000000000000000000000..46db0e389e308eba98b8a9e9664306c1c972016b
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/ExportFelder.java
@@ -0,0 +1,61 @@
+package de.ozgcloud.alfa.vorgang;
+
+import de.ozgcloud.alfa.common.DatentypCode;
+import de.xoev.xdomea.DatentypCodeType;
+import de.xoev.xdomea.FeldType;
+
+enum ExportFelder {
+ LEIKA_ID("LeikaID", "ID einer Leistung aus dem OZG-Leistungskatalog", DatentypCode.STRING.getCode()),
+ DATUM_ANTRAGSEINGANG("DatumAntragseingang", "Das Datum des Antragseingangs", DatentypCode.DATE.getCode()),
+ NAME("Name", null, DatentypCode.STRING.getCode()),
+ VORNAME("Vorname", null, DatentypCode.STRING.getCode()),
+ GEBURTSDATUM("Geburtsdatum", null, DatentypCode.DATE.getCode()),
+ PLZ("PLZAntragsteller", null, DatentypCode.STRING.getCode());
+
+ private static final String LIST_URI = "urn:xoev-de:xdomea:codeliste:datentyp";
+ private static final String LIST_VERSION_ID = "1.1";
+
+ private String name;
+ private String beschreibung;
+ private String datentypCode;
+
+ ExportFelder(String name, String beschreibung, String datentypCode) {
+ this.name = name;
+ this.beschreibung = beschreibung;
+ this.datentypCode = datentypCode;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public String getBeschreibung() {
+ return beschreibung;
+ }
+
+ public String getDatentypCode() {
+ return datentypCode;
+ }
+
+ public FeldType createFeld(String wert) {
+ var feld = createFeld();
+ feld.setWert(wert);
+ return feld;
+ }
+
+ public FeldType createFeld() {
+ var feld = new FeldType();
+ feld.setName(name);
+ feld.setBeschreibung(beschreibung);
+ feld.setDatentyp(fromCode(datentypCode));
+ return feld;
+ }
+
+ private DatentypCodeType fromCode(String code) {
+ var type = new DatentypCodeType();
+ type.setCode(code);
+ type.setListURI(LIST_URI);
+ type.setListVersionID(LIST_VERSION_ID);
+ return type;
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/ExportVorgangService.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/ExportVorgangService.java
new file mode 100644
index 0000000000000000000000000000000000000000..49ae46dc6950161c2121bb7fc395a07cf96317ae
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/ExportVorgangService.java
@@ -0,0 +1,55 @@
+package de.ozgcloud.alfa.vorgang;
+
+import java.util.Optional;
+import java.util.UUID;
+
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Service;
+
+import de.xoev.xdomea.AkteType;
+import de.xoev.xdomea.AllgemeineMetadatenType;
+import de.xoev.xdomea.IdentifikationObjektType;
+import de.xoev.xdomea.NkAbgabeType;
+import de.xoev.xdomea.VorgangType;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor
+@Service
+public class ExportVorgangService {
+
+ private final VorgangService vorgangService;
+
+ private final VorgangTypeCreator vorgangTypeCreator;
+ private final KopfCreator kopfCreator;
+
+ public VorgangWithEingang getVorgang(String vorgangId) {
+ return vorgangService.findVorgangWithEingang(vorgangId);
+ }
+
+ public VorgangType createVorgangType(VorgangWithEingang vorgangWithEingang) {
+ return vorgangTypeCreator.create(vorgangWithEingang);
+ }
+
+ public NkAbgabeType createKopf(VorgangWithEingang vorgangWithEingang) {
+ return kopfCreator.createKopf(vorgangWithEingang);
+ }
+
+ public AkteType createAkteType(VorgangWithEingang vorgangWithEingang) {
+ var akteType = new AkteType();
+ akteType.setIdentifikation(createIdentifikationObjektType());
+ akteType.setAllgemeineMetadaten(createAllgemeineMetadatenType(vorgangWithEingang));
+ return akteType;
+ }
+
+ IdentifikationObjektType createIdentifikationObjektType() {
+ var identifikationObjektType = new IdentifikationObjektType();
+ identifikationObjektType.setID(UUID.randomUUID().toString());
+ return identifikationObjektType;
+ }
+
+ AllgemeineMetadatenType createAllgemeineMetadatenType(VorgangWithEingang vorgangWithEingang) {
+ var allgemeineMetadatenType = new AllgemeineMetadatenType();
+ allgemeineMetadatenType.setKennzeichen(Optional.ofNullable(vorgangWithEingang.getAktenzeichen()).orElse(StringUtils.EMPTY));
+ return allgemeineMetadatenType;
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/FeldGruppeTypeCreator.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/FeldGruppeTypeCreator.java
new file mode 100644
index 0000000000000000000000000000000000000000..6b22705890f313c97caae1fad6692ea7405dd208
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/FeldGruppeTypeCreator.java
@@ -0,0 +1,39 @@
+package de.ozgcloud.alfa.vorgang;
+
+import static java.util.Optional.*;
+
+import java.time.format.DateTimeFormatter;
+import java.util.List;
+
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Component;
+
+import de.xoev.xdomea.FeldType;
+import de.xoev.xdomea.FeldgruppeType;
+
+@Component
+class FeldGruppeTypeCreator {
+
+ static final String NAME = "FeldgruppeOZGCloudBasis";
+ static final String BESCHREIBUNG = "Feldgruppe für OZGCloud Basis";
+
+ public FeldgruppeType create(VorgangWithEingang vorgang) {
+ var feldgruppe = new FeldgruppeType();
+ feldgruppe.setName(NAME);
+ feldgruppe.setBeschreibung(BESCHREIBUNG);
+ feldgruppe.getFeld().addAll(createFeldType(vorgang));
+ return feldgruppe;
+ }
+
+ List<FeldType> createFeldType(VorgangWithEingang vorgang) {
+ var antragsteller = ofNullable(vorgang.getEingang()).flatMap(eingang -> ofNullable(eingang.getAntragsteller()));
+ return List.of(
+ ExportFelder.LEIKA_ID.createFeld(),
+ ExportFelder.DATUM_ANTRAGSEINGANG.createFeld(DateTimeFormatter.ISO_DATE_TIME.format(vorgang.getCreatedAt())),
+ ExportFelder.NAME.createFeld(antragsteller.flatMap(a -> ofNullable(a.getNachname())).orElse(StringUtils.EMPTY)),
+ ExportFelder.VORNAME.createFeld(antragsteller.flatMap(a -> ofNullable(a.getVorname())).orElse(StringUtils.EMPTY)),
+ ExportFelder.GEBURTSDATUM.createFeld(antragsteller.flatMap(a -> ofNullable(a.getGeburtsdatum())).orElse(StringUtils.EMPTY)),
+ ExportFelder.PLZ.createFeld(antragsteller.flatMap(a -> ofNullable(a.getPlz())).orElse(StringUtils.EMPTY)));
+ }
+
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/FormDataMapper.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/FormDataMapper.java
new file mode 100644
index 0000000000000000000000000000000000000000..b5b8a45e9e650bc8e193de707b082ec057e8758f
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/FormDataMapper.java
@@ -0,0 +1,101 @@
+package de.ozgcloud.alfa.vorgang;
+
+import static java.util.Objects.*;
+
+import java.time.ZonedDateTime;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+
+import org.springframework.stereotype.Component;
+
+import de.ozgcloud.alfa.common.DateConverter;
+import de.xoev.xdomea.Antragsdaten;
+import de.xoev.xdomea.AntragsdatenGroupType;
+import de.xoev.xdomea.AntragsdatenItemType;
+import de.xoev.xdomea.AntragsdatenMultiValueFieldType;
+import de.xoev.xdomea.AntragsdatenSingleValueFieldType;
+import de.xoev.xdomea.DatatypeType;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor
+@Component
+class FormDataMapper {
+
+ private final DatatypeMapper datatypeMapper;
+
+ public Antragsdaten toAntragsdaten(VorgangWithEingang vorgang) {
+ var antragsdaten = new Antragsdaten();
+ antragsdaten.getItem().addAll(mapFormData(vorgang));
+ antragsdaten.getItem().addAll(mapOtherData(vorgang));
+ return antragsdaten;
+ }
+
+ List<AntragsdatenItemType> mapFormData(VorgangWithEingang vorgang) {
+ return Optional.ofNullable(vorgang.getEingang()).map(Eingang::getFormData).map(this::mapData).orElse(List.of());
+ }
+
+ List<AntragsdatenItemType> mapOtherData(VorgangWithEingang vorgang) {
+ return Optional.ofNullable(vorgang.getEingang()).map(Eingang::getAntragsteller).map(Antragsteller::getOtherData).map(this::mapData)
+ .orElse(List.of());
+ }
+
+ List<AntragsdatenItemType> mapData(Map<String, Object> data) {
+ return buildItems(WrappedValueExtractor.extractWrappedValues(data));
+ }
+
+ List<AntragsdatenItemType> buildItems(Map<?, ?> formData) {
+ var items = new ArrayList<AntragsdatenItemType>();
+ for (var formDataEntry : formData.entrySet()) {
+ var key = (String) formDataEntry.getKey();
+ var value = formDataEntry.getValue();
+ if (value instanceof Map<?, ?> map) {
+ items.add(buildAntragsdatenGroup(key, map));
+ } else if (value instanceof Collection<?> collection) {
+ items.add(buildMultiValueField(key, collection));
+ } else {
+ items.add(buildSingleValueField(key, value));
+
+ }
+ }
+ return items;
+ }
+
+ AntragsdatenItemType buildAntragsdatenGroup(String name, Map<?, ?> values) {
+ var antragsGroup = new AntragsdatenGroupType();
+ antragsGroup.setName(name);
+ antragsGroup.getItem().addAll(buildItems(values));
+ return antragsGroup;
+ }
+
+ AntragsdatenItemType buildMultiValueField(String name, Collection<?> values) {
+ var multiValue = new AntragsdatenMultiValueFieldType();
+ multiValue.setName(name);
+ var datatype = datatypeMapper.from(values);
+ multiValue.setType(datatype);
+ var multiValueList = multiValue.getValue();
+ values.stream().map(v -> formatValue(datatype, v)).forEach(multiValueList::add);
+ return multiValue;
+ }
+
+ AntragsdatenItemType buildSingleValueField(String name, Object value) {
+ var singleValue = new AntragsdatenSingleValueFieldType();
+ singleValue.setName(name);
+ if (nonNull(value)) {
+ var datatype = datatypeMapper.from(value);
+ singleValue.setType(datatype);
+ singleValue.setValue(formatValue(datatype, value));
+ }
+ return singleValue;
+ }
+
+ Object formatValue(DatatypeType datatype, Object value) {
+ return switch (datatype) {
+ case STRING -> String.valueOf(value);
+ case DATETIME -> DateConverter.toXmlGregorianCalendar((ZonedDateTime) value);
+ default -> value;
+ };
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/KontaktTypeCreator.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/KontaktTypeCreator.java
new file mode 100644
index 0000000000000000000000000000000000000000..8ca2aced5adb1a651b78c066c088395449b3fbd8
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/KontaktTypeCreator.java
@@ -0,0 +1,58 @@
+package de.ozgcloud.alfa.vorgang;
+
+import java.util.Optional;
+import java.util.function.Predicate;
+
+import javax.xml.datatype.XMLGregorianCalendar;
+
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Component;
+
+import de.ozgcloud.alfa.common.DateConverter;
+import de.ozgcloud.common.errorhandling.TechnicalException;
+import de.xoev.xdomea.GeburtType;
+import de.xoev.xdomea.KontaktType;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor
+@Component
+class KontaktTypeCreator {
+
+ private static final Predicate<Antragsteller> HAS_VORNAME = antragsteller -> StringUtils.isNotBlank(antragsteller.getVorname());
+ private static final Predicate<Antragsteller> HAS_NACHNAME = antragsteller -> StringUtils.isNotBlank(antragsteller.getNachname());
+ private static final Predicate<Antragsteller> HAS_ANREDE = antragsteller -> StringUtils.isNotBlank(antragsteller.getAnrede());
+ private static final Predicate<Antragsteller> HAS_GEBURTSDATUM = antragsteller -> geburtsdatumToISO(antragsteller).isPresent();
+
+ private final NameNatuerlichePersonTypeCreator nameNatuerlichePersonTypeCreator;
+
+ public Optional<KontaktType> create(VorgangWithEingang vorgang) {
+ return getAntragstellerIfHasRequiredData(vorgang).map(this::toKontaktType);
+ }
+
+ Optional<Antragsteller> getAntragstellerIfHasRequiredData(VorgangWithEingang vorgang) {
+ return Optional.ofNullable(vorgang.getEingang().getAntragsteller())
+ .filter(HAS_VORNAME.or(HAS_NACHNAME).or(HAS_ANREDE).or(HAS_GEBURTSDATUM));
+ }
+
+ KontaktType toKontaktType(Antragsteller antragsteller) {
+ var kontakt = new KontaktType();
+ kontakt.setName(nameNatuerlichePersonTypeCreator.create(antragsteller));
+
+ geburtsdatumToISO(antragsteller)
+ .map(this::createGeburtType)
+ .ifPresent(kontakt::setGeburt);
+
+ return kontakt;
+ }
+
+ static Optional<XMLGregorianCalendar> geburtsdatumToISO(Antragsteller antragsteller) {
+ return DateConverter.convertGermanFormatToISO(antragsteller.getGeburtsdatum());
+ }
+
+ GeburtType createGeburtType(XMLGregorianCalendar geburtsdatumIso) {
+ var geburtType = new GeburtType();
+ geburtType.setDatum(geburtsdatumIso);
+ return geburtType;
+ }
+
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/KopfCreator.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/KopfCreator.java
new file mode 100644
index 0000000000000000000000000000000000000000..5305519177c60d83ac4de118977b4fbd4c549fa2
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/KopfCreator.java
@@ -0,0 +1,93 @@
+package de.ozgcloud.alfa.vorgang;
+
+import java.time.ZoneOffset;
+import java.time.ZonedDateTime;
+
+import org.springframework.stereotype.Component;
+
+import de.ozgcloud.alfa.common.DateConverter;
+import de.ozgcloud.alfa.common.UUIDConverter;
+import de.ozgcloud.alfa.export.XdomeaProperties;
+import de.xoev.xdomea.BehoerdenkennungType;
+import de.xoev.xdomea.Code;
+import de.xoev.xdomea.KontaktType;
+import de.xoev.xdomea.NachrichtentypCodeType;
+import de.xoev.xdomea.NkAbgabeType;
+import de.xoev.xdomea.OrganisationseinheitType;
+import de.xoev.xdomea.SystemType;
+import io.micrometer.common.util.StringUtils;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor
+@Component
+class KopfCreator {
+
+ static final String NACHRICHTENTYP_CODE_TYPE_LIST_URI = "urn:xoev-de:xdomea:codeliste:nachrichtentyp";
+ static final String NACHRICHTENTYP_CODE_TYPE_LIST_VERSION_ID = "2.0";
+ static final String NACHRICHTENTYP_ABGABE_ABGABE_TYPE_CODE = "0401";
+ static final String PRODUKT_NAME = "OZG-Cloud";
+
+ private final XdomeaProperties xdomeaProperties;
+
+ public NkAbgabeType createKopf(VorgangWithEingang vorgang) {
+ var nkAbgabeType = new NkAbgabeType();
+ nkAbgabeType.setProzessID(UUIDConverter.fromObjectId(vorgang.getId()));
+ nkAbgabeType.setNachrichtentyp(createNachrichtentyp());
+ nkAbgabeType.setErstellungszeitpunkt(DateConverter.toXmlGregorianCalendar(ZonedDateTime.now(ZoneOffset.UTC)));
+ nkAbgabeType.setAbsender(createAbsender(vorgang.getEingang().getZustaendigeStelle().getOrganisationseinheitenId()));
+ nkAbgabeType.setEmpfaenger(createKontaktType());
+ nkAbgabeType.setSendendesSystem(createSendendesSystem());
+ nkAbgabeType.setImportbestaetigung(true);
+ nkAbgabeType.setEmpfangsbestaetigung(true);
+ return nkAbgabeType;
+ }
+
+ NachrichtentypCodeType createNachrichtentyp() {
+ var nachrichtentypCode = new NachrichtentypCodeType();
+ nachrichtentypCode.setCode(NACHRICHTENTYP_ABGABE_ABGABE_TYPE_CODE);
+ nachrichtentypCode.setListURI(NACHRICHTENTYP_CODE_TYPE_LIST_URI);
+ nachrichtentypCode.setListVersionID(NACHRICHTENTYP_CODE_TYPE_LIST_VERSION_ID);
+ return nachrichtentypCode;
+ }
+
+ KontaktType createAbsender(String organisationseinheitId) {
+ var absender = createKontaktType();
+ absender.setOrganisationseinheit(createOrganisationseinheitType(organisationseinheitId));
+ return absender;
+ }
+
+ KontaktType createKontaktType() {
+ var kontakt = new KontaktType();
+ if (StringUtils.isNotBlank(xdomeaProperties.getBehoerdenschluessel())) {
+ kontakt.setBehoerdenkennung(createBehoerdenkennung());
+ }
+ return kontakt;
+ }
+
+ OrganisationseinheitType createOrganisationseinheitType(String organisationseinheitId) {
+ var organisationseinheit = new OrganisationseinheitType();
+ organisationseinheit.setName(organisationseinheitId);
+ return organisationseinheit;
+ }
+
+ BehoerdenkennungType createBehoerdenkennung() {
+ var behoerdenkennungType = new BehoerdenkennungType();
+ behoerdenkennungType.setBehoerdenschluessel(createBehoerdenschluessel());
+ return behoerdenkennungType;
+ }
+
+ Code createBehoerdenschluessel() {
+ var behoerdenschluessel = new Code();
+ behoerdenschluessel.setCode(xdomeaProperties.getBehoerdenschluessel());
+ behoerdenschluessel.setListURI(xdomeaProperties.getBehoerdenschluesselUri());
+ behoerdenschluessel.setListVersionID(xdomeaProperties.getBehoerdenschluesselVersion());
+ return behoerdenschluessel;
+ }
+
+ SystemType createSendendesSystem() {
+ var sendendesSystem = new SystemType();
+ sendendesSystem.setProduktname(PRODUKT_NAME);
+ return sendendesSystem;
+ }
+
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/NameNatuerlichePersonTypeCreator.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/NameNatuerlichePersonTypeCreator.java
new file mode 100644
index 0000000000000000000000000000000000000000..3f4431f47450482dd6c2543460f19219f3d1d5c5
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/NameNatuerlichePersonTypeCreator.java
@@ -0,0 +1,29 @@
+package de.ozgcloud.alfa.vorgang;
+
+import static java.util.Optional.*;
+
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Component;
+
+import de.xoev.xdomea.AllgemeinerNameType;
+import de.xoev.xdomea.NameNatuerlichePersonType;
+
+@Component
+class NameNatuerlichePersonTypeCreator {
+
+ public NameNatuerlichePersonType create(Antragsteller antragsteller) {
+ var nameNatuerlichPerson = new NameNatuerlichePersonType();
+ nameNatuerlichPerson.setAnrede(ofNullable(antragsteller).map(Antragsteller::getAnrede).orElse(StringUtils.EMPTY));
+ nameNatuerlichPerson.setVorname(
+ createAllgemeinerNameType(ofNullable(antragsteller).map(Antragsteller::getVorname).orElse(StringUtils.EMPTY)));
+ nameNatuerlichPerson.setFamilienname(
+ createAllgemeinerNameType(ofNullable(antragsteller).map(Antragsteller::getNachname).orElse(StringUtils.EMPTY)));
+ return nameNatuerlichPerson;
+ }
+
+ private AllgemeinerNameType createAllgemeinerNameType(String name) {
+ var allgemeinerName = new AllgemeinerNameType();
+ allgemeinerName.setName(name);
+ return allgemeinerName;
+ }
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/VorgangTypeCreator.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/VorgangTypeCreator.java
new file mode 100644
index 0000000000000000000000000000000000000000..11b5a0502926d5b23aa29665cd47b64cf93c5c37
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/VorgangTypeCreator.java
@@ -0,0 +1,57 @@
+package de.ozgcloud.alfa.vorgang;
+
+import java.util.UUID;
+
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.stereotype.Component;
+
+import de.xoev.xdomea.AllgemeineMetadatenType;
+import de.xoev.xdomea.IdentifikationObjektType;
+import de.xoev.xdomea.MediumCodeType;
+import de.xoev.xdomea.VorgangType;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor
+@Component
+class VorgangTypeCreator {
+
+ static final Long NUMMER_IM_UEBERGEORDNETEN_CONTAINER = 1L;
+ static final String ALLGEMEINE_METADATEN_MEDIUM_CODE = "001";
+
+ private final AnwendungsspezifischeErweiterungTypeCreator anwendungsspezifischeErweiterungTypeCreator;
+ private final AnwendungsspezifischeErweiterungXMLTypeCreator anwendungsspezifischeErweiterungXMLTypeCreator;
+ private final KontaktTypeCreator kontaktTypeCreator;
+
+ public VorgangType create(VorgangWithEingang vorgangWithEingang) {
+ var vorgang = new VorgangType();
+ vorgang.setAnwendungsspezifischeErweiterung(anwendungsspezifischeErweiterungTypeCreator.create(vorgangWithEingang));
+ vorgang.setAnwendungsspezifischeErweiterungXML(anwendungsspezifischeErweiterungXMLTypeCreator.create(vorgangWithEingang));
+ vorgang.setIdentifikation(createIdentifikation());
+ vorgang.setAllgemeineMetadaten(createAllgemeineMetadaten(vorgangWithEingang));
+ kontaktTypeCreator.create(vorgangWithEingang).ifPresent(vorgang.getKontakt()::add);
+ return vorgang;
+ }
+
+ IdentifikationObjektType createIdentifikation() {
+ var identifikation = new IdentifikationObjektType();
+ identifikation.setID(UUID.randomUUID().toString());
+ identifikation.setNummerImUebergeordnetenContainer(NUMMER_IM_UEBERGEORDNETEN_CONTAINER);
+ return identifikation;
+ }
+
+ AllgemeineMetadatenType createAllgemeineMetadaten(VorgangWithEingang vorgang) {
+ var allgemeineMetadaten = new AllgemeineMetadatenType();
+ allgemeineMetadaten.setBetreff(vorgang.getName());
+ allgemeineMetadaten.setKennzeichen(vorgang.getNummer());
+ allgemeineMetadaten.setBemerkung(StringUtils.EMPTY);
+ allgemeineMetadaten.setMedium(createMediumCode());
+ return allgemeineMetadaten;
+ }
+
+ private MediumCodeType createMediumCode() {
+ var mediumCode = new MediumCodeType();
+ mediumCode.setCode(ALLGEMEINE_METADATEN_MEDIUM_CODE);
+ return mediumCode;
+ }
+
+}
diff --git a/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/WrappedValueExtractor.java b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/WrappedValueExtractor.java
new file mode 100644
index 0000000000000000000000000000000000000000..12a2d36bc271932aa84defc5e7d43a0bfa2bafd9
--- /dev/null
+++ b/alfa-xdomea/src/main/java/de/ozgcloud/alfa/vorgang/WrappedValueExtractor.java
@@ -0,0 +1,36 @@
+package de.ozgcloud.alfa.vorgang;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+class WrappedValueExtractor {
+
+ static final String WRAPPER_KEY = "value";
+
+ public static Map<String, Object> extractWrappedValues(Map<String, Object> formData) {
+ Map<String, Object> result = new HashMap<>();
+ for (var entry : formData.entrySet()) {
+ result.put(entry.getKey(), replaceWrappedValueWithDirectValue(entry.getValue()));
+ }
+ return result;
+ }
+
+ @SuppressWarnings("unchecked")
+ static Object replaceWrappedValueWithDirectValue(Object value) {
+ if (!(value instanceof Map)) {
+ return value;
+ }
+ Map<String, Object> formData = (Map<String, Object>) value;
+ return isWrappedValue(formData) ?
+ replaceWrappedValueWithDirectValue(formData.get(WRAPPER_KEY)) :
+ extractWrappedValues(formData);
+ }
+
+ static boolean isWrappedValue(Map<String, Object> formData) {
+ return formData.containsKey(WRAPPER_KEY) && formData.size() == 1;
+ }
+}
diff --git a/alfa-xdomea/src/main/resources/ozgcloud_XML-Schemata/ozgcloud.xsd b/alfa-xdomea/src/main/resources/ozgcloud_XML-Schemata/ozgcloud.xsd
new file mode 100644
index 0000000000000000000000000000000000000000..16daa7f5862da6b2b0e36a69b2f6d30969f555b9
--- /dev/null
+++ b/alfa-xdomea/src/main/resources/ozgcloud_XML-Schemata/ozgcloud.xsd
@@ -0,0 +1,70 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema targetNamespace="urn:ozgcloud-de:xdomea:schema:1.0.0"
+ xmlns:ozgcloud="urn:ozgcloud-de:xdomea:schema:1.0.0"
+ xmlns:xs="http://www.w3.org/2001/XMLSchema"
+ xmlns:xdomea="urn:xoev-de:xdomea:schema:3.0.0"
+ elementFormDefault="qualified">
+
+ <xs:import namespace="urn:xoev-de:xdomea:schema:3.0.0" schemaLocation="../xdomea_3-0-0_XML-Schemata/xdomea.xsd"/>
+
+ <xs:element name="Antragsdaten">
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Item" type="ozgcloud:AntragsdatenItemType" minOccurs="0" maxOccurs="unbounded"/>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+
+ <xs:complexType name="AntragsdatenItemType" abstract="true">
+ <xs:attribute name="name" type="xs:string" use="required"/>
+ </xs:complexType>
+
+ <xs:complexType name="AntragsdatenFieldType" abstract="true">
+ <xs:complexContent>
+ <xs:extension base="ozgcloud:AntragsdatenItemType">
+ <xs:attribute name="type" type="ozgcloud:DatatypeType" default="string"/>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <xs:complexType name="AntragsdatenSingleValueFieldType">
+ <xs:complexContent>
+ <xs:extension base="ozgcloud:AntragsdatenFieldType">
+ <xs:all>
+ <xs:element name="Value" type="xs:anyType"/>
+ </xs:all>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <xs:complexType name="AntragsdatenMultiValueFieldType">
+ <xs:complexContent>
+ <xs:extension base="ozgcloud:AntragsdatenFieldType">
+ <xs:sequence>
+ <xs:element name="Value" type="xs:anyType" maxOccurs="unbounded"/>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <xs:complexType name="AntragsdatenGroupType">
+ <xs:complexContent>
+ <xs:extension base="ozgcloud:AntragsdatenItemType">
+ <xs:sequence>
+ <xs:element name="Item" type="ozgcloud:AntragsdatenItemType" minOccurs="0" maxOccurs="unbounded"/>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+
+ <xs:simpleType name="DatatypeType">
+ <xs:restriction base="xs:string">
+ <xs:enumeration value="string"/>
+ <xs:enumeration value="date"/>
+ <xs:enumeration value="datetime"/>
+ <xs:enumeration value="integer"/>
+ <xs:enumeration value="float"/>
+ <xs:enumeration value="boolean"/>
+ </xs:restriction>
+ </xs:simpleType>
+</xs:schema>
\ No newline at end of file
diff --git a/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Baukasten.xsd b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Baukasten.xsd
new file mode 100644
index 0000000000000000000000000000000000000000..97b358a114505f27f22593e524a5c21d5ba8136c
--- /dev/null
+++ b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Baukasten.xsd
@@ -0,0 +1,1818 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+ xmlns:xdomea="urn:xoev-de:xdomea:schema:3.0.0"
+ xmlns:xoev-code="http://xoev.de/schemata/code/1_0"
+ targetNamespace="urn:xoev-de:xdomea:schema:3.0.0"
+ version="3.0.0"
+ elementFormDefault="qualified"
+ attributeFormDefault="unqualified">
+ <xs:annotation>
+ <xs:appinfo>
+ <standard>
+ <nameLang>xdomea - XÖV-Standard für den IT-gestützten Austausch und die IT-gestützte Aussonderung behördlichen Schriftgutes</nameLang>
+ <nameKurz>xdomea</nameKurz>
+ <nameTechnisch>xdomea</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:kosit:standard:xdomea</kennung>
+ <beschreibung>xdomea ist der vom IT-Planungsrat verabschiedete verbindliche Standard für den Austausch von Akten, Vorgängen und Dokumenten im Kontext der Übermittlung, der Abgabe sowie der Aussonderung von Schriftgutobjekten (www.it-planungsrat.de, Beschluss 2017/39). Weiterhin kann xdomea für den Austausch zwischen Fachverfahren und DMS/VBS sowie für die Zwischenarchivierung genutzt werden.
+
+Um diese Anwendungsszenarien bestmöglich zu unterstützen, ist xdomea gemäß des XÖV-Rahmenwerkes nach dem Baukastenprinzip aufgebaut und bietet einzelne Nachrichten(gruppen) für die jeweiligen Prozesse an.
+
+Der Standard xdomea wird von der gleichnamigen Arbeitsgruppe des IT-Planungsrates weiterentwickelt und gepflegt. Der Betrieb des Standards erfolgt durch die Koordinierungsstelle für IT-Standards (KoSIT).
+</beschreibung>
+ </standard>
+ <versionStandard>
+ <version>3.0.0</version>
+ <beschreibung>Die Version 3.0.0 ist durch den IT-Planungsrat beschlossen. Details zum Beschluss sowie zu den Fristen der Umsetzung sind der Veröffentlichung im Bundesanzeiger unter www.bundesanzeiger.de zu entnehmen.</beschreibung>
+ <versionXOEVProfil>1.7.2</versionXOEVProfil>
+ <versionXOEVHandbuch>2.3.1</versionXOEVHandbuch>
+ <versionXGenerator>3.0.1</versionXGenerator>
+ <versionModellierungswerkzeug>19.0</versionModellierungswerkzeug>
+ <nameModellierungswerkzeug>MagicDraw</nameModellierungswerkzeug>
+ </versionStandard>
+ </xs:appinfo>
+ <xs:documentation>Der Baukasten beinhaltet alle spezifischen Komponenten, die entweder aus XÖV-Kernkomponenten abgeleitet sind oder für xdomea erstellt wurden.</xs:documentation>
+ </xs:annotation>
+ <xs:include schemaLocation="xdomea-Datentypen.xsd"/>
+ <xs:import schemaLocation="http://xoev.de/schemata/code/1_0/xoev-code.xsd"
+ namespace="http://xoev.de/schemata/code/1_0"/>
+ <xs:complexType name="AkteType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Akte</title>
+ </xs:appinfo>
+ <xs:documentation>Akte enthält die Metadatenfelder für den Austausch von Akten einschließlich der archivspezifischen Metadaten, anwendungsspezifischer Metadaten, Historien- und Protokollinformationen sowie Informationen zum internen Geschäftsgang. Die absendende Behörde kann festlegen, welche Informationen dem Empfänger mit der Übertragung zur Verfügung gestellt werden sollen. So kann auch der Anforderung nach einer ggf. erforderlichen Beschränkung der übertragenen Metadaten Rechnung getragen werden (z.B. auf Grund datenschutzrechtlicher oder sonstiger gesetzlicher Bestimmungen).</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Identifikation" type="xdomea:IdentifikationObjektType">
+ <xs:annotation>
+ <xs:documentation>Über Identifikation werden zur systemübergreifend eindeutigen Identifizierung der Akte spezifische Merkmale übergeben.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="AllgemeineMetadaten"
+ minOccurs="0"
+ type="xdomea:AllgemeineMetadatenType">
+ <xs:annotation>
+ <xs:documentation>Über AllgemeineMetadaten werden allgemeine Metadaten zu einer Akte angegeben.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="ArchivspezifischeMetadaten"
+ minOccurs="0"
+ type="xdomea:MetadatenAussonderungType">
+ <xs:annotation>
+ <xs:documentation>Über ArchivspezifischeMetadaten werden die für die Archivierung und Aussonderung relevanten Metadaten zu einer Akte angegeben.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Standort" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Aufbewahrungsort der Akte.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Typ" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die weitere Spezifikation der Akte, um u. a. Recherche durchzuführen oder um zusätzliche Metadaten festzulegen. Beispiele sind Bauakte oder auch Personalakte.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Laufzeit" minOccurs="0" type="xdomea:ZeitraumType">
+ <xs:annotation>
+ <xs:documentation>Die Laufzeit der Akte, d.h. Zeitpunkt des Beginns und des Endes.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="HistorienProtokollInformation"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:HistorienProtokollInformationType">
+ <xs:annotation>
+ <xs:documentation>Über HistorienProtokollInformation werden die zur Historisierung und Protokollierung relevanten Metadaten zu einer Akte angegeben, in der die Veränderungen an den beschreibenden Attributen und dem Zustand der Akte erfasst werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="InternerGeschaeftsgang"
+ minOccurs="0"
+ type="xdomea:GeschaeftsgangType">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Der interne Geschäftsgang kann nach organisatorischer Absprache zwischen den austauschenden Systemen genutzt werden, ist aber nicht verpflichtender Bestandteil von xdomea.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Über InternerGeschaeftsgang wird der Akte zum Nachweis des internen Geschäftsgangs eine spezifische Ausprägung eines Geschäftsgangs zugeordnet.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Akteninhalt" minOccurs="0">
+ <xs:annotation>
+ <xs:documentation>Die Sachverhalte in der Akte sind inhaltlich mittels üblicher Akteninhalte wie z.B. Vorgänge abgegrenzt.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Dokument"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:DokumentType">
+ <xs:annotation>
+ <xs:documentation>Ein Dokument, das hierarchisch in die Akte eingebunden bzw. der Akte untergeordnet ist.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Vorgang"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:VorgangType">
+ <xs:annotation>
+ <xs:documentation>Ein Vorgang, der hierarchisch in die Akte eingebunden bzw. der Akte untergeordnet ist.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Teilakte"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:AkteType">
+ <xs:annotation>
+ <xs:documentation>Über diese Eigenschaft wird eine Teilakte hierarchisch in eine Akte eingebunden bzw. einer Akte untergeordnet.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Verweis"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:VerweisType">
+ <xs:annotation>
+ <xs:documentation>Über einen Verweis wird eine inhaltliche Querbeziehung der Akte zu einem anderen Schriftgutobjekt dargestellt.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Kontakt"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:KontaktType">
+ <xs:annotation>
+ <xs:documentation>Eine Kontaktinformation zu einem Geschäftsprozessbeteiligten.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="ZdA" minOccurs="0" type="xs:boolean">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>ZdA (zu den Akten) steht für das Schließen eines Schriftgutobjekts (Teilvorgang, Vorgang, Teilakte oder Akte). Die hierfür in den Verwaltungen genutzten Bezeichnungen können anders lauten (z.B. „Schließen der Akte oder des Vorgangs“).</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>ZdA kennzeichnet, ob die Akte zu den Akten verfügt wurde (Wert 1) oder nicht (Wert 0).</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="ZdADatum" minOccurs="0" type="xs:date">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>ZdA (zu den Akten) steht für das Schließen eines Schriftgutobjekts (Teilvorgang, Vorgang, Teilakte oder Akte). Die hierfür in den Verwaltungen genutzten Bezeichnungen können anders lauten (z.B. „Schließen der Akte oder des Vorgangs“).</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>ZdADatum kennzeichnet, wann der Vorgang zu den Akten verfügt wurde.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="AnwendungsspezifischeErweiterung"
+ minOccurs="0"
+ type="xdomea:AnwendungsspezifischeErweiterungType">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Die Speicherung der nicht-auflösbaren Daten beim Empfang erfolgt in einer XML-Datei zum Schriftgutobjekt im empfangenden System. Die Umsetzung muss systemspezifisch gelöst werden - hierbei muss durch das System sichergestellt sein, dass die empfangenen Informationen nicht verloren gehen.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>AnwendungsspezifischeErweiterung darf nur dazu genutzt werden, weitere (z.B. fachspezifische) Metadaten zu spezifizieren, deren Übermittlung mit den bereits in xdomea spezifizierten Metadaten nicht möglich ist.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="AnwendungsspezifischeErweiterungXML"
+ minOccurs="0"
+ type="xdomea:AnwendungsspezifischeErweiterungXMLType">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Die Speicherung der nicht-auflösbaren Daten beim Empfang erfolgt in einer XML-Datei zum Schriftgutobjekt im empfangenden System. Die Umsetzung muss systemspezifisch gelöst werden - hierbei muss durch das System sichergestellt sein, dass die empfangenen Informationen nicht verloren gehen.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>AnwendungsspezifischeErweiterungXML darf nur dazu genutzt werden, weitere (z.B. fachspezifische) Metadaten zu spezifizieren, deren Übermittlung mit den bereits in xdomea spezifizierten Metadaten nicht möglich ist. Die AnwendungsspezifischeErweiterungXML bietet die Möglichkeit, mittels Einbindung externer XML-Schemata diese Metadaten zu spezifizieren. Es können beliebige XML-Schemata mit unterschiedlichen Namensräumen angegeben werden. Die XML-Schema-Validierung der weiterführenden Metadaten erfolgt innerhalb der xdomea-Nachricht selbst "lax".</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="AktenplanType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Aktenplan</title>
+ </xs:appinfo>
+ <xs:documentation>Der Aktenplan enthält ein aufgabenbezogenes mehrstufiges Ordnungssystem mit einer hierarchischen Gliederung für das Bilden und Kennzeichnen von Akten und Vorgängen sowie das Zuordnen von Dokumenten.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Bezeichnung" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Name des Aktenplans.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Typ" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Typ des Aktenplans, z.B. Teilaktenplan.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Version" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Version des Aktenplans.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Einheit"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:AktenplaneinheitAktenplanType">
+ <xs:annotation>
+ <xs:documentation>Die Einheit eines Aktenplans, die Auskunft über die hierarchische Strukturierung eines Aktenplans gibt. Eine Aktenplanheit entspricht z.B. einer Hauptgruppe, Obergruppe, Gruppe, Untergruppe oder Betreffseinheit.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Gueltigkeit" minOccurs="0" type="xdomea:ZeitraumType">
+ <xs:annotation>
+ <xs:documentation>Die Gültigkeit des Aktenplans mit Beginn und Ende.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Aktenplandatei"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:FormatType">
+ <xs:annotation>
+ <xs:documentation>Die Datei zum Aktenplan als Primärdokument.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="AktenplaneinheitAktenplanType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>AktenplaneinheitAktenplan</title>
+ </xs:appinfo>
+ <xs:documentation>Eine Aktenplaneinheit gibt Auskunft über die hierarchische Strukturierung eines Aktenplans. Eine Aktenplanheit entspricht z.B. einer Hauptgruppe, Obergruppe, Gruppe, Untergruppe oder Betreffseinheit.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="xdomea:AktenplaneinheitType">
+ <xs:sequence>
+ <xs:element name="Aussonderungsart" type="xdomea:AussonderungsartType">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Die Aussonderungsart vererbt sich auf alle unter einer Hierarchiestufe angelegten Schriftgutobjekte.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die Aussonderungsart gibt für eine Akte oder einen Vorgang das Ergebnis der archivischen Bewertung an. Die Aussonderungsart wird vom Aktenplan (zweistufiges Aussonderungsverfahren) auf zugehörige Vorgänge und Dokumente vererbt.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Gueltigkeit" minOccurs="0" type="xdomea:ZeitraumType">
+ <xs:annotation>
+ <xs:documentation>Die Gültigkeit einer Aktenplaneinheit in einem Aktenplan.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Stillgelegt" type="xs:boolean">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Für die Umsetzung in den Systemen wird empfohlen, sofern kein anderer Wert hinterlegt wurde, als Standardwert den Wert 0 für "nicht stillgelegt" anzugeben.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Stillgelegt gibt an, ob eine Aktenplaneinheit inaktiv ist (Wert 1) oder nicht (Wert 0). Der Grund für eine Stilllegung kann eintreten, wenn z.B. auf einen bestimmten Zeitpunkt hin der alte Aktenplan "stillgelegt" und der neue Aktenplan in Kraft tritt - aktive Einheiten werden dann in den neuen Aktenplan übernommen, stillgelegte werden abgeschlossen und nicht übernommen.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Aufbewahrungsdauer" type="xdomea:AufbewahrungsdauerType">
+ <xs:annotation>
+ <xs:documentation>Die Aufbewahrungsdauer legt fest, wie viele Jahre eine Akte oder ein Vorgang nach der Verfügung zur Akte (zdA-Verfügung) innerhalb der aktenführenden Stelle aufzubewahren ist oder ob die Aufbewahrung unbefristet erfolgen soll. Nach Ablauf der Aufbewahrungsfrist erfolgt die Aussonderung in Abhängigkeit von der Aussonderungsart.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Einheit"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:AktenplaneinheitAktenplanType">
+ <xs:annotation>
+ <xs:documentation>Eine Aktenplaneinheit, die hierarchisch einer anderen Aktenplaneinheit untergeordnet ist.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="VerweisAktenplaneinheit"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Ein Verweis auf eine andere Aktenplaneinheit in einem aktuellen oder früheren Aktenplan.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="AnwendungsspezifischeErweiterung"
+ minOccurs="0"
+ type="xdomea:AnwendungsspezifischeErweiterungType">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Die Speicherung der nicht-auflösbaren Daten beim Empfang erfolgt in einer XML-Datei zum Schriftgutobjekt im empfangenden System. Die Umsetzung muss systemspezifisch gelöst werden - hierbei muss durch das System sichergestellt sein, dass die empfangenen Informationen nicht verloren gehen.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>AnwendungsspezifischeErweiterung darf nur dazu genutzt werden, weitere (z.B. fachspezifische) Metadaten zu spezifizieren, deren Übermittlung mit den bereits in xdomea spezifizierten Metadaten nicht möglich ist.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="AnwendungsspezifischeErweiterungXML"
+ minOccurs="0"
+ type="xdomea:AnwendungsspezifischeErweiterungXMLType">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Die Speicherung der nicht-auflösbaren Daten beim Empfang erfolgt in einer XML-Datei zum Schriftgutobjekt im empfangenden System. Die Umsetzung muss systemspezifisch gelöst werden - hierbei muss durch das System sichergestellt sein, dass die empfangenen Informationen nicht verloren gehen.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>AnwendungsspezifischeErweiterungXML darf nur dazu genutzt werden, weitere (z.B. fachspezifische) Metadaten zu spezifizieren, deren Übermittlung mit den bereits in xdomea spezifizierten Metadaten nicht möglich ist. Die AnwendungsspezifischeErweiterungXML bietet die Möglichkeit, mittels Einbindung externer XML-Schemata diese Metadaten zu spezifizieren. Es können beliebige XML-Schemata mit unterschiedlichen Namensräumen angegeben werden. Die XML-Schema-Validierung der weiterführenden Metadaten erfolgt innerhalb der xdomea-Nachricht selbst "lax".</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="AktenplaneinheitType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Aktenplaneinheit</title>
+ </xs:appinfo>
+ <xs:documentation>Die Aktenplaneinheit repräsentiert in dem aufgabenbezogenem Ordnungssystem Aktenplan eine Aufgabe.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Kennzeichen" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Das Kennzeichen einer Aktenplaneinheit.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Inhaltsangabe" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die ausführliche Beschreibung der Aufgabe, die durch die Aktenplaneinheit repräsentiert wird.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="BetreffKurz" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die kurze Beschreibung der Aufgabe, die durch die Aktenplaneinheit repräsentiert wird.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="AllgemeineMetadatenType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>AllgemeineMetadaten</title>
+ </xs:appinfo>
+ <xs:documentation>AllgemeineMetadaten enthält die Metadaten, die der allgemeinen Charakterisierung eines Schriftgutobjektes dienen.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Betreff" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Betreff des Schriftgutobjektes, z.B. für eine Akte der Aktentitel.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Kennzeichen" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Aus dem Aktenplan abgeleitete Kennung des Schriftgutobjektes zur Identifikation und Zuordnung zum Schriftgut in einer Behörde. Bei Akten ist das Kennzeichen das Aktenzeichen, es setzt sich zusammen aus dem zugehörigen Aktenplankennzeichen und einer eindeutigen Ordnungsnummer. Auf Vorgangsebene ist das Kennzeichen das Vorgangszeichen, das sich aus dem Aktenzeichen sowie einer zusätzlichen Nummer für den Vorgang zusammensetzt. Auf Dokumentebene wird als Kennzeichen das Geschäftszeichen verwendet. Dies besteht in der Regel aus dem Aktenzeichen resp. Vorgangszeichen, einer laufenden Nummer sowie der Organisationskurzbezeichnung der zuständigen Organisationseinheit.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Federfuehrung" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Organisationseinheit mit der Hauptverantwortung bzw. der Zuständigkeit für einen Geschäftsprozess.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Aktenfuehrung" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Organisationseinheit mit der Hauptverantwortung bzw. der Zuständigkeit für die Aktenführung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Vertraulichkeitsstufe"
+ minOccurs="0"
+ type="xdomea:VertraulichkeitsstufeCodeType">
+ <xs:annotation>
+ <xs:documentation>Die Vertraulichkeitsstufe beschreibt, welche Kriterien z.B. für die Weitergabe und Veröffentlichung eines Schriftgutobjekts beachtet werden müssen. Mögliche Werte sind "Geheim", "NfD", "Offen", "Streng geheim" oder "Vertraulich".</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Bemerkung" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Zusätzliches Feld zur Übermittlung weiterer Informationen in einem konkreten Geschäftsprozess.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Medium" minOccurs="0" type="xdomea:MediumCodeType">
+ <xs:annotation>
+ <xs:documentation>Das Medium beschreibt, ob es sich um ein Papier- und/oder elektronisches Dokument handelt. Mögliche Werte sind "Papier", "Elektronisch" oder "Hybrid".</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Aktenplaneinheit"
+ minOccurs="0"
+ type="xdomea:AktenplaneinheitType">
+ <xs:annotation>
+ <xs:documentation>Die Aktenplaneinheit, dem das Schriftgutobjekt zugeordnet ist.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="AllgemeinerNameType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>AllgemeinerName</title>
+ </xs:appinfo>
+ <xs:documentation>AllgemeinerName leitet sich von der entsprechenden XÖV-Kernkomponente ab. Er dient der Darstellung von Vor- und Nachnamen und fasst deren gemeinsame Eigenschaften zusammen.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Name" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Name ist der eigentliche Familien- oder Vorname als Zeichenkette. Nachnamen, z.B. mit Adelstiteln bzw. ausländische Nachnamen werden als ein Name übermittelt und nicht in verschiedene Bestandteile aufgeteilt.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="AnlageDokumentType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>AnlageDokument</title>
+ </xs:appinfo>
+ <xs:documentation>AnlageDokument ist eine Erweiterung eines Dokuments zu einer Anlage mit einer entsprechenden Anlagennummer. Über sie werden andere Dokumente, die einem Dokument als Anlage zugeordnet werden, als solche gekennzeichnet.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="xdomea:DokumentType">
+ <xs:sequence>
+ <xs:element name="Nummer" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die fortlaufende Nummer eines Anlagendokuments zu einem Dokument.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="AnschriftType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Anschrift</title>
+ </xs:appinfo>
+ <xs:documentation>Die Anschrift leitet sich von der entsprechenden XÖV-Kernkomponente ab. Sie beschreibt einen Ort mit den klassischen Ordnungsbegriffen wie Orts- und Straßennamen sowie ergänzenden Informationen wie z.B. Postfach. Eine Anschrift kann genutzt werden, um Orte zu benennen, an denen sich Personen aufhalten, an denen Objekte zu finden sind, oder an denen Ereignisse stattfinden. Darüber hinaus kann sie genutzt werden, um Post oder Waren zuzustellen. Daher enthält sie auch die notwendigen Attribute, um Postfächer zu adressieren.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Staat" minOccurs="0" type="xdomea:StaatType">
+ <xs:annotation>
+ <xs:documentation>Der Staat, dem die Anschrift postalisch zugeordnet wird.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Strasse" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Straße enthält den Namen bzw. die Bezeichnung einer Straße. Eine Straße ist ein planmäßig angelegter, i. allg. befestigter Verkehrsweg innerhalb eines Ortes. Es soll möglichst der amtliche Straßenname aus einem offiziellen Straßenverzeichnis genutzt werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Hausnummer" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Eine Hausnummer dient der genauen Lokalisierung eines Grundstücks, Gebäudes oder Gebäudeteils (Eingang) in einer Straße. Hausnummern können entsprechend der üblichen Praxis in vielen Gemeinden mit ergänzenden Angaben zur weiteren Unterteilung versehen werden, etwa "12a" oder "17 1/3". Da manche Gebäude oder Organisationen sich als Einheit über mehrere Hausnummern erstrecken, können auch Hausnummernbereiche angegeben werden, etwa "12a - 12e" oder "1 - 3".</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Postfach" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Ein Postfach (oft Postfachnummer) ist ein Schlüssel zur Identifikation eines Postfaches in einer Postfiliale. Eine Beschränkung auf numerische Postfachbezeichnungen wurde bewusst nicht vorgenommen.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Postleitzahl" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Eine Postleitzahl ist eine Angabe, um postalische Zustellgebiete unabhängig von Gebietskörperschaften (Gemeinde, Kreis, ...) zu bezeichnen. In Deutschland sind durch Postleitzahlen bezeichnete Bereiche und verwaltungspolitische Grenzen in der Regel aufeinander abgestimmt. Größere Gemeinden und Städte sind häufig in mehrere Postleitzahlengebiete aufgeteilt. Postleitzahlen werden durch die Deutsche Post AG verwaltet. Eine Beschränkung auf deutsche Postleitzahlen (5-stellig) wurde bewusst nicht vorgenommen.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Ort" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Ort enthält den Namen eines Ortes (Gemeinde, Ortschaft oder Stadt). Als Ortsname sollte der amtliche Gemeindename genutzt werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Zusatz" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Ein Anschriftenzusatz beinhaltet ggf. erforderliche weitere Präzisierungen zu einer Anschrift.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Typ" minOccurs="0" type="xdomea:AnschriftstypCodeType">
+ <xs:annotation>
+ <xs:documentation>Im Typ wird beschrieben, um welche Art der Anschrift es sich handelt. Mögliche Werte sind "Aktuelle Anschrift", "Hauptsitz" oder "Zweitsitz".</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="AnwendungsspezifischeErweiterungType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>AnwendungsspezifischeErweiterung</title>
+ </xs:appinfo>
+ <xs:documentation>AnwendungsspezifischeErweiterung darf nur dazu genutzt werden, weitere (z.B. fachspezifische) Metadaten zu spezifizieren, deren Übermittlung mit den bereits in xdomea spezifizierten Metadaten nicht möglich ist.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Kennung" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Das Identifikationskennzeichen der anwendungsspezifischen Erweiterung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Name" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Name der anwendungsspezifischen Erweiterung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Beschreibung" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die textuelle Erläuterung zu einer anwendungsspezifischen Erweiterung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Versionsnummer" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Versionsnummer der anwendungsspezifischen Erweiterung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Versionsdatum" minOccurs="0" type="xs:date">
+ <xs:annotation>
+ <xs:documentation>Das Datum, an dem die Version der anwendungsspezifischen Erweiterung erstellt wurde.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Feldgruppe"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:FeldgruppeType">
+ <xs:annotation>
+ <xs:documentation>Eine Feldgruppe, die der anwendungsspezifischen Erweiterung zugeordnet ist.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Feld"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:FeldType">
+ <xs:annotation>
+ <xs:documentation>Ein Feld, das der anwendungsspezifischen Erweiterung zugeordnet ist.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="AnwendungsspezifischeErweiterungXMLType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>AnwendungsspezifischeErweiterungXML</title>
+ </xs:appinfo>
+ <xs:documentation>AnwendungsspezifischeErweiterungXML darf nur dazu genutzt werden, weitere (z.B. fachspezifische) Metadaten zu spezifizieren, deren Übermittlung mit den bereits in xdomea spezifizierten Metadaten nicht möglich ist. Die AnwendungsspezifischeErweiterungXML bietet über ein xs:any-Element die Möglichkeit, mittels Einbindung externer XML-Schemata diese Metadaten zu spezifizieren. Es können beliebige XML-Schemata mit unterschiedlichen Namensräumen angegeben werden. Die XML-Schema-Validierung der weiterführenden Metadaten erfolgt innerhalb der xdomea-Nachricht selbst "lax".</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:any minOccurs="0"
+ maxOccurs="unbounded"
+ namespace="##any"
+ processContents="lax"/>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="AufbewahrungsdauerType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Aufbewahrungsdauer</title>
+ </xs:appinfo>
+ <xs:documentation>Die Aufbewahrungsdauer legt fest, wie viele Jahre eine Akte oder ein Vorgang nach der Verfügung zur Akte (zdA-Verfügung) innerhalb der aktenführenden Stelle aufzubewahren ist oder ob die Aufbewahrung unbefristet erfolgen soll.</xs:documentation>
+ </xs:annotation>
+ <xs:choice>
+ <xs:element name="AnzahlJahre" type="xs:unsignedShort">
+ <xs:annotation>
+ <xs:documentation>Anzahl der Jahre, die eine Akte oder ein Vorgang nach der Verfügung zur Akte (zdA-Verfügung) innerhalb der aktenführenden Stelle aufzubewahren ist.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Unbefristet" fixed="1" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>Eine Akte oder ein Vorgang ist nach der Verfügung zur Akte (zdA-Verfügung) innerhalb der aktenführenden Stelle unbefristet aufzubewahren.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:choice>
+ </xs:complexType>
+ <xs:complexType name="AussonderungsartType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Aussonderungsart</title>
+ </xs:appinfo>
+ <xs:documentation>Die Aussonderungsart gibt das Ergebnis der archivischen Bewertung an. Damit eine automatische Selektion der auszusondernden Vorgänge erfolgen kann, muss in Vorgangsbearbeitungssystemen für Akten und Vorgänge ein Metadatum "Aussonderungsart" oder "AussonderungsartKonfigurierbar" vorgegeben werden. Die Aussonderungsart liegt beim zweistufigen Aussonderungsverfahren bereits im DMS/VBS vor (durch Bewertung von Akten und Vorgängen im DMS oder durch Hinterlegung eines Bewertungskatalogs am Aktenplan) oder sie wird im vierstufigen Aussonderungsverfahren durch die Übernahme des Bewertungsverzeichnisses ins DMS/VBS übernommen.</xs:documentation>
+ </xs:annotation>
+ <xs:choice>
+ <xs:element name="Aussonderungsart" type="xdomea:AussonderungsartCodeType">
+ <xs:annotation>
+ <xs:documentation>Die Aussonderungsart als Wert aus einer vorgegebenen Codeliste.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="AussonderungsartKonfigurierbar" type="xs:string">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Die möglichen Werte für AussonderungsartKonfigurierbar müssen zwischen den beteiligten Kommunikationspartnern (abgebende Stelle und Archiv) vereinbart werden.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die Aussonderungsart als frei konfigurierbarer Wert.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:choice>
+ </xs:complexType>
+ <xs:complexType name="BearbeitungType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Bearbeitung</title>
+ </xs:appinfo>
+ <xs:documentation>Die Erledigung eines Beteiligungsschrittes in einem Geschäftsgang.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Bearbeiter" type="xdomea:KontaktType">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Wird ein Schritt durch den Bearbeiter eines vorhergehenden Schrittes als "übersprungen" markiert, so wird derjenige in dem übersprungenen Schritt auch als Bearbeiter geführt. An dieser Stelle wird für den Bearbeiter der Datentyp "KontaktType" verwendet, da damit der Geschäftsgang (auch organisationsübergreifend) gesteuert werden kann.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die spezifische Ausprägung eines Kontaktes, der die Informationen zum Bearbeiter des Beteiligungsschrittes enthält.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Datum" type="xs:date">
+ <xs:annotation>
+ <xs:documentation>Das Datum des Bearbeitungsabschlusses.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Uhrzeit" minOccurs="0" type="xs:time">
+ <xs:annotation>
+ <xs:documentation>Der Zeitpunkt des Bearbeitungsabschlusses.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Vermerk" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Eine Bemerkung auf einem Schriftgutobjekt, die den Geschäftsgang und die Bearbeitung steuert. Sie dient dem Nachvollziehen der Erledigung eines Geschäftsvorfalls. Im konkreten Fall von xdomea ist hiermit die Bestätigung der Erledigung eines Beteiligungsschrittes im externen und internen Geschäftsgang gemeint.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Notiz" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die ergänzende Anmerkung, die der Bearbeiter zum Beteiligungsschritt erfasst.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Anlage"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:DokumentType">
+ <xs:annotation>
+ <xs:documentation>Ein Dokument, das der Bearbeiter des Beteiligungsschrittes dem Beteiligungsschritt z.B. als Stellungnahme beifügt.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="BehoerdenkennungType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Behoerdenkennung</title>
+ </xs:appinfo>
+ <xs:documentation>Die Behördenkennung leitet sich von der entsprechenden XÖV-Kernkomponente ab. Sie fasst die Eigenschaften zusammen, über die eine Behörde identifiziert werden kann. Die Behördenkennung ist prioritär zur Übermittlung der im DVDV verzeichneten Behördenschlüssel vorgesehen, kann aber auch für andere Behördenkennungen, bspw. die BKZ der Justizverwaltung eingesetzt werden. Eine Behördenkennung im DVDV besteht aus einem Präfix und der eigentlichen Kennung. Die Codelisten für die Präfixe sowie die Kennungen pro Präfix werden durch die koordinierende Stelle für das DVDV verwaltet. Ein Beispiel für die weitere Nutzung: Bei einer Identifikation von Behörden auf kommunaler Ebene anhand des amtlichen Gemeindeschlüssels (AGS) der Gemeinde, für die die Behörde zuständig ist, lautet der Präfix ags:, die Kennung ist dann der AGS der jeweiligen Gemeinde.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Behoerdenschluessel" minOccurs="0" type="xoev-code:Code">
+ <xs:annotation>
+ <xs:documentation>Schlüssel zur eindeutigen Identifikation einer Behörde. Die Kennung kennzeichnet eine Behörde ggf. innerhalb der durch den Präfix bezeichneten Klasse (z.B. DVDV) eindeutig. Im Zusammenhang mit dem DVDV wird die Kennung durch die koordinierende Stelle für das DVDV verwaltet. Die tatsächlich zu nutzende Codeliste kann an dieser Stelle nicht angegeben werden, da es voraussichtlich pro Präfix jeweils eine Codeliste der Kennungen der Behörden mit diesem Präfix geben wird. (Zum Beispiel die Codeliste der Amtlichen Gemeindeschlüssel für die Behörden auf kommunaler Ebene, die anhand dieses Ordnungsmerkmals im DVDV verzeichnet sind und mit dem Präfix ags: adressiert werden. Eine andere zulässige Liste wäre die Codeliste der Kennungen aller Bundesbehörden, die jeweils mit dem Präfix dbs: zu versehen sind. Nach jetzigem Kenntnisstand kann nicht ausgeschlossen werden, dass Inhalte der Codelisten mit Kennungen für Behörden unterschiedlichen Typs immer disjunkt sind.)</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Praefix" minOccurs="0" type="xoev-code:Code">
+ <xs:annotation>
+ <xs:documentation>Der Präfix bezeichnet eine Klasse von Behördenkennungen. Beispiel: So werden u.a. alle Behördenkennungen der Behörden, die anhand des amtlichen Gemeindeschlüssels (AGS) identifiziert werden können, den Präfix ags: erhalten. Die Liste der Präfixe für Behördenkennungen werden im Zusammenhang mit dem DVDV durch das Bundesverwaltungsamt als koordinierende Stelle für das DVDV verwaltet.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="BeteiligungsschrittType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Beteiligungsschritt</title>
+ </xs:appinfo>
+ <xs:documentation>Das Verwaltungshandeln an einem Schriftgutobjekt wird in dem zugehörigen Geschäftsgang protokolliert, der sich aus einzelnen Beteiligungsschritten zusammensetzt. Jeder Beteiligungsschritt hat einen Verfügungsteil, in dem der Bearbeitungsschritt festgelegt, und einen Bearbeitungsteil, in dem der Beteiligungsschritt bearbeitet wird. Die Beteiligungsschritte im Geschäftsgang werden fortlaufend nummeriert.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Nummer" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Nummer des Beteiligungsschrittes innerhalb der fortlaufenden Nummerierung im Geschäftsgang. Die Nummerierung ist innerhalb eines xdomea-Geschäftsgangsobjekts eindeutig. Werden in den xdomea-Geschäftsgang neue Bearbeitungsschritte eingefügt, werden dementsprechend die Nummern der nachfolgenden Beteiligungsschritte verändert. Beteiligungsschritte, die abgeschlossen sind, sind unveränderlich.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Status" type="xdomea:BeteiligungsstatusCodeType">
+ <xs:annotation>
+ <xs:documentation>Der Status beschreibt den Fortschritt eines Beteiligungsschrittes.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Verfuegung" type="xdomea:VerfuegungType">
+ <xs:annotation>
+ <xs:documentation>Steuerungsinformation und Arbeitsanweisung bei der Bearbeitung eines Geschäftsvorfalls. Im konkreten Fall von xdomea ist hier die Arbeitsanweisung für den Bearbeiter eines Beteiligungsschrittes im externen und internen Geschäftsgang gemeint.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Bearbeitung" minOccurs="0" type="xdomea:BearbeitungType">
+ <xs:annotation>
+ <xs:documentation>In der Bearbeitung sind die Informationen zum Bearbeitungsteil des Beteiligungsschrittes zusammengefasst.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="DokumentType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Dokument</title>
+ </xs:appinfo>
+ <xs:documentation>Dokument enthält die Metadatenfelder für den Austausch von Dokumenten einschließlich der archivspezifischen Metadaten, anwendungsspezifischer Metadaten, Historien- und Protokollinformationen sowie Informationen zum internen Geschäftsgang. In der Objekthierarchie des Organisationskonzepts elektronische Verwaltungsarbeit ist das Dokument die kleinste logische Einheit des Schriftguts. Es handelt sich um ein einzelnes Schriftstück, papiergebunden oder elektronisch erstellt und verwaltet. Zum Dokument gehören zudem alle ergänzenden Angaben (z.B. Metadaten), die zum Verständnis der Primärdokumente notwendig sind. Der Begriff Dokument entspricht nicht nur den ehemaligen Papierdokumenten, sondern kann daneben jede andere digitale Form von Informationen beinhalten. Es kann aus einem (zum Beispiel ein Bild oder ein Datensatz) oder mehreren Einzelobjekten (zum Beispiel mehrere Bilder, einer Datei mit integrierten Bildern, Text und Tabellen, gemischte Inhalte aus mehreren Quellen) bestehen.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Identifikation" type="xdomea:IdentifikationObjektType">
+ <xs:annotation>
+ <xs:documentation>Über Identifikation werden zur systemübergreifend eindeutigen Identifizierung des Dokuments spezifische Merkmale übergeben.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="AllgemeineMetadaten"
+ minOccurs="0"
+ type="xdomea:AllgemeineMetadatenType">
+ <xs:annotation>
+ <xs:documentation>Über AllgemeineMetadaten werden allgemeine Metadaten zu einem Dokument angegeben.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="FremdesGeschaeftszeichen" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Das Geschäftszeichen des Dokuments im absendenden System, das im Zuge eines Nachrichtentransfers übermittelt wird.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Posteingangsdatum" minOccurs="0" type="xs:date">
+ <xs:annotation>
+ <xs:documentation>Das Posteingangsdatum eines Eingangsdokumentes. Es ist relevant beim Austausch von Dokumenten im Vorgangs- oder Aktenzusammenhang.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Postausgangsdatum" minOccurs="0" type="xs:date">
+ <xs:annotation>
+ <xs:documentation>Das Postausgangsdatum eines Ausgangsdokumentes. Es ist relevant beim Austausch von Dokumenten im Vorgangs- oder Aktenzusammenhang.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="DatumDesSchreibens" minOccurs="0" type="xs:date">
+ <xs:annotation>
+ <xs:documentation>Das Datum des Schreibens, z.B. das Datum eines Briefes. Es handelt sich nicht um das Erstellungs- oder Veränderungsdatum des Primärdokuments.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Bezug" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der konkrete Bezug eines Dokuments, z.B. "Ihr Schreiben vom ..."</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Hier" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>"Hier" wird zur Konkretisierung des Betreffs verwendet. Auch als Unterbetreff bekannt.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Bearbeiter" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>An dieser Stelle wird für den Bearbeiter der Datentyp "String" verwendet, da es sich hierbei lediglich um den Namen des Bearbeiters handelt und keine weiteren Steuerungsinformationen damit verbunden sind.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die für die Bearbeitung zuständige Person.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Typ" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Dokumenttyp dient der weiteren Spezifikation des Dokumentes. Der Typ ist relevant beim Austausch von Dokumenten im Vorgangs- oder Aktenzusammenhang. Zulässige Werte sind z.B. Erlass, Vermerk, Bericht, Bescheid.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="HistorienProtokollInformation"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:HistorienProtokollInformationType">
+ <xs:annotation>
+ <xs:documentation>Über HistorienProtokollInformation werden die zur Historisierung und Protokollierung relevanten Metadaten zu einem Dokument angegeben, in der die Veränderungen an den beschreibenden Attributen und dem Zustand des Dokumentes erfasst werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="InternerGeschaeftsgang"
+ minOccurs="0"
+ type="xdomea:GeschaeftsgangType">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Der interne Geschäftsgang kann nach organisatorischer Absprache zwischen den austauschenden Systemen genutzt werden, ist aber nicht verpflichtender Bestandteil von xdomea.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die spezifische Ausprägung eines Geschäftsgangs, über die der interne Geschäftsgang am Dokument nachgewiesen wird.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Version"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:VersionType">
+ <xs:annotation>
+ <xs:documentation>Über eine Version wird ein bestimmter Bearbeitungszustand zu einem Dokument im Rahmen der Versionierung des Dokumentes abgebildet.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Verweis"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:VerweisType">
+ <xs:annotation>
+ <xs:documentation>Über einen Verweis wird eine inhaltliche Querbeziehung des Dokuments zu einem anderen Schriftgutobjekt dargestellt.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Anlage"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:AnlageDokumentType">
+ <xs:annotation>
+ <xs:documentation>Ein dem Dokument zugeordnetes Anlagendokument.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Absender"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:KontaktType">
+ <xs:annotation>
+ <xs:documentation>Die spezifische Ausprägung eines Kontakts, der die Informationen zum Absender des Dokumentes enthält.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Empfaenger"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:KontaktType">
+ <xs:annotation>
+ <xs:documentation>Die spezifische Ausprägung eines Kontakts, der die Informationen zum Empfänger des Dokumentes enthält.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="WeitererKontakt"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:KontaktType">
+ <xs:annotation>
+ <xs:documentation>Die spezifische Ausprägung eines Kontakts, der die Informationen zu einem weiteren Beteiligten enthält, der nicht Empfänger oder Absender des Dokuments ist.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="AnwendungsspezifischeErweiterung"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:AnwendungsspezifischeErweiterungType">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Die Speicherung der nicht-auflösbaren Daten beim Empfang erfolgt in einer XML-Datei zum Schriftgutobjekt im empfangenden System. Die Umsetzung muss systemspezifisch gelöst werden - hierbei muss durch das System sichergestellt sein, dass die empfangenen Informationen nicht verloren gehen.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>AnwendungsspezifischeErweiterung darf nur dazu genutzt werden, weitere (z.B. fachspezifische) Metadaten zu spezifizieren, deren Übermittlung mit den bereits in xdomea spezifizierten Metadaten nicht möglich ist.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="AnwendungsspezifischeErweiterungXML"
+ minOccurs="0"
+ type="xdomea:AnwendungsspezifischeErweiterungXMLType">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Die Speicherung der nicht-auflösbaren Daten beim Empfang erfolgt in einer XML-Datei zum Schriftgutobjekt im empfangenden System. Die Umsetzung muss systemspezifisch gelöst werden - hierbei muss durch das System sichergestellt sein, dass die empfangenen Informationen nicht verloren gehen.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>AnwendungsspezifischeErweiterungXML darf nur dazu genutzt werden, weitere (z.B. fachspezifische) Metadaten zu spezifizieren, deren Übermittlung mit den bereits in xdomea spezifizierten Metadaten nicht möglich ist. Die AnwendungsspezifischeErweiterungXML bietet die Möglichkeit, mittels Einbindung externer XML-Schemata diese Metadaten zu spezifizieren. Es können beliebige XML-Schemata mit unterschiedlichen Namensräumen angegeben werden. Die XML-Schema-Validierung der weiterführenden Metadaten erfolgt innerhalb der xdomea-Nachricht selbst "lax".</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="FeldType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Feld</title>
+ </xs:appinfo>
+ <xs:documentation>Ein Feld ist ein anwendungsspezifisches Metadatum, das bei dem Austausch eines Schriftgutobjektes übergeben wird. Die Konfiguration eines Feldes in den austauschenden Systemen muss zwischen den Kommunikationspartnern abgesprochen und in den Systemen umgesetzt sein.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Name" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Name des Feldes.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Beschreibung" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Hinweise und Erläuterungen zu einem Feld.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Datentyp" minOccurs="0" type="xdomea:DatentypCodeType">
+ <xs:annotation>
+ <xs:documentation>Der Datentyp des Feldwertes. Gültige Angaben sind die W3C-Datentypen.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Wert" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Wert des Feldes.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="FeldgruppeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Feldgruppe</title>
+ </xs:appinfo>
+ <xs:documentation>Eine Feldgruppe gruppiert mehrere Felder als anwendungsspezifische Metadaten beim Austausch eines Schriftgutobjektes.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Name" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Name der Feldgruppe.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Beschreibung" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Hinweise und Erläuterungen zu einer Feldgruppe.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Unterfeldgruppe"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:FeldgruppeType">
+ <xs:annotation>
+ <xs:documentation>Über Unterfeldgruppe erfolgt die hierarchische Unterteilung einer Feldgruppe in weitere Feldgruppen.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Feld"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:FeldType">
+ <xs:annotation>
+ <xs:documentation>Über Feld erfolgt die Unterteilung einer Feldgruppe in konkrete Felder.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="FormatType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Format</title>
+ </xs:appinfo>
+ <xs:documentation>Ein Format gibt die Syntax und Semantik einer Datei (z.B. Primärdokument, Aktenplandatei) an.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Name" type="xdomea:DateiformatCodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Für zusätzliche Formatnamen enthält die Codeliste den Wert "Sonstiges" - ist dieser Wert benannt, so muss unter SonstigerName der Name des Formats angegeben werden.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Der Name des Formats. Gültige Werte sind z.B. doc, pdf, jpg.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SonstigerName" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Die Voraussetzung für die Nutzung von SonstigerName ist die Angabe von "Sonstiges" als Namenswert.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Der sonstige Name des Formats.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Version" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Version des Formats, z.B. für pdf 1.4 wäre hier "1.4" anzugeben.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Primaerdokument" type="xdomea:PrimaerdokumentType">
+ <xs:annotation>
+ <xs:documentation>Über Primaerdokument werden Dateiangaben zum tatsächlich beschriebenen Primärdokument eines Formats angegeben.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="GeburtType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Geburt</title>
+ </xs:appinfo>
+ <xs:documentation>Geburt fasst geburtsbezogene Informationen einer natürlichen Person zusammen.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Datum" type="xs:date">
+ <xs:annotation>
+ <xs:documentation>Das Datum der Geburt.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="GeschaeftsgangType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Geschaeftsgang</title>
+ </xs:appinfo>
+ <xs:documentation>In einem Geschäftsgang wird das vorgenommene Verwaltungshandeln an Schriftgutobjekten festgehalten.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Identifikation" type="xdomea:IdentifikationObjektType">
+ <xs:annotation>
+ <xs:documentation>Die Identifikation zur systemübergreifend eindeutigen Identifizierung des Geschäftsgangs.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Beteiligungsschritt"
+ maxOccurs="unbounded"
+ type="xdomea:BeteiligungsschrittType">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Es müssen immer alle Beteiligungsschritte eines Geschäftsgangs geliefert werden - unabhängig davon, welchen Status sie besitzen.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Ein dem Geschäftsgang zugeordneter Beteiligungsschritt, der im Zuge des Geschäftsgangs durchgeführt wird. Die Beteiligungsschritte sind fortlaufend nummeriert.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="HistorienProtokollInformationType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>HistorienProtokollInformation</title>
+ </xs:appinfo>
+ <xs:documentation>Die Historien- und Protokollinformationen entstehen durch die Bearbeitung von Schriftgutobjekten. Sie protokollieren die Veränderungen an den Metadaten und dem Zustand eines Schriftgutobjektes, die für den Nachweis des Verwaltungshandelns relevant sind - dazu gehören zum Beispiel die Anlage von Vorgängen und Akten, deren Umprotokollierung oder die zdA-Verfügung. Bei der Historisierung werden der alte und der neue Zustand nach der Änderung mit der Angabe des Zeitpunktes und der Uhrzeit der Änderung und der Person, die die Änderung vorgenommen hat, gespeichert.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="MetadatumName" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Das Metadatum, das sich geändert hat.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="MetadatumAlterWert" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Wert des Metadatums vor der Änderung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="MetadatumNeuerWert" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Wert des Metadatums als Ergebnis der Änderung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Akteur" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Person, die die Änderung vorgenommen hat. Wird die Änderung automatisch durch das System und nicht manuell durch eine Person vorgenommen, so ist das entsprechende System anzugeben.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="DatumUhrzeit" type="xs:dateTime">
+ <xs:annotation>
+ <xs:documentation>Das Datum und die Uhrzeit der erfassten Änderung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Bemerkung" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Hinweise und Erläuterungen zu der Änderung eines Metadatums.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Aktion" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Aktion, die die konkrete Änderung des Metadatums näher beschreibt, z.B. gelöscht, neu.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="IdentifikationObjektType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>IdentifikationObjekt</title>
+ </xs:appinfo>
+ <xs:documentation>Die Zusammenfassung von Merkmalen zur eindeutigen Identifizierung eines Schriftgutobjektes (Dokument, Vorgang, Akte) bzw. von Geschäftsgängen und zur Nummerierung im übergeordneten Schriftgutobjekt.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="ID" type="xdomea:stringUUIDType">
+ <xs:annotation>
+ <xs:documentation>Jedes Schriftgutobjekt (Dokument, Vorgang, Akte) und jeder Geschäftsgang erhält beim Nachrichtenaustausch eine UUID, die sowohl im sendenden als auch empfangenden System als externe ID gespeichert wird.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="NummerImUebergeordnetenContainer"
+ minOccurs="0"
+ type="xs:unsignedInt">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Die Nummer dient nicht zur Identifizierung von Schriftgutobjekten - hierzu sollte die ID verwendet werden. Es darf keine doppelte Nummernvergabe erfolgen, aber Lücken z.B. durch gelöschte oder verschobene Schriftgutobjekte sind möglich. Innerhalb eines Schriftgutobjekts ist keine Mischform zulässig (d.h. einige Schriftgutobjekte mit Nummer und andere ohne).</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die laufende Nummer des Schriftgutobjekts im übergeordneten Objekt (z.B. die Heftungsnummer eines Dokuments in einem Vorgang, die Nummer eines Bandes in einer Akte).</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="KommunikationType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Kommunikation</title>
+ </xs:appinfo>
+ <xs:documentation>Die Kommunikation leitet sich von der entsprechenden XÖV-Kernkomponente ab. Sie fasst Angaben zur Erreichbarkeit über elektronische Kommunikationskanäle (z.B. Telefon, Fax, E-Mail) zusammen.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="IstDienstlich" minOccurs="0" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>Mit IstDienstlich kann angegeben werden, ob es sich um dienstliche oder private Kommunikationsdaten handelt. Handelt es sich um dienstliche Kommunikationsdaten, so ist der Wert 1 anzugeben. Handelt es sich um private Kommunikationsdaten, so ist der Wert 0 anzugeben.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Kanal" minOccurs="0" type="xdomea:KommunikationsartCodeType">
+ <xs:annotation>
+ <xs:documentation>Der Kanal gibt an, über welchen Kommunikationskanal eine Erreichbarkeit besteht (z.B. Telefon, Fax, E-Mail).</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Kennung" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Kennung beinhaltet die konkrete Angabe zur Erreichbarkeit über einen Kommunikationskanal, d.h. die Telefonnummer, Faxnummer, E-Mail-Adresse oder dergleichen. Die Kennung soll strukturiert erfasst werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Zusatz" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Im Zusatz können zusätzliche freie Angaben zur Erreichbarkeit über einen Kommunikationskanal erfasst werden, z.B. "erreichbar tagsüber zwischen 9 und 16 Uhr".</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="IstInstitution" minOccurs="0" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>Mit IstInstitution kann angegeben werden, ob es sich um Kommunikationsdaten einer Institution handelt oder nicht. Handelt es sich um eine Institution, so ist der Wert 1 anzugeben. Handelt es sich um keine Institution, so ist der Wert 0 anzugeben.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="KontaktType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Kontakt</title>
+ <implementationHint>Je nach Anwendungsfall ist mindestens eines der enthaltenen Elemente mit Daten zu befüllen.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Ein Kontakt fasst wesentliche Merkmale zu einem Kommunikationspartner zusammen, z.B. Anschriften, Kommunikationsmöglichkeiten.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Behoerdenkennung"
+ minOccurs="0"
+ type="xdomea:BehoerdenkennungType">
+ <xs:annotation>
+ <xs:documentation>Die Kennung der Behörde zur Adressierung, z.B. im DVDV.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Institution" minOccurs="0" type="xdomea:NameOrganisationType">
+ <xs:annotation>
+ <xs:documentation>Die Institution des Kontakts. Eine Institution ist z.B. ein Unternehmen oder eine Behörde.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Organisationseinheit"
+ minOccurs="0"
+ type="xdomea:OrganisationseinheitType">
+ <xs:annotation>
+ <xs:documentation>Die Organisationseinheit des Kontakts.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Name" minOccurs="0" type="xdomea:NameNatuerlichePersonType">
+ <xs:annotation>
+ <xs:documentation>Der Name des Ansprechpartners zum Kontakt.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Taetigkeit" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Tätigkeit gibt an, welche Position der im Kontakt angegebene Ansprechpartner in der jeweiligen Institution einnimmt. Es können hier die Amtsbezeichnung (z.B. Regierungsrat), Dienstbezeichnung (z.B. Referendar), der Dienstgrad (z.B. General) oder die Berufsbezeichnung (z.B. IT-Berater) angegeben werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Zustaendigkeit" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Zuständigkeit gibt die Bereiche an, für die der im Kontakt angegebene Ansprechpartner oder die Institution verantwortlich ist, z.B. "Leiter der Abteilung O", "Projektleiter des XYZ-Projekts".</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Anschrift"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:AnschriftType">
+ <xs:annotation>
+ <xs:documentation>Eine strukturierte Anschrift des Kontakts.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Kommunikation"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:KommunikationType">
+ <xs:annotation>
+ <xs:documentation>Eine Kommunikationsmöglichkeit des Kontakts, die die Angaben zur Erreichbarkeit über elektronische Kommunikationskanäle enthält.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Rolle" minOccurs="0" type="xoev-code:Code">
+ <xs:annotation>
+ <xs:documentation>Die Rolle des Kontakts im konkreten Geschäftsprozess, z.B Antragsteller, Zustellungsbevollmächtigter, Gutachter.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="UnstrukturierteAnschrift"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:UnstrukturierteAnschriftType">
+ <xs:annotation>
+ <xs:documentation>Eine unstrukturierte Anschrift des Kontakts.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Geburt" minOccurs="0" type="xdomea:GeburtType">
+ <xs:annotation>
+ <xs:documentation>Die Geburtsangaben des Ansprechpartners zum Kontakt.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="MetadatenAussonderungType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>MetadatenAussonderung</title>
+ </xs:appinfo>
+ <xs:documentation>MetadatenAussonderung fasst die Informationen zu einem abschließend bearbeiteten Schriftgutobjekt (Vorgang oder Akte) zusammen, die für seine Aufbewahrung und Aussonderung relevant sind.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Aufbewahrungsdauer"
+ minOccurs="0"
+ type="xdomea:AufbewahrungsdauerType">
+ <xs:annotation>
+ <xs:documentation>Die Aufbewahrungsdauer legt fest, wie viele Jahre eine Akte oder ein Vorgang nach der Verfügung zur Akte (zdA-Verfügung) innerhalb der aktenführenden Stelle aufzubewahren ist oder ob die Aufbewahrung unbefristet erfolgen soll. Nach Ablauf der Aufbewahrungsfrist erfolgt die Aussonderung in Abhängigkeit von der Aussonderungsart.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Aussonderungsart"
+ minOccurs="0"
+ type="xdomea:AussonderungsartType">
+ <xs:annotation>
+ <xs:documentation>Die Aussonderungsart gibt das Ergebnis der archivischen Bewertung an. Damit eine automatische Selektion der auszusondernden Vorgänge erfolgen kann, muss in Vorgangsbearbeitungssystemen für Akten und Vorgänge ein Metadatum "Aussonderungsart" vorgegeben werden. Die Aussonderungsart wird vom Aktenplan (zweistufiges Aussonderungsverfahren) oder von der Akte (vierstufiges Aussonderungsverfahren) auf zugehörige Vorgänge und Dokumente vererbt.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Kennung" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Kennung enthält bei der Durchführung einer Aussonderung die Archivkennung, bei einer Abgabe die Kennung des Schriftgutobjekts aus dem System der übernehmenden Behörde.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Bewertungsvorschlag"
+ minOccurs="0"
+ type="xdomea:BewertungsvorschlagCodeType">
+ <xs:annotation>
+ <xs:documentation>Der Bewertungsvorschlag ist ein Hinweis des Bearbeiters eines Schriftgutobjekts an das zuständige Archiv. Er kann die Werte archivwürdig oder vernichten annehmen.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Aufbewahrungsende" minOccurs="0" type="xs:date">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Über die Belegung dieses Feldes mit 31.12.JJJJ kann auch nur ein Endjahr angegeben werden. Die Art der Aussonderung (taggenau oder jährlich) ist mit dem zuständigen Archiv abzustimmen.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Das Aufbewahrungsende gibt taggenau das Ende der Aufbewahrungsfrist an.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="NameNatuerlichePersonType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>NameNatuerlichePerson</title>
+ </xs:appinfo>
+ <xs:documentation>NameNatuerlichePerson leitet sich von der entsprechenden XÖV-Kernkomponente ab. Der Name der Person ist eine Benennung dieser Person, die dazu dient, diese Person von anderen Personen zu unterscheiden.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Anrede" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Anrede ist der Namenszusatz (auch eine Anrede ohne Namen nur mit Titel ist eine Anrede!) bei der Anrede (mündlich oder schriftlich) oder bei einem Anruf (fernmündlich) an eine Person oder Personengruppe, z.B. Herr, Frau.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Titel" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Ein Titel wird häufig im Zusammenhang mit Namen verwendet, ist aber kein originärer Bestandteil des Namens. Im Unterschied dazu gehören Adelstitel zum Familiennamen und sind daher in diesem Verständnis kein Titel. Zu den Titeln zählen beispielsweise akademische Grade, Dienst- und Amtsbezeichnungen oder militärische Ränge. Es können auch Titel übermittelt werden, die keine Titel im Sinne des Meldewesens sind.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Familienname" minOccurs="0" type="xdomea:AllgemeinerNameType">
+ <xs:annotation>
+ <xs:documentation>Der Familienname ist der aktuelle Nachname einer Person und Ausdruck einer bestimmten Familienzugehörigkeit dieser Person.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Vorname" minOccurs="0" type="xdomea:AllgemeinerNameType">
+ <xs:annotation>
+ <xs:documentation>Der Vorname ist der Name bzw. der Teil des Namens, der nicht die Zugehörigkeit zu einer Familie ausdrückt, sondern das Individuum innerhalb der Familie bezeichnet und dazu dient, es von anderen Familienmitgliedern zu unterscheiden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="NameOrganisationType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>NameOrganisation</title>
+ </xs:appinfo>
+ <xs:documentation>NameOrganisation leitet sich von der entsprechenden XÖV-Kernkomponente ab und fasst Angaben zum Namen einer Organisation zusammen.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Name" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der offizielle Name einer Organisation. Entspricht bei registrierten Organisationen dem im Register eingetragenen Namen.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Kurzbezeichnung" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Kurzbezeichnung des Namens einer Organisation.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="NkBasisType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>NkBasis</title>
+ </xs:appinfo>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="ProzessID" type="xdomea:stringUUIDType">
+ <xs:annotation>
+ <xs:documentation>Die UUID des Prozesses, zu dem die Nachricht gehört. Sie dient zur Identifikation bei Rückmeldungen.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Nachrichtentyp" type="xdomea:NachrichtentypCodeType">
+ <xs:annotation>
+ <xs:documentation>Der Nachrichtentyp gibt die Bezeichnung der Nachricht an.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Erstellungszeitpunkt" type="xs:dateTime">
+ <xs:annotation>
+ <xs:documentation>Der Zeitpunkt der Nachrichtenerzeugung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Absender" type="xdomea:KontaktType">
+ <xs:annotation>
+ <xs:documentation>Der Absender der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Empfaenger" type="xdomea:KontaktType">
+ <xs:annotation>
+ <xs:documentation>Der Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SendendesSystem" minOccurs="0" type="xdomea:SystemType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zu dem System, aus dem die Daten gesendet werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Hinweis" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Hinweis umfasst Erläuterungen zu der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="AnwendungsspezifischeErweiterung"
+ minOccurs="0"
+ type="xdomea:AnwendungsspezifischeErweiterungType">
+ <xs:annotation>
+ <xs:documentation>AnwendungsspezifischeErweiterung darf nur dazu genutzt werden, weitere (z.B. fachspezifische) Metadaten zu spezifizieren, deren Übermittlung mit den bereits in xdomea spezifizierten Metadaten nicht möglich ist.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="AnwendungsspezifischeErweiterungXML"
+ minOccurs="0"
+ type="xdomea:AnwendungsspezifischeErweiterungXMLType">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Die Speicherung der nicht-auflösbaren Daten beim Empfang erfolgt in einer XML-Datei zum Schriftgutobjekt im empfangenden System. Die Umsetzung muss systemspezifisch gelöst werden - hierbei muss durch das System sichergestellt sein, dass die empfangenen Informationen nicht verloren gehen.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>AnwendungsspezifischeErweiterungXML darf nur dazu genutzt werden, weitere (z.B. fachspezifische) Metadaten zu spezifizieren, deren Übermittlung mit den bereits in xdomea spezifizierten Metadaten nicht möglich ist. Die AnwendungsspezifischeErweiterungXML bietet die Möglichkeit, mittels Einbindung externer XML-Schemata diese Metadaten zu spezifizieren. Es können beliebige XML-Schemata mit unterschiedlichen Namensräumen angegeben werden. Die XML-Schema-Validierung der weiterführenden Metadaten erfolgt innerhalb der xdomea-Nachricht selbst "lax".</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="NkFVDatenType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>NkFVDaten</title>
+ </xs:appinfo>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen zu Nachrichten im Rahmen eines Austauschs von Fachverfahrensdaten.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="xdomea:NkBasisType">
+ <xs:sequence>
+ <xs:element name="EmpfangendesSystem"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:SystemType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zu dem System, das die Daten erhalten soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="NkNichtFVDatenEinEmpfaengerMitEmpfangsbestaetigungType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>NkNichtFVDatenEinEmpfaengerMitEmpfangsbestaetigung</title>
+ </xs:appinfo>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger einer Nachricht, bei der es sich nicht um eine Empfangs-/Importnachricht auf eine andere Nachricht handelt, die einen Empfänger besitzt und mit der eine Empfangsbestätigung angefordert werden kann.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="xdomea:NkBasisType">
+ <xs:sequence>
+ <xs:element name="Empfangsbestaetigung" type="xs:boolean">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Für die Umsetzung in den Systemen wird empfohlen, sofern kein anderer Wert hinterlegt wurde, als Standardwert den Wert 0 für "keine Empfangsbestätigung senden" anzugeben.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die Angabe, ob vom Empfänger der Nachricht eine Empfangsbestätigung erwünscht wird. Eine erwünschte Empfangsbestätigung wird mit 1 gekennzeichnet. Wird keine Empfangsbestätigung gewünscht, so wird dies mit 0 gekennzeichnet.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="NkNichtFVDatenWeitereEmpfaengerMitEmpfangsbestaetigungType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>NkNichtFVDatenWeitereEmpfaengerMitEmpfangsbestaetigung</title>
+ </xs:appinfo>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger einer Nachricht, bei der es sich nicht um eine Empfangs-/Importnachricht auf eine andere Nachricht handelt, die mehrere Empfänger besitzen kann und mit der eine Empfangsbestätigung angefordert werden kann.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="xdomea:NkNichtFVDatenWeitereEmpfaengerType">
+ <xs:sequence>
+ <xs:element name="Empfangsbestaetigung" type="xs:boolean">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Für die Umsetzung in den Systemen wird empfohlen, sofern kein anderer Wert hinterlegt wurde, als Standardwert den Wert 0 für "keine Empfangsbestätigung senden" anzugeben.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die Angabe, ob vom Empfänger der Nachricht eine Empfangsbestätigung erwünscht wird. Eine erwünschte Empfangsbestätigung wird mit 1 gekennzeichnet. Wird keine Empfangsbestätigung gewünscht, so wird dies mit 0 gekennzeichnet.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="NkNichtFVDatenWeitereEmpfaengerType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>NkNichtFVDatenWeitereEmpfaenger</title>
+ </xs:appinfo>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger einer Nachricht, bei der es sich nicht um eine Empfangs-/Importnachricht auf eine andere Nachricht handelt und die beliebige Empfänger besitzen kann.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="xdomea:NkBasisType">
+ <xs:sequence>
+ <xs:element name="WeitererEmpfaenger"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:KontaktType">
+ <xs:annotation>
+ <xs:documentation>Ein weiterer Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="OrganisationseinheitType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Organisationseinheit</title>
+ </xs:appinfo>
+ <xs:documentation>Die Organisationseinheit leitet sich von der entsprechenden XÖV-Kernkomponente ab. Sie fasst Angaben zur Darstellung der internen hierarchischen Organisationsstruktur einer Institution zusammen, z.B. zur Darstellung von Abteilungen, Referaten.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Name" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Bezeichnung der Organisationseinheit.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="PrimaerdokumentType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Primaerdokument</title>
+ </xs:appinfo>
+ <xs:documentation>Ein Primärdokument gehört zum eigentlichen Inhalt eines Dokuments. Es kann sowohl in analoger Form als Inhalt eines Papierdokuments oder in digitaler Form als Inhalt eines elektronischen Dokuments (Datei) vorliegen.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Dateiname" type="xdomea:stringDateinameType">
+ <xs:annotation>
+ <xs:documentation>Der Dateiname des Primärdokumentes, der z.B. nach dem Muster "UUID", "UUID.Dateiformat" oder "UUID_Dokumentname.Dateiformat" gebildet werden kann.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="DateinameOriginal" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Name der Datei zum Zeitpunkt des Imports in ein DMS / VBS.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Ersteller" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>An dieser Stelle wird für den Ersteller der Datentyp "String" verwendet, da es sich hierbei lediglich um den Namen des Erstellers handelt und keine weiteren Steuerungsinformationen damit verbunden sind.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Der Ersteller des Primärdokuments.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="DatumUhrzeit" minOccurs="0" type="xs:dateTime">
+ <xs:annotation>
+ <xs:documentation>Der Erstellungszeitpunkt des Primärdokuments.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SignaturSiegel"
+ minOccurs="0"
+ type="xdomea:SignaturSiegelType">
+ <xs:annotation>
+ <xs:documentation>Angaben zur elektronischen Signatur oder zum elektronischen Siegel, die zum Dokument gehören.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="SignaturSiegelType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Signatur und Siegel</title>
+ </xs:appinfo>
+ <xs:documentation>Angaben zur elektronischen Signatur oder zum elektronischen Siegel.</xs:documentation>
+ </xs:annotation>
+ <xs:choice>
+ <xs:element name="SignaturSiegelEingebettet" fixed="1" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>Die elektronische Signatur oder das elektronische Siegel zum Dokument liegt eingebettet vor.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SignaturSiegelDatei"
+ maxOccurs="unbounded"
+ type="xdomea:stringDateinameType">
+ <xs:annotation>
+ <xs:documentation>Die elektronische Signatur oder das elektronische Siegel zum Dokument liegt in einer separaten Datei vor.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:choice>
+ </xs:complexType>
+ <xs:complexType name="StaatType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Staat</title>
+ </xs:appinfo>
+ <xs:documentation>Staat leitet sich von der entsprechenden XÖV-Kernkomponente ab. Als Staat bezeichnet man eine politische Ordnung, die ein gemeinsames als Staatsgebiet abgegrenztes Territorium, ein dazugehöriges Staatsvolk und eine Machtausübung über dieses umfasst.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Staat" type="xdomea:StaatCodeType">
+ <xs:annotation>
+ <xs:documentation>Staat enthält einen Schlüssel zur Identifikation eines Staates.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="SystemType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>System</title>
+ <implementationHint>Je nach Anwendungsfall ist mindestens eines der enthaltenen Elemente mit Daten zu befüllen.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Ein System ist ein die xdomea-Nachrichten erzeugendes Produkt (z.B. DMS oder VBS).</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="InstanzID" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Instanz-ID dient der eindeutigen Identifikation des Systems, in dem die xdomea-Nachricht erzeugt wird. Die Identifizierung des Mandantens ist darin enthalten.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Produktname" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Name des Produktes.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Version" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Version des Produktes.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="UnstrukturierteAnschriftType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>UnstrukturierteAnschrift</title>
+ </xs:appinfo>
+ <xs:documentation>Die unstrukturierte Anschrift dient der Übermittlung von Anschriften, die nicht der regulären Anschrift entsprechen.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Typ" minOccurs="0" type="xdomea:AnschriftstypCodeType">
+ <xs:annotation>
+ <xs:documentation>Im Typ wird beschrieben, um welche Art der Anschrift es sich handelt. Mögliche Werte sind "Aktuelle Anschrift", "Hauptsitz" oder "Zweitsitz".</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Zeile1" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Erste Zeile der unstrukturierten Anschrift.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Zeile2" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Zweite Zeile der unstrukturierten Anschrift.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Zeile3" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Dritte Zeile der unstrukturierten Anschrift.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Zeile4" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Vierte Zeile der unstrukturierten Anschrift.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Zeile5" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Fünfte Zeile der unstrukturierten Anschrift.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Zeile6" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Sechste Zeile der unstrukturierten Anschrift.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Zusatz" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Ein Anschriftenzusatz beinhaltet ggf. erforderliche weitere Präzisierungen zu einer Anschrift.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="VerfuegungType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Verfuegung</title>
+ </xs:appinfo>
+ <xs:documentation>Eine Verfügung ist ein Mittel zur Steuerung der Bearbeitung eines Schriftgutobjektes in einem Beteiligungsschritt. Die Bearbeitung eines Geschäftsvorfalls wird durch förmliche und abschließend gezeichnete Verfügungen eingeleitet, fortgeführt und abgeschlossen. Gegenstand von Verfügungen können insbesondere sein: Entwürfe von Schreiben Beteiligung anderer Organisationseinheiten Hinweise zur Sicherung eines ausreichenden schriftlichen Nachweises der Bearbeitung Abschließende Verfügung zur weiteren Bearbeitung oder zu deren Abschluss (Schlussverfügung)</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Ersteller" type="xdomea:KontaktType">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>An dieser Stelle wird für den Ersteller der Datentyp "KontaktType" verwendet, da damit der Geschäftsgang (auch organisationsübergreifend) gesteuert werden kann.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die spezifische Ausprägung eines Kontaktes, durch die der Erlasser der Verfügung bestimmt wird.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Adressat" type="xdomea:KontaktType">
+ <xs:annotation>
+ <xs:documentation>Die spezifische Ausprägung eines Kontaktes, durch die der Empfänger der Verfügung bestimmt wird.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Erstellungsdatum" type="xs:date">
+ <xs:annotation>
+ <xs:documentation>Das Erstellungsdatum der Verfügung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Erstellungsuhrzeit" minOccurs="0" type="xs:time">
+ <xs:annotation>
+ <xs:documentation>Die Erstellungsuhrzeit der Verfügung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Verfuegung" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die textuelle Beschreibung der Verfügung, z.B. zur Kenntnis, zur Mitzeichnung, zur Bearbeitung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="TerminDatum" minOccurs="0" type="xs:date">
+ <xs:annotation>
+ <xs:documentation>Das vom Ersteller für die Erledigung der Verfügung festgelegte Datum.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="TerminUhrzeit" minOccurs="0" type="xs:time">
+ <xs:annotation>
+ <xs:documentation>Die vom Ersteller für die Erledigung der Verfügung festgelegte Uhrzeit.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Notiz" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Hinweise oder Erläuterungen zu einer Verfügung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="VersionType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Version</title>
+ </xs:appinfo>
+ <xs:documentation>Eine Version ist ein definierter Stand eines Dokuments zu einem bestimmten Zeitpunkt. Verschiedene Versionen stellen die Veränderung und Weiterentwicklung eines Dokumentes dar. Welche Veränderungen zu einer neuen Version führen, ist eine organisatorische Festlegung. Um die Chronologie abzubilden, erhält auch das Originaldokument eine Versionsnummer.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Nummer" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Nummer der Version.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Format" maxOccurs="unbounded" type="xdomea:FormatType">
+ <xs:annotation>
+ <xs:documentation>Ein Format, das der Dokumentversion zugeordnet ist.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="VerweisType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Verweis</title>
+ <implementationHint>Mindestens eines der Elemente ID bzw. SGOKennzeichen muss gefüllt sein.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Ein Verweis stellt eine inhaltliche Querbeziehung eines Schriftgutobjekts zu einem anderen Schriftgutobjekt dar.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="ID" minOccurs="0" type="xdomea:stringUUIDType">
+ <xs:annotation>
+ <xs:documentation>Die UUID des Schriftgutobjektes, zu dem der inhaltliche Querverweis dargestellt wird.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SGOTyp" type="xdomea:SchriftgutobjekttypCodeType">
+ <xs:annotation>
+ <xs:documentation>Der Typ des Schriftgutobjektes, auf das verwiesen wird. Mögliche Werte sind "Akte", "Dokument" und "Vorgang".</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SGOKennzeichen" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Das Kennzeichen des Schriftgutobjektes, auf das verwiesen wird.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Bemerkung" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Hinweise und Bemerkungen zu diesem Verweis.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="VorgangType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Vorgang</title>
+ </xs:appinfo>
+ <xs:documentation>Vorgang enthält die Metadatenfelder für den Austausch von Vorgängen einschließlich der archivspezifischen Metadaten, anwendungsspezifischer Metadaten, Historien- und Protokollinformationen sowie Informationen zum internen Geschäftsgang. Die absendende Behörde kann jeweils festlegen, welche Informationen dem Empfänger mit der Übertragung zur Verfügung gestellt werden sollen. So kann auch der Anforderung nach einer ggf. erforderlichen Beschränkung der übertragenen Metadaten Rechnung getragen werden (z.B. auf Grund datenschutzrechtlicher oder sonstiger gesetzlicher Bestimmungen).</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Identifikation" type="xdomea:IdentifikationObjektType">
+ <xs:annotation>
+ <xs:documentation>Über Identifikation werden zur systemübergreifend eindeutigen Identifizierung des Vorgangs spezifische Merkmale übergeben.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="AllgemeineMetadaten"
+ minOccurs="0"
+ type="xdomea:AllgemeineMetadatenType">
+ <xs:annotation>
+ <xs:documentation>Über AllgemeineMetadaten werden allgemeine Metadaten zu einem Vorgang angegeben.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="ArchivspezifischeMetadaten"
+ minOccurs="0"
+ type="xdomea:MetadatenAussonderungType">
+ <xs:annotation>
+ <xs:documentation>Über ArchivspezifischeMetadaten werden die für die Archivierung und Aussonderung relevanten Metadaten zu einem Vorgang angegeben.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Aktenbetreff" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Inhaltsangabe der Akte, der der Vorgang untergeordnet ist. Dies ist relevant als Kontextinformation bei der Versendung von Vorgängen ohne die Akte.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Typ" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die weitere Spezifikation des Vorgangs über einen Typ, u.a zur Recherche oder zur Festlegung zusätzlicher Metadaten. Mögliche Werte sind z.B. Genehmigungsverfahren, Widerspruchsverfahren, Kabinettsvorlage etc.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="ZdA" minOccurs="0" type="xs:boolean">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>ZdA (zu den Akten) steht für das Schließen eines Schriftgutobjekts (Teilvorgang, Vorgang, Teilakte oder Akte). Die hierfür in den Verwaltungen genutzten Bezeichnungen können anders lauten (z.B. „Schließen der Akte oder des Vorgangs“).</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>ZdA kennzeichnet, ob der Vorgang zu den Akten verfügt wurde (Wert 1) oder nicht (Wert 0).</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="ZdADatum" minOccurs="0" type="xs:date">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>ZdA (zu den Akten) steht für das Schließen eines Schriftgutobjekts (Teilvorgang, Vorgang, Teilakte oder Akte). Die hierfür in den Verwaltungen genutzten Bezeichnungen können anders lauten (z.B. „Schließen der Akte oder des Vorgangs“).</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>ZdADatum kennzeichnet, wann der Vorgang zu den Akten verfügt wurde.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Laufzeit" minOccurs="0" type="xdomea:ZeitraumType">
+ <xs:annotation>
+ <xs:documentation>Die Laufzeit des Vorgangs, d.h. Zeitpunkt des Beginns und des Endes.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="HistorienProtokollInformation"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:HistorienProtokollInformationType">
+ <xs:annotation>
+ <xs:documentation>Über HistorienProtokollInformation werden die zur Historisierung und Protokollierung relevanten Metadaten zu einem Vorgang angegeben, in der die Veränderungen an den beschreibenden Attributen und dem Zustand des Vorgangs erfasst werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="InternerGeschaeftsgang"
+ minOccurs="0"
+ type="xdomea:GeschaeftsgangType">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Der interne Geschäftsgang kann nach organisatorischer Absprache zwischen den austauschenden Systemen genutzt werden, ist aber nicht verpflichtender Bestandteil von xdomea.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die spezifische Ausprägung eines Geschäftsgangs, über die der interne Geschäftsgang am Vorgang nachgewiesen wird.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Dokument"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:DokumentType">
+ <xs:annotation>
+ <xs:documentation>Ein Dokument, das hierarchisch in den Vorgang eingebunden bzw. dem Vorgang untergeordnet ist.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Verweis"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:VerweisType">
+ <xs:annotation>
+ <xs:documentation>Über einen Verweis wird eine inhaltliche Querbeziehung des Vorgangs zu einem anderen Schriftgutobjekt dargestellt.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Kontakt"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:KontaktType">
+ <xs:annotation>
+ <xs:documentation>Eine Kontaktinformation zu einem Geschäftsprozessbeteiligten.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Teilvorgang"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:VorgangType">
+ <xs:annotation>
+ <xs:documentation>Über einen Teilvorgang kann ein Vorgang hierarchisch in einen anderen Vorgang eingebunden bzw. einem anderen Vorgang untergeordnet werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="AnwendungsspezifischeErweiterung"
+ minOccurs="0"
+ type="xdomea:AnwendungsspezifischeErweiterungType">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Die Speicherung der nicht-auflösbaren Daten beim Empfang erfolgt in einer XML-Datei zum Schriftgutobjekt im empfangenden System. Die Umsetzung muss systemspezifisch gelöst werden - hierbei muss durch das System sichergestellt sein, dass die empfangenen Informationen nicht verloren gehen.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>AnwendungsspezifischeErweiterung darf nur dazu genutzt werden, weitere (z.B. fachspezifische) Metadaten zu spezifizieren, deren Übermittlung mit den bereits in xdomea spezifizierten Metadaten nicht möglich ist.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="AnwendungsspezifischeErweiterungXML"
+ minOccurs="0"
+ type="xdomea:AnwendungsspezifischeErweiterungXMLType">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Die Speicherung der nicht-auflösbaren Daten beim Empfang erfolgt in einer XML-Datei zum Schriftgutobjekt im empfangenden System. Die Umsetzung muss systemspezifisch gelöst werden - hierbei muss durch das System sichergestellt sein, dass die empfangenen Informationen nicht verloren gehen.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>AnwendungsspezifischeErweiterungXML darf nur dazu genutzt werden, weitere (z.B. fachspezifische) Metadaten zu spezifizieren, deren Übermittlung mit den bereits in xdomea spezifizierten Metadaten nicht möglich ist. Die AnwendungsspezifischeErweiterungXML bietet die Möglichkeit, mittels Einbindung externer XML-Schemata diese Metadaten zu spezifizieren. Es können beliebige XML-Schemata mit unterschiedlichen Namensräumen angegeben werden. Die XML-Schema-Validierung der weiterführenden Metadaten erfolgt innerhalb der xdomea-Nachricht selbst "lax".</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="ZeitraumType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Zeitraum</title>
+ </xs:appinfo>
+ <xs:documentation>Der Zeitraum kennzeichnet einen Abschnitt auf dem Zeitstrahl durch Angabe von Beginn und/oder Ende.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Beginn" minOccurs="0" type="xs:date">
+ <xs:annotation>
+ <xs:documentation>Der Beginn eines Zeitraums beschreibt den Zeitpunkt, ab dem ein Sachverhalt eintritt bzw. rechtskräftig wirksam ist. Der Beginn ist immer Teil der Dauer des Zeitraumes. Beispiele sind: Fristbeginn (BKA) Wirksamkeitsdatum der Änderung des Familiennamens (Personenstand) Eheschließungsdatum (Personenstand)</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Ende" minOccurs="0" type="xs:date">
+ <xs:annotation>
+ <xs:documentation>Das Ende eines Zeitraumes beschreibt den Zeitpunkt, ab dem ein Sachverhalt endet bzw. nicht mehr rechtskräftig ist. Das Ende ist selbst Teil der Dauer des Zeitraumes. Beispiele sind: Fristdatum (Bau) Ablaufdatum (Finanz) Faelligkeitsdatum (Finanz) Wirksamkeitsdatum der Aufhebung/Scheidung der Ehe (Personenstand)</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+</xs:schema>
diff --git a/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Datentypen.xsd b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Datentypen.xsd
new file mode 100644
index 0000000000000000000000000000000000000000..060a9d2ea4dbde2c8d6df4f3a500417aab09f16f
--- /dev/null
+++ b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Datentypen.xsd
@@ -0,0 +1,5329 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+ xmlns:xdomea="urn:xoev-de:xdomea:schema:3.0.0"
+ xmlns:xoev-code="http://xoev.de/schemata/code/1_0"
+ targetNamespace="urn:xoev-de:xdomea:schema:3.0.0"
+ version="3.0.0"
+ elementFormDefault="qualified"
+ attributeFormDefault="unqualified">
+ <xs:annotation>
+ <xs:appinfo>
+ <standard>
+ <nameLang>xdomea - XÖV-Standard für den IT-gestützten Austausch und die IT-gestützte Aussonderung behördlichen Schriftgutes</nameLang>
+ <nameKurz>xdomea</nameKurz>
+ <nameTechnisch>xdomea</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:kosit:standard:xdomea</kennung>
+ <beschreibung>xdomea ist der vom IT-Planungsrat verabschiedete verbindliche Standard für den Austausch von Akten, Vorgängen und Dokumenten im Kontext der Übermittlung, der Abgabe sowie der Aussonderung von Schriftgutobjekten (www.it-planungsrat.de, Beschluss 2017/39). Weiterhin kann xdomea für den Austausch zwischen Fachverfahren und DMS/VBS sowie für die Zwischenarchivierung genutzt werden.
+
+Um diese Anwendungsszenarien bestmöglich zu unterstützen, ist xdomea gemäß des XÖV-Rahmenwerkes nach dem Baukastenprinzip aufgebaut und bietet einzelne Nachrichten(gruppen) für die jeweiligen Prozesse an.
+
+Der Standard xdomea wird von der gleichnamigen Arbeitsgruppe des IT-Planungsrates weiterentwickelt und gepflegt. Der Betrieb des Standards erfolgt durch die Koordinierungsstelle für IT-Standards (KoSIT).
+</beschreibung>
+ </standard>
+ <versionStandard>
+ <version>3.0.0</version>
+ <beschreibung>Die Version 3.0.0 ist durch den IT-Planungsrat beschlossen. Details zum Beschluss sowie zu den Fristen der Umsetzung sind der Veröffentlichung im Bundesanzeiger unter www.bundesanzeiger.de zu entnehmen.</beschreibung>
+ <versionXOEVProfil>1.7.2</versionXOEVProfil>
+ <versionXOEVHandbuch>2.3.1</versionXOEVHandbuch>
+ <versionXGenerator>3.0.1</versionXGenerator>
+ <versionModellierungswerkzeug>19.0</versionModellierungswerkzeug>
+ <nameModellierungswerkzeug>MagicDraw</nameModellierungswerkzeug>
+ </versionStandard>
+ </xs:appinfo>
+ <xs:documentation>Datentypen enthält spezifische Datentypen, welche von Datentypen aus anderen Namensräumen (z.B. UN/CEFACT, W3C) abgeleitet wurden.</xs:documentation>
+ </xs:annotation>
+ <xs:import schemaLocation="http://xoev.de/schemata/code/1_0/xoev-code.xsd"
+ namespace="http://xoev.de/schemata/code/1_0"/>
+ <xs:complexType name="AllgemeineRueckmeldungCodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>AllgemeineRueckmeldung</nameLang>
+ <nameKurz>AllgemeineRueckmeldung</nameKurz>
+ <nameTechnisch>allgemeinerueckmeldung</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:allgemeinerueckmeldung</kennung>
+ <beschreibung>Die Werteliste der allgemeinen Rückmeldungen.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.1</version>
+ <datumGueltigkeitAb>2021-10-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von Rückmeldungen für Fachverfahrensnachrichten unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0000000">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Ausführung wurde erfolgreich beendet.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Das DMS ist im Rahmen der Kommunikation vom Fachverfahren in Richtung DMS nicht verfügbar oder antwortet nicht in angemessener Zeit (Time-out).</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Verbindungsabbruch im Rahmen der Kommunikation vom Fachverfahren in Richtung DMS.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Kennung ist dem DMS nicht bekannt.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000004">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Dem Benutzer bzw. der Rolle fehlen die erforderlichen Rechte zum Aufruf der Nachricht im Rahmen der Kommunikation vom Fachverfahren in Richtung DMS.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000005">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die ID des Fachverfahrens ist im Rahmen der Kommunikation vom Fachverfahren in Richtung DMS unbekannt.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000006">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die ID der Verwaltung ist im Rahmen der Kommunikation vom Fachverfahren in Richtung DMS unbekannt.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000007">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>DMS-Session-ID ist im Rahmen der Kommunikation vom Fachverfahren in Richtung DMS ungültig bzw. nicht bekannt.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000008">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die übergebene XML-Struktur entspricht im Rahmen der Kommunikation vom Fachverfahren in Richtung DMS nicht dem angegebenen Schema und ist nicht valide.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000009">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Nachricht ist im Rahmen der Kommunikation vom Fachverfahren in Richtung DMS bereits verarbeitet.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000010">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Stapellänge ist im Rahmen der Kommunikation vom Fachverfahren in Richtung DMS kleiner oder gleich 0.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000011">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Stapellänge ist im Rahmen der Kommunikation vom Fachverfahren in Richtung DMS größer als 1 und somit in der Dialogverarbeitung unzulässig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000012">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Stapellänge ist im Rahmen der Kommunikation vom Fachverfahren in Richtung DMS kleiner als 1 und somit in der Stapelverarbeitung unzulässig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000013">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Länge des Stapels stimmt im Rahmen der Kommunikation vom Fachverfahren in Richtung DMS nicht mit der Anzahl der Objekte im Stapel überein.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000014">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Stapel ist im Rahmen der Kommunikation vom Fachverfahren in Richtung DMS syntaktisch nicht korrekt.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000015">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Übertragungsfehler im Rahmen der Kommunikation vom Fachverfahren in Richtung DMS.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000016">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Das Verzeichnis ist im Rahmen der Kommunikation vom Fachverfahren in Richtung DMS ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000017">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die URL ist im Rahmen der Kommunikation vom Fachverfahren in Richtung DMS ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000018">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Datei kann im Rahmen der Kommunikation vom Fachverfahren in Richtung DMS nicht gefunden werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000019">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Datenbanktabelle ist im Rahmen der Kommunikation vom Fachverfahren in Richtung DMS nicht zugreifbar.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000499">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Unbekannter Fehler im Rahmen der Kommunikation vom Fachverfahren in Richtung DMS.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000501">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Das Fachverfahren ist im Rahmen der Kommunikation vom DMS in Richtung Fachverfahren nicht verfügbar oder antwortet nicht in angemessener Zeit (Time-out).</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000502">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Verbindungsabbruch im Rahmen der Kommunikation vom DMS in Richtung Fachverfahren.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000503">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Kennung ist im Rahmen der Kommunikation vom DMS in Richtung Fachverfahren dem System nicht bekannt.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000504">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Dem Benutzer fehlen im Rahmen der Kommunikation vom DMS in Richtung Fachverfahren die erforderlichen Rechte zum Aufruf der Nachricht.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000505">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die ID des Fachverfahrens ist im Rahmen der Kommunikation vom DMS in Richtung Fachverfahren nicht bekannt.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000506">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die ID der Verwaltung ist im Rahmen der Kommunikation vom DMS in Richtung Fachverfahren nicht bekannt.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000507">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die FV-Session-ID ist im Rahmen der Kommunikation vom DMS in Richtung Fachverfahren ungültig bzw. nicht bekannt.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000508">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die übergebene XML-Struktur entspricht im Rahmen der Kommunikation vom DMS in Richtung Fachverfahren nicht dem angegebenen Schema und ist nicht valide.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000509">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Nachricht wurde im Rahmen der Kommunikation vom DMS in Richtung Fachverfahren bereits verarbeitet.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000510">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Stapellänge ist im Rahmen der Kommunikation vom DMS in Richtung Fachverfahren kleiner oder gleich 0.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000511">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Länge des Stapels stimmt im Rahmen der Kommunikation vom DMS in Richtung Fachverfahren nicht mit der Anzahl der Objekte im Stapel überein.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000512">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Stapel ist im Rahmen der Kommunikation vom DMS in Richtung Fachverfahren syntaktisch nicht korrekt.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000513">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Übertragungsfehler im Rahmen der Kommunikation vom DMS in Richtung Fachverfahren.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000514">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Das Verzeichnis ist im Rahmen der Kommunikation vom DMS in Richtung Fachverfahren ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000515">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die URL ist im Rahmen der Kommunikation vom DMS in Richtung Fachverfahren ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000516">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Datei kann im Rahmen der Kommunikation vom DMS in Richtung Fachverfahren nicht gefunden werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0000999">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Unbekannter Fehler im Rahmen der Kommunikation vom DMS in Richtung Fachverfahren.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:allgemeinerueckmeldung"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.1"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="AnschriftstypCodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>Anschriftstyp</nameLang>
+ <nameKurz>Anschriftstyp</nameKurz>
+ <nameTechnisch>anschriftstyp</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:anschriftstyp</kennung>
+ <beschreibung>Die Werteliste der Anschriftentypen.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von Anschriftentypen unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Aktuelle Anschrift: Die aktuelle Anschrift, z.B. einer Organisation, einer Person.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Hauptsitz: Die Anschrift ist der Hauptsitz, z.B. einer Organisation, oder der Hauptwohnsitz einer Person.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Zweitsitz: Die Anschrift ist der Zweitsitz, z.B. einer Organisation, oder der Nebenwohnsitz einer Person.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:anschriftstyp"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="AussonderungsartCodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>Aussonderungsart</nameLang>
+ <nameKurz>Aussonderungsart</nameKurz>
+ <nameTechnisch>aussonderungsart</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:aussonderungsart</kennung>
+ <beschreibung>Die Werteliste der Aussonderungsarten.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von Aussonderungsarten unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="A">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Das Schriftgutobjekt ist archivwürdig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="B">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Das Schriftgutobjekt ist zum Bewerten markiert.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="V">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Das Schriftgutobjekt ist zum Vernichten markiert.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:aussonderungsart"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="BeteiligungsstatusCodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>Beteiligungsstatus</nameLang>
+ <nameKurz>Beteiligungsstatus</nameKurz>
+ <nameTechnisch>beteiligungsstatus</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:beteiligungsstatus</kennung>
+ <beschreibung>Die Liste der Statuswerte eines Beteiligungsschrittes im Geschäftsgang.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.1</version>
+ <datumGueltigkeitAb>2021-10-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von Beteiligungsstatus unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes. Für die Umsetzung in den Systemen wird empfohlen, sofern kein anderer Wert hinterlegt wurde, als Standardwert den Wert 001 für "Der Schritt liegt in der Zukunft." anzugeben.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Schritt liegt in der Zukunft.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Schritt ist aktuell.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Schritt ist abgeschlossen.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="004">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Schritt wurde übersprungen, jedoch nicht aus dem Geschäftsgang gelöscht. Der Schritt wird im Verlauf des Geschäftsgangs nicht mehr angesprochen.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:beteiligungsstatus"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.1"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="BewertungsvorschlagCodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>Bewertungsvorschlag</nameLang>
+ <nameKurz>Bewertungsvorschlag</nameKurz>
+ <nameTechnisch>bewertungsvorschlag</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:bewertungsvorschlag</kennung>
+ <beschreibung>Die Werteliste der Bewertungsvorschläge.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von Bewertungsvorschlägen unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="A">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Das Schriftgutobjekt ist archivwürdig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="V">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Das Schriftgutobjekt ist zum Vernichten markiert.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:bewertungsvorschlag"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="DateiformatCodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>Dateiformat</nameLang>
+ <nameKurz>Dateiformat</nameKurz>
+ <nameTechnisch>dateiformat</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:dateiformat</kennung>
+ <beschreibung>Die Werteliste der gängigen Dateiformate. Für sonstige Formate existiert der Wert "Sonstiges". Die Angaben stammen größtenteils aus der internationalen Formatdatenbank PRONOM (http://www.nationalarchives.gov.uk/pronom/).</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von Dateiformaten unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" type="xs:token" form="unqualified"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:dateiformat"/>
+ <xs:attribute name="listVersionID" type="xs:normalizedString" use="required"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="DatenaustauschartCodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>Datenaustauschart</nameLang>
+ <nameKurz>Datenaustauschart</nameKurz>
+ <nameTechnisch>datenaustauschart</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:datenaustauschart</kennung>
+ <beschreibung>Die Werteliste der Datenaustauscharten.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.1</version>
+ <datumGueltigkeitAb>2021-10-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von Datenaustauscharten unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Freigegebenes Verzeichnis</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Datenbanktabelle</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>WebDAV und http(s)</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:datenaustauschart"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.1"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="DatentypCodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>Datentyp</nameLang>
+ <nameKurz>Datentyp</nameKurz>
+ <nameTechnisch>datentyp</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:datentyp</kennung>
+ <beschreibung>Die Werteliste der W3C-Datentypen (http://www.w3.org/TR/xmlschema-2, W3C Recommendation 28 October 2004) ergänzt um anySimpleType als Metadatentyp.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.1</version>
+ <datumGueltigkeitAb>2021-10-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von Datentypen unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>anyURI</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>base64Binary</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>boolean</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="004">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>byte</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="005">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>date</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="006">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>dateTime</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="007">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>decimal</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="008">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>double</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="009">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>duration</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="010">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>ENTITIES</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="011">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>ENTITY</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="012">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>float</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="013">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>gDay</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="014">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>gMonth</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="015">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>gMonthDay</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="016">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>gYear</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="017">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>gYearMonth</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="018">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>hexBinary</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="019">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>ID</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="020">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>IDREF</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="021">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>IDREFS</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="022">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>int</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="023">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>integer</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="024">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>language</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="025">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>long</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="026">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Name</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="027">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>NCNAME</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="028">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>negativeInteger</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="029">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>NMTOKEN</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="030">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>NMTOKENS</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="031">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>nonNegativeInteger</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="032">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>nonPositiveInteger</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="033">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>normalizedString</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="034">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>NOTATION</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="035">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>positiveInteger</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="036">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>QName</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="037">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>short</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="038">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>string</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="039">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>time</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="040">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>token</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="041">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>unsignedByte</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="042">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>unsignedInt</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="043">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>unsignedLong</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="044">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>unsignedShort</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="045">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>anySimpleType</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:datentyp"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.1"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="KommunikationsartCodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>Kommunikationskanal / Erreichbarkeit</nameLang>
+ <nameKurz>Erreichbarkeit</nameKurz>
+ <nameTechnisch>erreichbarkeit</nameTechnisch>
+ <kennung>urn:de:xoev:codeliste:erreichbarkeit</kennung>
+ <beschreibung>Eine Liste der Kommunikationsmedien und -kanäle, über die man eine Person oder Institution erreichen kann.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>KoSIT</herausgebernameKurz>
+ </codeliste>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von Kommunikationsarten unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" type="xs:token" form="unqualified"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:de:xoev:codeliste:erreichbarkeit"/>
+ <xs:attribute name="listVersionID" type="xs:normalizedString" use="required"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="KompressionsverfahrenCodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>Kompressionsverfahren</nameLang>
+ <nameKurz>Kompressionsverfahren</nameKurz>
+ <nameTechnisch>kompressionsverfahren</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:kompressionsverfahren</kennung>
+ <beschreibung>Die Werteliste der Kompressionsverfahren.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von Kompressionsverfahren unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>ZIP v2.0</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Gnu ZIP (GZIP) v4.3 / Tape ARchive (TAR)</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:kompressionsverfahren"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="KonfigurationsparameterCodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>Konfigurationsparameter</nameLang>
+ <nameKurz>Konfigurationsparameter</nameKurz>
+ <nameTechnisch>konfigurationsparameter</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:konfigurationsparameter</kennung>
+ <beschreibung>Die Werteliste der Konfigurationsparameter.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.1</version>
+ <datumGueltigkeitAb>2021-10-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von Konfigurationsparametern unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="001001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Transportweg</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="002001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Datenaustauschart</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="003001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Ablageort</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="004001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>LDAP_Name</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="004002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>LDAP_Hostname</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="004003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>LDAP_Port</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="004004">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>LDAP_Bind_DN</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="004005">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>LDAP_Password</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="004006">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>LDAP_Base_DN</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="004007">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>LDAP_Searchfilter</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="004008">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>LDAP_MaxResult</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="005001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>SQL_Name</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="005002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>SQL_Hostname</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="005003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>SQL_Datenbank</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="005004">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>SQL_Tabelle</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="005005">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>SQL_Benutzername</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="005006">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>SQL_Passwort</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="005007">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>SQL_Query</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="006001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>ADDR_Name</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="006002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>ADDR_ATTR1</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="006003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>ADDR_ATTR2</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="006004">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>ADDR_ATTR3</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="006005">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>ADDR_ATTR4</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="006006">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>ADDR_ATTR5</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="006007">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>ADDR_ATTR6</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="006008">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>ADDR_ATTR7</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="006009">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>ADDR_ATTR8</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="006010">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>ADDR_ATTR9</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="006011">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>ADDR_ATTR10</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="007001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Standardablage</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="008001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Komprimierter Datenaustausch</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="008002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Kompressionsverfahren</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:konfigurationsparameter"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.1"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="KonfigurationsparameterGruppeCodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>KonfigurationsparameterGruppe</nameLang>
+ <nameKurz>KonfigurationsparameterGruppe</nameKurz>
+ <nameTechnisch>konfigurationsparametergruppe</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:konfigurationsparametergruppe</kennung>
+ <beschreibung>Die Werteliste der Konfigurationsparametergruppen.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.1</version>
+ <datumGueltigkeitAb>2021-10-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von Konfigurationsparametergruppen unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Transportweg</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Datenaustauschart</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Ablageort</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="004">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>LDAP-Adressverzeichnis</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="005">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>SQL-Server-Adressverzeichnis</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="006">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Unbekanntes Adressverzeichnis</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="007">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Standardablage</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="008">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Komprimierter Datenaustausch</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:konfigurationsparametergruppe"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.1"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="MediumCodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>Medium</nameLang>
+ <nameKurz>Medium</nameKurz>
+ <nameTechnisch>medium</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:medium</kennung>
+ <beschreibung>Die Werteliste der Medienarten.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von Medientypen unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Elektronisch: Das Schriftgutobjekt liegt ausschließlich in elektronischer Form vor.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Hybrid: Das Schriftgutobjekt liegt teilweise in elektronischer Form und teilweise als Papier vor.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Papier: Das Schriftgutobjekt liegt ausschließlich als Papier vor.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:medium"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="NachrichtentypCodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>Nachrichtentyp</nameLang>
+ <nameKurz>Nachrichtentyp</nameKurz>
+ <nameTechnisch>nachrichtentyp</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:nachrichtentyp</kennung>
+ <beschreibung>Die Werteliste der Nachrichtentypen, die den Namen der jeweiligen Nachricht angeben. Der Schlüssel wird entsprechend folgender Regel gebildet: Die ersten zwei Zeichen geben die Nachrichtengruppe an, zu der der Nachrichtentyp gehört, z.B. 01 für "Information". Die letzten zwei Zeichen ergeben die fortlaufende Nummerierung der Nachrichtentypen in einer Nachrichtengruppe.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>2.0</version>
+ <datumGueltigkeitAb>2021-10-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von Nachrichtentypen unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0101">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Information.Information</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0102">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Information.EmpfangBestaetigen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0201">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Geschaeftsgang.Geschaeftsgang</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0202">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Geschaeftsgang.EmpfangBestaetigen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0301">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Aktenplan.Aktenplan</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0302">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Aktenplan.EmpfangBestaetigen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0401">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Abgabe.Abgabe</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0402">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Abgabe.ImportBestaetigen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0403">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Abgabe.EmpfangBestaetigen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0501">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Aussonderung.Anbieteverzeichnis</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0502">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Aussonderung.Bewertungsverzeichnis</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0503">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Aussonderung.Aussonderung</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0504">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Aussonderung.AnbietungEmpfangBestaetigen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0505">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Aussonderung.BewertungEmpfangBestaetigen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0506">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Aussonderung.AussonderungImportBestaetigen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0507">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Aussonderung.AussonderungEmpfangBestaetigen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0511">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Aussonderung.AktenplanZurBewertung</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0512">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Aussonderung.AktenplanZurBewertungEmpfangBestaetigen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0513">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Aussonderung.Bewertungskatalog</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0514">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Aussonderung.BewertungskatalogImportBestaetigen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0515">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Aussonderung.BewerteterAktenplanEmpfangBestaetigen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0601">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.DokumentAktualisieren</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0602">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.SGOAnsehen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0603">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.SGOBearbeiten</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0604">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.SGOErstellen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0605">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.SGOAblegen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0606">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.SGODrucken</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0607">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.ProtokolleintragErstellen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0608">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.SGOSuchen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0609">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.MetadatenAnlegen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0610">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.MetadatenAktualisieren</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0611">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.MetadatenAnsehen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0612">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.MetadatenLoeschen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0613">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.SGOLoeschenMarkieren</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0614">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.SGOLoeschmarkierungAufheben</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0615">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.SGOEndgueltigLoeschen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0616">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.SGOLoeschstatusAbfragen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0617">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.SGOUngueltigKennzeichnen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0618">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.DatensatzLoeschen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0619">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.BenachrichtigungAbrufen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0620">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.VertretungAktivierenOderDeaktivieren</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0621">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.VertretungsstatusAbfragen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0622">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.ZustaendigkeitAendern</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0623">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.GesamtprotokollAblegen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0624">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.SGOZDAVerfuegen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0625">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.SystemstatusAbfragen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0626">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.KonfigurationsparameterErstellen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0627">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.KonfigurationsparameterAktualisieren</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0628">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.KonfigurationsparameterAbrufen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0629">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.EmpfangBestaetigen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0630">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.ImportBestaetigen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0631">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.PrimaerdokumentExportieren</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0632">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>FVDaten.SGOZDAAufheben</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0701">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Zwischenarchivierung.Auslagerung</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0702">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Zwischenarchivierung.AuslagerungEmpfangBestaetigen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0703">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Zwischenarchivierung.AuslagerungImportBestaetigen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0711">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Zwischenarchivierung. RueckleiheAnforderung</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0712">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Zwischenarchivierung. RueckleiheUebergabe</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0713">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Zwischenarchivierung.RueckleiheEmpfangBestaetigen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0721">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Zwischenarchivierung.RueckuebertragungAnforderung</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0722">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Zwischenarchivierung.RueckuebertragungUebergabe</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0723">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Zwischenarchivierung.RueckuebertragungImportBestaetigen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0724">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Zwischenarchivierung.RueckuebertragungEmpfangBestaetigen</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:nachrichtentyp"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="2.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SchriftgutobjekttypCodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>Schriftgutobjekttyp</nameLang>
+ <nameKurz>Schriftgutobjekttyp</nameKurz>
+ <nameTechnisch>schriftgutobjekttyp</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:schriftgutobjekttyp</kennung>
+ <beschreibung>Die Werteliste der Typen von Schriftgutobjekten.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von Schriftgutobjekttypen unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Akte</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Dokument</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Vorgang</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:schriftgutobjekttyp"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SonstigeFehlermeldungCodeType">
+ <xs:annotation>
+ <xs:documentation>Der Datentyp zu sonstigen Fehlermeldungen aus einer Codeliste für die Importbestätigungen unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" type="xs:token" form="unqualified"/>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI" type="xs:anyURI" use="required"/>
+ <xs:attribute name="listVersionID" type="xs:normalizedString" use="required"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0601CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0601.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0601.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0601</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0601</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0601.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0601 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0601001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die ID des Dokuments im DMS ist unbekannt/ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0601002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Das Verzeichnis ist ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0601003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die URL ist ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0601004">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Datei kann nicht gefunden werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0601005">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Es kann keine neue Version erstellt werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0601006">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Name eines Metadatums enthält ungültige Zeichen.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0601007">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Wert eines Metadatums enthält ungültige Zeichen.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0601"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0602CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0602.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0602.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0602</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0602</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0602.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0602 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0602001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die ID des Dokuments ist unbekannt/ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0602002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Das Dokument kann nicht geöffnet werden (bspw. ist zum Dokumenttyp keine Applikation registriert oder der Server hat keinen Zugriff auf den Client).</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0602003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Versionsnummer ist ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0602"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0603CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0603.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0603.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0603</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0603</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0603.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0603 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0603001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die ID des Dokuments ist unbekannt/ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0603002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Das Dokument kann nicht geöffnet werden (bspw. ist zum Dokumenttyp keine Applikation registriert).</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0603003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Versionsnummer ist ungültig</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0603"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0604CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0604.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0604.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0604</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0604</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0604.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0604 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0604001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die ID des Containerobjekts ist unbekannt/ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0604002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Schriftgutobjekttyp ist nicht definiert.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0604003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Das Schriftgutobjekt kann nicht angelegt werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0604004">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Das Objekt kann nicht geöffnet werden (bspw. ist zum Dokumenttyp keine Applikation registriert).</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0604005">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Name eines Metadatums enthält ungültige Zeichen.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0604006">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Wert eines Metadatums enthält ungültige Zeichen.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0604007">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Beschreibung eines Metadatums enthält ungültige Zeichen.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0604"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0605CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0605.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0605.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0605</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0605</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0605.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0605 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0605001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die ID des Containers ist im DMS unbekannt/ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0605002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Das Verzeichnis ist ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0605003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die URL ist ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0605004">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Datei kann nicht gefunden werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0605005">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Datei kann im DMS nicht abgelegt werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0605006">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Name eines Metadatums enthält ungültige Zeichen.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0605007">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Wert eines Metadatums enthält ungültige Zeichen.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0605008">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Beschreibung eines Metadatums enthält ungültige Zeichen.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0605"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0606CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0606.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0606.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0606</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0606</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0606.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0606 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0606001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die ID des Objektes ist unbekannt/ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0606002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der angegebene Drucker existiert nicht.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0606003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der angegebene Drucker ist nicht bereit.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0606004">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Unterschriftgutobjekttyp existiert nicht.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0606005">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Druck ist fehlgeschlagen.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0606006">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Version des Dokuments existiert nicht.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0606"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0607CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0607.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0607.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0607</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0607</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0607.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0607 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0607001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die ID ist unbekannt/ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0607002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Protokolleintragsinformationen beinhalten ungültige Zeichen.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0607003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Protokolleintrag kann nicht angelegt werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0607"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0608CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0608.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0608.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0608</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0608</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0608.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0608 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0608001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Suchtyp ist unbekannt/ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0608"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0609CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0609.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0609.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0609</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0609</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0609.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0609 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0609001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die ID des Objektes ist unbekannt/ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0609002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Name des Metadatums ist ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0609003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Beschreibung des Metadatums ist ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0609004">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Datentyp des Metadatums existiert nicht.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0609005">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Wert des Metadatums ist ungültig/befindet sich außerhalb des Wertebereichs.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0609006">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Das Metadatum kann nicht angelegt werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0609007">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Datentyp für das Metadatum wurde nicht angegeben.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0609008">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Wert für das Metadatum wurde nicht angegeben.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0609"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0610CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0610.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0610.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0610</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0610</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0610.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0610 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0610001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die ID des Objektes ist unbekannt/ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0610002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Name des Metadatums ist ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0610003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Beschreibung des Metadatums ist ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0610004">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Wert des Metadatums ist ungültig/befindet sich außerhalb des Wertebereichs.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0610005">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Das Metadatum kann nicht aktualisiert werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0610006">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Datentyp des Metadatums weicht vom vorhandenen Datentyp ab.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0610007">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Wert des Metadatums wurde nicht gesetzt.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0610"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0611CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0611.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0611.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0611</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0611</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0611.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.1</version>
+ <datumGueltigkeitAb>2021-10-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0611 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0611001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die UUID des Objektes ist ungültig/unbekannt.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0611002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Name des Metadatums ist ungültig/unbekannt.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0611003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Das Metadatum kann nicht ausgelesen werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0611004">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Beschreibung des Metadatums weicht von der vorhandenen Beschreibung ab.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0611005">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Datentyp des Metadatums weicht von dem vorhandenen Datentyp ab.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0611006">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Wert des Metadatums weicht von dem vorhandenen Wert ab.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0611"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.1"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0612CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0612.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0612.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0612</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0612</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0612.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0612 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0612001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die ID des Objektes ist ungültig/unbekannt.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0612002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Name des Metadatums ist ungültig/unbekannt.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0612003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Das Metadatum kann nicht gelöscht werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0612004">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Beschreibung des Metadatums unterscheidet sich von der vorhandenen: Metadatum nicht gelöscht.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0612005">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Datentyp des Metadatums unterscheidet sich von dem vorhandenen: Metadatum nicht gelöscht.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0612006">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Wert des Metadatums unterscheidet sich von dem vorhandenen: Metadatum nicht gelöscht.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0612"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0613CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0613.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0613.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0613</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0613</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0613.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0613 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0613001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die ID des Schriftgutobjektes ist unbekannt/ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0613002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Das Schriftgutobjekt kann nicht zum Löschen markiert werden (z. B. weil es zur Bearbeitung gesperrt ist).</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0613"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0614CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0614.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0614.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0614</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0614</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0614.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0614 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0614001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die ID des Schriftgutobjektes ist unbekannt/ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0614002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Das Schriftgutobjekt ist nicht zum Löschen markiert.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0614003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Löschmarkierung kann nicht aufgehoben werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0614"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0615CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0615.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0615.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0615</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0615</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0615.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0615 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0615001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die ID des Schriftgutobjektes ist unbekannt/ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0615002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Das Schriftgutobjekt kann nicht gelöscht werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0615"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0616CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0616.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0616.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0616</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0616</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0616.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0616 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0616001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die ID des Schriftgutobjektes ist unbekannt/ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0616002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Status kann nicht abgefragt werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0616"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0617CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0617.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0617.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0617</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0617</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0617.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0617 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0617001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die ID des Objektes ist unbekannt/ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0617002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Das Schriftgutobjekt kann nicht als ungültig gekennzeichnet werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0617"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0618CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0618.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0618.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0618</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0618</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0618.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0618 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0618001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die ID des Datensatzes ist im DMS unbekannt/ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0618002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Mindestens ein Schriftgutobjekt kann nicht gelöscht werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0618"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0619CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0619.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0619.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0619</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0619</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0619.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0619 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0619001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Nachrichten können nicht abgefragt werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0619002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Keine Nachricht vorhanden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0619"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0620CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0620.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0620.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0620</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0620</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0620.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0620 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0620001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Benutzer/Rolle des zu Vertretenden ist unbekannt.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0620002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Benutzer/Rolle des Vertreters ist unbekannt.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0620003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Vertretung ist bereits aktiviert.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0620004">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Vertretung ist bereits deaktiviert.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0620005">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Vertretung kann nicht aktiviert werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0620006">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Vertretung kann nicht deaktiviert werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0620"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0621CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0621.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0621.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0621</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0621</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0621.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.1</version>
+ <datumGueltigkeitAb>2021-10-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0621 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0621001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Benutzer/Rolle, für den/die der Status abgefragt werden soll, ist unbekannt.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0621002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Status kann nicht abgefragt werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0621"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.1"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0622CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0622.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0622.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0622</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0622</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0622.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0622 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0622001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>ID des Schriftgutobjektes nicht bekannt/ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0622002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Neu zuständiger/zuständige Benutzer/Rolle ist unbekannt.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0622003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Bisher zuständiger/zuständige Benutzer/Rolle ist unbekannt.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0622004">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Kennzeichen der aufnehmenden Aktenplaneinheit ist unbekannt.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0622005">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>ID der aufnehmenden Akte ist unbekannt.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0622006">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Kennzeichen der abgebenden Aktenplaneinheit ist unbekannt.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0622007">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>ID der abgebenden Akte ist unbekannt.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0622008">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Name eines Metadatums enthält ungültige Zeichen.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0622009">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Beschreibung des Metadatums enthält ungültige Zeichen.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0622010">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Wert eines Metadatums enthält ungültige Zeichen.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0622011">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Zuständigkeitswechsel kann nicht durchgeführt werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0622"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0623CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0623.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0623.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0623</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0623</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0623.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.1</version>
+ <datumGueltigkeitAb>2021-10-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0623 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0623001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die ID des Schriftgutobjektes ist unbekannt/ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0623002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Das Verzeichnis ist ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0623003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die URL ist ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0623004">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Protokoll als Datei kann nicht abgelegt werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0623005">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Protokoll als xdomea-Geschäftsgang kann nicht abgelegt werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0623006">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Syntaxfehler in xdomea-Geschäftsgang-Daten.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0623007">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>HistorienProtokollinformationen konnten nicht angelegt werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0623"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.1"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0624CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0624.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0624.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0624</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0624</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0624.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0624 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0624001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>ID des Schriftgutobjektes nicht bekannt/ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0624002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die zdA-Verfügung kann nicht durchgeführt werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0624"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0625CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0625.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0625.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0625</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0625</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0625.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0625 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0625001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Systemstatus-ID ist unbekannt/ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0625002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Status kann nicht abgefragt werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0625"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0626CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0626.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0626.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0626</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0626</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0626.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0626 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0626001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Name des Konfigurationsparameters ist ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0626002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Wert des Konfigurationsparameters ist ungültig/liegt außerhalb des definierten Wertebereichs.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0626003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Datentyp ist unbekannt.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0626"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0627CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0627.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0627.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0627</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0627</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0627.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0627 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0627001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Name des Konfigurationsparameters ist ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0627002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Wert des Konfigurationsparameters ist ungültig/liegt außerhalb des definierten Wertebereichs.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0627003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Konfigurationsparameter kann nicht aktualisiert werden (bspw. wegen fehlender Rechte).</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0627004">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Typ des Konfigurationsparameters entspricht nicht dem aktuellen Typ des Konfigurationsparameters.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0627"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0628CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0628.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0628.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0628</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0628</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0628.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0628 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0628001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Name des Konfigurationsparameters ist ungültig/unbekannt.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0628002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Der Konfigurationsparameter kann nicht ausgelesen werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0628"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0631CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0631.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0631.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0631</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0631</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0631.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0631 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0631001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die ID des Dokuments ist unbekannt/ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0631002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die Versionsnummer ist ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0631"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SpezifischeFehlermeldung0632CodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>0632.SpezifischeFehlermeldung</nameLang>
+ <nameKurz>0632.SpezifischeFehlermeldung</nameKurz>
+ <nameTechnisch>spezifischefehlermeldung0632</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0632</kennung>
+ <beschreibung>Die Werteliste der spezifischen Rückmeldungen zur Nachricht 0632.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.1</version>
+ <datumGueltigkeitAb>2021-10-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von spezifischen Fehlermeldungen für die Nachricht 0632 unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="0632001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die ID des Schriftgutobjektes ist nicht bekannt/ungültig.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="0632002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Die zdA-Verfügung kann nicht aufgehoben werden.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:spezifischefehlermeldung0632"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.1"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="StaatCodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>Country Codes</nameLang>
+ <nameKurz>Country Codes</nameKurz>
+ <nameTechnisch>Country-Codes</nameTechnisch>
+ <kennung>urn:xoev-de:kosit:codeliste:country-codes</kennung>
+ <beschreibung>Die Codeliste basiert auf der Staats- und Gebietssystematik des Statistischen Bundesamtes (DESTATIS) und dem Standard "Country codes" der International Organization for Standardization (ISO). Die vorliegende Liste enthält alle "officially assigned codes" (Alpha-2 und Numerisch) der ISO-Liste. Kurz- und Langnamen der aufgeführten Einträge wurden, sofern vorhanden, der DESTATIS-Liste entnommen. Zu den nicht in der DESTATIS-Liste geführten Codeeinträgen wurden die zugehörigen Namen der Deutschen Fassung der Norm entnommen.</beschreibung>
+ <herausgebernameLang>Koordinierungsstelle für IT-Standards</herausgebernameLang>
+ <herausgebernameKurz>KoSIT</herausgebernameKurz>
+ </codeliste>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von Staaten unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes. Genutzt wird hier die ISO-3166-1-Liste. Für den Schlüssel (code) wird die Spalte "ALPHA2" und für den beschreibenden Namen (name) die Spalte "Name des Landes" verwendet.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" type="xs:token" form="unqualified"/>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:kosit:codeliste:country-codes"/>
+ <xs:attribute name="listVersionID" type="xs:normalizedString" use="required"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="TransportwegCodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>Transportweg</nameLang>
+ <nameKurz>Transportweg</nameKurz>
+ <nameTechnisch>transportweg</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:transportweg</kennung>
+ <beschreibung>Die Werteliste der Transportwege.</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von Transportwegen unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Web Service</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Austauschverzeichnis</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Austauschdatenbank</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:transportweg"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="VertraulichkeitsstufeCodeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <codeliste>
+ <nameLang>Vertraulichkeitsstufe</nameLang>
+ <nameKurz>Vertraulichkeitsstufe</nameKurz>
+ <nameTechnisch>vertraulichkeitsstufe</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:codeliste:vertraulichkeitsstufe</kennung>
+ <beschreibung>Die Werteliste der Vertraulichkeitsstufen von Schriftgutobjekten nach Verschlusssachenanweisungen des Bundes und der Länder (VSA).</beschreibung>
+ <herausgebernameLang>AG xdomea des IT-Planungsrates</herausgebernameLang>
+ <herausgebernameKurz>ag-xdomea</herausgebernameKurz>
+ </codeliste>
+ <versionCodeliste>
+ <version>1.0</version>
+ <datumGueltigkeitAb>2016-01-01</datumGueltigkeitAb>
+ <versionCodelistenHandbuch>1.1</versionCodelistenHandbuch>
+ </versionCodeliste>
+ <codelistenspalten>
+ <code>
+ <spaltennameLang>Code</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>true</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>true</empfohleneCodeSpalte>
+ </code>
+ <beschreibung>
+ <spaltennameLang>Beschreibung</spaltennameLang>
+ <datentyp>string</datentyp>
+ <codeSpalte>false</codeSpalte>
+ <verwendung>required</verwendung>
+ <empfohleneCodeSpalte>false</empfohleneCodeSpalte>
+ </beschreibung>
+ </codelistenspalten>
+ <genutzteCodeSpalte>code</genutzteCodeSpalte>
+ </xs:appinfo>
+ <xs:documentation>Der Datentyp zur Werteliste von Vertraulichkeitsstufen unter Angabe weiterer Informationen zur konkreten Angabe eines Wertes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xoev-code:Code">
+ <xs:sequence>
+ <xs:element name="code" form="unqualified">
+ <xs:simpleType>
+ <xs:restriction base="xs:token">
+ <xs:enumeration value="001">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Geheim: Das Schriftgutobjekt ist als geheim eingestuft.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="002">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>NfD: Das Schriftgutobjekt ist als "nur für den Dienstgebrauch (nfD)" eingestuft.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="003">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Offen: Das Schriftgutobjekt ist nicht eingestuft.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="004">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Streng geheim: Das Schriftgutobjekt ist als streng geheim eingestuft.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ <xs:enumeration value="005">
+ <xs:annotation>
+ <xs:appinfo>
+ <beschreibung>Vertraulich: Das Schriftgutobjekt ist als vertraulich eingestuft.</beschreibung>
+ </xs:appinfo>
+ </xs:annotation>
+ </xs:enumeration>
+ </xs:restriction>
+ </xs:simpleType>
+ </xs:element>
+ <xs:element name="name"
+ type="xs:normalizedString"
+ form="unqualified"
+ minOccurs="0"/>
+ </xs:sequence>
+ <xs:attribute name="listURI"
+ type="xs:anyURI"
+ use="optional"
+ fixed="urn:xoev-de:xdomea:codeliste:vertraulichkeitsstufe"/>
+ <xs:attribute name="listVersionID"
+ type="xs:normalizedString"
+ use="optional"
+ fixed="1.0"/>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:simpleType name="stringDateinameType">
+ <xs:annotation>
+ <xs:documentation>Der Datentyp zur Angabe eines Dateinamens.</xs:documentation>
+ </xs:annotation>
+ <xs:restriction base="xs:string">
+ <xs:pattern value="[0-9|A-F|a-f]{8}-[0-9|A-F|a-f]{4}-[0-9|A-F|a-f]{4}-[0-9|A-F|a-f]{4}-[0-9|A-F|a-f]{12}[_]?.*[\.]?.*"/>
+ </xs:restriction>
+ </xs:simpleType>
+ <xs:simpleType name="stringUUIDType">
+ <xs:annotation>
+ <xs:documentation>Der Datentyp zur Angabe einer UUID.</xs:documentation>
+ </xs:annotation>
+ <xs:restriction base="xs:string">
+ <xs:pattern value="[0-9|A-F|a-f]{8}-[0-9|A-F|a-f]{4}-[0-9|A-F|a-f]{4}-[0-9|A-F|a-f]{4}-[0-9|A-F|a-f]{12}"/>
+ </xs:restriction>
+ </xs:simpleType>
+</xs:schema>
diff --git a/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-AbgabeDurchfuehren.xsd b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-AbgabeDurchfuehren.xsd
new file mode 100644
index 0000000000000000000000000000000000000000..51499776bfdabc173a9e6dfea2096b3d267b25dc
--- /dev/null
+++ b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-AbgabeDurchfuehren.xsd
@@ -0,0 +1,122 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+ xmlns:xdomea="urn:xoev-de:xdomea:schema:3.0.0"
+ targetNamespace="urn:xoev-de:xdomea:schema:3.0.0"
+ version="3.0.0"
+ elementFormDefault="qualified"
+ attributeFormDefault="unqualified">
+ <xs:annotation>
+ <xs:appinfo>
+ <standard>
+ <nameLang>xdomea - XÖV-Standard für den IT-gestützten Austausch und die IT-gestützte Aussonderung behördlichen Schriftgutes</nameLang>
+ <nameKurz>xdomea</nameKurz>
+ <nameTechnisch>xdomea</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:kosit:standard:xdomea</kennung>
+ <beschreibung>xdomea ist der vom IT-Planungsrat verabschiedete verbindliche Standard für den Austausch von Akten, Vorgängen und Dokumenten im Kontext der Übermittlung, der Abgabe sowie der Aussonderung von Schriftgutobjekten (www.it-planungsrat.de, Beschluss 2017/39). Weiterhin kann xdomea für den Austausch zwischen Fachverfahren und DMS/VBS sowie für die Zwischenarchivierung genutzt werden.
+
+Um diese Anwendungsszenarien bestmöglich zu unterstützen, ist xdomea gemäß des XÖV-Rahmenwerkes nach dem Baukastenprinzip aufgebaut und bietet einzelne Nachrichten(gruppen) für die jeweiligen Prozesse an.
+
+Der Standard xdomea wird von der gleichnamigen Arbeitsgruppe des IT-Planungsrates weiterentwickelt und gepflegt. Der Betrieb des Standards erfolgt durch die Koordinierungsstelle für IT-Standards (KoSIT).
+</beschreibung>
+ </standard>
+ <versionStandard>
+ <version>3.0.0</version>
+ <beschreibung>Die Version 3.0.0 ist durch den IT-Planungsrat beschlossen. Details zum Beschluss sowie zu den Fristen der Umsetzung sind der Veröffentlichung im Bundesanzeiger unter www.bundesanzeiger.de zu entnehmen.</beschreibung>
+ <versionXOEVProfil>1.7.2</versionXOEVProfil>
+ <versionXOEVHandbuch>2.3.1</versionXOEVHandbuch>
+ <versionXGenerator>3.0.1</versionXGenerator>
+ <versionModellierungswerkzeug>19.0</versionModellierungswerkzeug>
+ <nameModellierungswerkzeug>MagicDraw</nameModellierungswerkzeug>
+ </versionStandard>
+ <title>Abgabe durchführen</title>
+ </xs:appinfo>
+ </xs:annotation>
+ <xs:include schemaLocation="xdomea-Baukasten.xsd"/>
+ <xs:include schemaLocation="xdomea-Typen-AbgabeDurchfuehren.xsd"/>
+ <xs:element name="Abgabe.Abgabe.0401">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt den vollständigen Export von Schriftgutobjekten bei Zuständigkeitswechseln zwischen Behörden oder bei Systemwechseln.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkAbgabeType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Abgabe-Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Anschreiben" minOccurs="0" type="xdomea:DokumentType">
+ <xs:annotation>
+ <xs:documentation>Ein Dokument, das dem Empfänger zur Erläuterung der Abgabe mitgegeben wird.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Schriftgutobjekt" maxOccurs="unbounded">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Bei der Abgabe müssen zu einem Schriftgutobjekt alle prozess- und aktenrelevanten Metadaten übergeben werden. Die Fristen und die Aussonderungsart werden bei der Abgabe zu einem Schriftgutobjekt mit übergeben. Die aufnehmende Behörde kann entscheiden, ob diese Informationen dann in das eigene System übernommen werden oder nicht.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Ein Schriftgutobjekt (Akte, Vorgang oder Dokument) zu einer Abgabe.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:choice>
+ <xs:element name="Akte" type="xdomea:AkteType">
+ <xs:annotation>
+ <xs:documentation>Eine Akte.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Vorgang" type="xdomea:VorgangType">
+ <xs:annotation>
+ <xs:documentation>Ein Vorgang.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Dokument" type="xdomea:DokumentType">
+ <xs:annotation>
+ <xs:documentation>Ein Dokument.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:choice>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Aktenplan" minOccurs="0" type="xdomea:AktenplanType">
+ <xs:annotation>
+ <xs:documentation>Der Aktenplan zu einer Abgabe enthält ein aufgabenbezogenes mehrstufiges Ordnungssystem mit einer hierarchischer Gliederung für das Bilden und Kennzeichnen von Akten und Vorgängen sowie das Zuordnen von Dokumenten.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Abgabe.ImportBestaetigen.0402">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die erfolgreiche oder nicht erfolgreiche Übernahme der Abgabe.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkBasisType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Importnachricht zu einer Abgabe.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="AbgegebenesObjekt"
+ maxOccurs="unbounded"
+ type="xdomea:ErfolgOderMisserfolgAbgabeType">
+ <xs:annotation>
+ <xs:documentation>Die Information zum erfolgreichen oder nicht erfolgreichen Import eines Schriftgutobjekts zur Abgabe.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Abgabe.EmpfangBestaetigen.0403">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt den erfolgreichen Empfang der Abgabe.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkBasisType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Empfangsbestätigung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+</xs:schema>
diff --git a/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-AktenplanAustauschen.xsd b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-AktenplanAustauschen.xsd
new file mode 100644
index 0000000000000000000000000000000000000000..2b96a4c682119014aed547820d17e2c842d5ce76
--- /dev/null
+++ b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-AktenplanAustauschen.xsd
@@ -0,0 +1,72 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+ xmlns:xdomea="urn:xoev-de:xdomea:schema:3.0.0"
+ targetNamespace="urn:xoev-de:xdomea:schema:3.0.0"
+ version="3.0.0"
+ elementFormDefault="qualified"
+ attributeFormDefault="unqualified">
+ <xs:annotation>
+ <xs:appinfo>
+ <standard>
+ <nameLang>xdomea - XÖV-Standard für den IT-gestützten Austausch und die IT-gestützte Aussonderung behördlichen Schriftgutes</nameLang>
+ <nameKurz>xdomea</nameKurz>
+ <nameTechnisch>xdomea</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:kosit:standard:xdomea</kennung>
+ <beschreibung>xdomea ist der vom IT-Planungsrat verabschiedete verbindliche Standard für den Austausch von Akten, Vorgängen und Dokumenten im Kontext der Übermittlung, der Abgabe sowie der Aussonderung von Schriftgutobjekten (www.it-planungsrat.de, Beschluss 2017/39). Weiterhin kann xdomea für den Austausch zwischen Fachverfahren und DMS/VBS sowie für die Zwischenarchivierung genutzt werden.
+
+Um diese Anwendungsszenarien bestmöglich zu unterstützen, ist xdomea gemäß des XÖV-Rahmenwerkes nach dem Baukastenprinzip aufgebaut und bietet einzelne Nachrichten(gruppen) für die jeweiligen Prozesse an.
+
+Der Standard xdomea wird von der gleichnamigen Arbeitsgruppe des IT-Planungsrates weiterentwickelt und gepflegt. Der Betrieb des Standards erfolgt durch die Koordinierungsstelle für IT-Standards (KoSIT).
+</beschreibung>
+ </standard>
+ <versionStandard>
+ <version>3.0.0</version>
+ <beschreibung>Die Version 3.0.0 ist durch den IT-Planungsrat beschlossen. Details zum Beschluss sowie zu den Fristen der Umsetzung sind der Veröffentlichung im Bundesanzeiger unter www.bundesanzeiger.de zu entnehmen.</beschreibung>
+ <versionXOEVProfil>1.7.2</versionXOEVProfil>
+ <versionXOEVHandbuch>2.3.1</versionXOEVHandbuch>
+ <versionXGenerator>3.0.1</versionXGenerator>
+ <versionModellierungswerkzeug>19.0</versionModellierungswerkzeug>
+ <nameModellierungswerkzeug>MagicDraw</nameModellierungswerkzeug>
+ </versionStandard>
+ <title>Aktenplan austauschen</title>
+ </xs:appinfo>
+ </xs:annotation>
+ <xs:include schemaLocation="xdomea-Baukasten.xsd"/>
+ <xs:element name="Aktenplan.Aktenplan.0301">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Die austauschenden Behörden müssen die für den Aktenplan erforderliche Konfiguration abstimmen, wenn dieser übernommen werden soll.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die Nachricht beschreibt den Export eines Aktenplans zur Information oder Übernahme in ein anderes System.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf"
+ type="xdomea:NkNichtFVDatenWeitereEmpfaengerMitEmpfangsbestaetigungType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Aktenplan-Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Aktenplan" type="xdomea:AktenplanType">
+ <xs:annotation>
+ <xs:documentation>Der zu übergebende Aktenplan enthält ein aufgabenbezogenes mehrstufiges Ordnungssystem mit hierarchischer Gliederung für das Bilden und Kennzeichnen von Akten und Vorgängen sowie das Zuordnen von Dokumenten.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Aktenplan.EmpfangBestaetigen.0302">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt den erfolgreichen Empfang des Aktenplans.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkBasisType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Empfangsbestätigung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+</xs:schema>
diff --git a/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-Archivsystem.xsd b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-Archivsystem.xsd
new file mode 100644
index 0000000000000000000000000000000000000000..08946f4b970c317144764fd67fda24ae4f2ed87b
--- /dev/null
+++ b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-Archivsystem.xsd
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+ xmlns:xdomea="urn:xoev-de:xdomea:schema:3.0.0"
+ targetNamespace="urn:xoev-de:xdomea:schema:3.0.0"
+ version="3.0.0"
+ elementFormDefault="qualified"
+ attributeFormDefault="unqualified">
+ <xs:annotation>
+ <xs:appinfo>
+ <standard>
+ <nameLang>xdomea - XÖV-Standard für den IT-gestützten Austausch und die IT-gestützte Aussonderung behördlichen Schriftgutes</nameLang>
+ <nameKurz>xdomea</nameKurz>
+ <nameTechnisch>xdomea</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:kosit:standard:xdomea</kennung>
+ <beschreibung>xdomea ist der vom IT-Planungsrat verabschiedete verbindliche Standard für den Austausch von Akten, Vorgängen und Dokumenten im Kontext der Übermittlung, der Abgabe sowie der Aussonderung von Schriftgutobjekten (www.it-planungsrat.de, Beschluss 2017/39). Weiterhin kann xdomea für den Austausch zwischen Fachverfahren und DMS/VBS sowie für die Zwischenarchivierung genutzt werden.
+
+Um diese Anwendungsszenarien bestmöglich zu unterstützen, ist xdomea gemäß des XÖV-Rahmenwerkes nach dem Baukastenprinzip aufgebaut und bietet einzelne Nachrichten(gruppen) für die jeweiligen Prozesse an.
+
+Der Standard xdomea wird von der gleichnamigen Arbeitsgruppe des IT-Planungsrates weiterentwickelt und gepflegt. Der Betrieb des Standards erfolgt durch die Koordinierungsstelle für IT-Standards (KoSIT).
+</beschreibung>
+ </standard>
+ <versionStandard>
+ <version>3.0.0</version>
+ <beschreibung>Die Version 3.0.0 ist durch den IT-Planungsrat beschlossen. Details zum Beschluss sowie zu den Fristen der Umsetzung sind der Veröffentlichung im Bundesanzeiger unter www.bundesanzeiger.de zu entnehmen.</beschreibung>
+ <versionXOEVProfil>1.7.2</versionXOEVProfil>
+ <versionXOEVHandbuch>2.3.1</versionXOEVHandbuch>
+ <versionXGenerator>3.0.1</versionXGenerator>
+ <versionModellierungswerkzeug>19.0</versionModellierungswerkzeug>
+ <nameModellierungswerkzeug>MagicDraw</nameModellierungswerkzeug>
+ </versionStandard>
+ </xs:appinfo>
+ </xs:annotation>
+ <xs:include schemaLocation="xdomea-Nachrichten-AktenplanAustauschen.xsd"/>
+ <xs:include schemaLocation="xdomea-Nachrichten-AussonderungDurchfuehren.xsd"/>
+</xs:schema>
diff --git a/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-AussonderungDurchfuehren.xsd b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-AussonderungDurchfuehren.xsd
new file mode 100644
index 0000000000000000000000000000000000000000..1ed82d2216a97067129fd87ad4400b097bb95737
--- /dev/null
+++ b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-AussonderungDurchfuehren.xsd
@@ -0,0 +1,324 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+ xmlns:xdomea="urn:xoev-de:xdomea:schema:3.0.0"
+ targetNamespace="urn:xoev-de:xdomea:schema:3.0.0"
+ version="3.0.0"
+ elementFormDefault="qualified"
+ attributeFormDefault="unqualified">
+ <xs:annotation>
+ <xs:appinfo>
+ <standard>
+ <nameLang>xdomea - XÖV-Standard für den IT-gestützten Austausch und die IT-gestützte Aussonderung behördlichen Schriftgutes</nameLang>
+ <nameKurz>xdomea</nameKurz>
+ <nameTechnisch>xdomea</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:kosit:standard:xdomea</kennung>
+ <beschreibung>xdomea ist der vom IT-Planungsrat verabschiedete verbindliche Standard für den Austausch von Akten, Vorgängen und Dokumenten im Kontext der Übermittlung, der Abgabe sowie der Aussonderung von Schriftgutobjekten (www.it-planungsrat.de, Beschluss 2017/39). Weiterhin kann xdomea für den Austausch zwischen Fachverfahren und DMS/VBS sowie für die Zwischenarchivierung genutzt werden.
+
+Um diese Anwendungsszenarien bestmöglich zu unterstützen, ist xdomea gemäß des XÖV-Rahmenwerkes nach dem Baukastenprinzip aufgebaut und bietet einzelne Nachrichten(gruppen) für die jeweiligen Prozesse an.
+
+Der Standard xdomea wird von der gleichnamigen Arbeitsgruppe des IT-Planungsrates weiterentwickelt und gepflegt. Der Betrieb des Standards erfolgt durch die Koordinierungsstelle für IT-Standards (KoSIT).
+</beschreibung>
+ </standard>
+ <versionStandard>
+ <version>3.0.0</version>
+ <beschreibung>Die Version 3.0.0 ist durch den IT-Planungsrat beschlossen. Details zum Beschluss sowie zu den Fristen der Umsetzung sind der Veröffentlichung im Bundesanzeiger unter www.bundesanzeiger.de zu entnehmen.</beschreibung>
+ <versionXOEVProfil>1.7.2</versionXOEVProfil>
+ <versionXOEVHandbuch>2.3.1</versionXOEVHandbuch>
+ <versionXGenerator>3.0.1</versionXGenerator>
+ <versionModellierungswerkzeug>19.0</versionModellierungswerkzeug>
+ <nameModellierungswerkzeug>MagicDraw</nameModellierungswerkzeug>
+ </versionStandard>
+ <title>Aussonderung durchführen</title>
+ </xs:appinfo>
+ </xs:annotation>
+ <xs:include schemaLocation="xdomea-Baukasten.xsd"/>
+ <xs:include schemaLocation="xdomea-Typen-AussonderungDurchfuehren.xsd"/>
+ <xs:element name="Aussonderung.Anbieteverzeichnis.0501">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt den Export von Metadaten zu Schriftgutobjekten, die dem zuständigen Archiv angeboten werden sollen.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf"
+ type="xdomea:NkNichtFVDatenEinEmpfaengerMitEmpfangsbestaetigungType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Anbieteverzeichnis-Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Anschreiben"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:DokumentType">
+ <xs:annotation>
+ <xs:documentation>Ein Dokument, in dem allgemeine Informationen zu den anzubietenden Schriftgutobjekten an das Archiv mitgegeben werden. Hier können auch Formblätter (z.B. Vorblatt zur Abgabe) mitgegeben werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Schriftgutobjekt" maxOccurs="unbounded">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Es werden im Rahmen des Versendens eines Anbieteverzeichnisses keine Primärdokumente übergeben. Die MetadatenAussonderung müssen zwingend übergeben werden.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Ein Schriftgutobjekt (Akte, Vorgang oder Dokument) zu einem Anbieteverzeichnis.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:choice>
+ <xs:element name="Akte" type="xdomea:AkteType">
+ <xs:annotation>
+ <xs:documentation>Eine Akte.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Vorgang" type="xdomea:VorgangType">
+ <xs:annotation>
+ <xs:documentation>Ein Vorgang.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Dokument" type="xdomea:DokumentType">
+ <xs:annotation>
+ <xs:documentation>Ein Dokument.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:choice>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Aktenplan" minOccurs="0" type="xdomea:AktenplanType">
+ <xs:annotation>
+ <xs:documentation>Der Aktenplan bildet ein aufgabenbezogenes mehrstufiges Ordnungssystem mit hierarchischer Gliederung für das Bilden und Kennzeichnen von Akten und Vorgängen sowie das Zuordnen von Dokumenten. Zur näheren Einordnung des Anbieteverzeichnisses kann der Aktenplan als Anlage mitgeliefert werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Aussonderung.Bewertungsverzeichnis.0502">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt den Export von Metadaten zu Schriftgutobjekten, die vom zuständigen Archiv zu einer Bewertung ausgewählt wurden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf"
+ type="xdomea:NkNichtFVDatenEinEmpfaengerMitEmpfangsbestaetigungType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Bewertungsverzeichnis-Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="BewertetesObjekt"
+ maxOccurs="unbounded"
+ type="xdomea:RueckgabeparameterAnbietungType">
+ <xs:annotation>
+ <xs:documentation>Die Information zu einem Schriftgutobjekt über die durch das Archiv erfolgte Bewertung im Anbieteverzeichnis.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Aussonderung.Aussonderung.0503">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt den Export von Schriftgutobjekten mit dem Ziel der Übergabe an das zuständige Archiv.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkAussonderungType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Aussonderungs-Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Anschreiben"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:DokumentType">
+ <xs:annotation>
+ <xs:documentation>Ein Dokument, in dem allgemeine Informationen zu den auszusondernden Schriftgutobjekten an das Archiv mitgegeben werden können. Hier können auch Formblätter (z.B. "Vorblatt zur Abgabe" gemäß Registraturrichtlinie) mitgegeben werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Schriftgutobjekt" maxOccurs="unbounded">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Die Primärdokumente und MetadatenAussonderung müssen zwingend im Zuge einer Aussonderung übergeben werden.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Ein Schriftgutobjekt (Akte, Vorgang oder Dokument) zu einer Aussonderung.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:choice>
+ <xs:element name="Akte" type="xdomea:AkteType">
+ <xs:annotation>
+ <xs:documentation>Eine Akte.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Vorgang" type="xdomea:VorgangType">
+ <xs:annotation>
+ <xs:documentation>Ein Vorgang.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Dokument" type="xdomea:DokumentType">
+ <xs:annotation>
+ <xs:documentation>Ein Dokument.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:choice>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Aktenplan" minOccurs="0" type="xdomea:AktenplanType">
+ <xs:annotation>
+ <xs:documentation>Der Aktenplan zu einer Aussonderung enthält ein aufgabenbezogenes mehrstufiges Ordnungssystem mit hierarchischer Gliederung für das Bilden und Kennzeichnen von Akten und Vorgängen sowie das Zuordnen von Dokumenten.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Aussonderung.AnbietungEmpfangBestaetigen.0504">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt den erfolgreichen Empfang des Anbietverzeichnisses.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkBasisType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Empfangsbestätigung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Aussonderung.BewertungEmpfangBestaetigen.0505">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt den erfolgreichen Empfang des Bewertungsverzeichnisses.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkBasisType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Empfangsbestätigung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Aussonderung.AussonderungImportBestaetigen.0506">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die erfolgreiche oder nicht erfolgreiche Übernahme der Aussonderung.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkBasisType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Importnachricht zu einer Aussonderung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="AusgesondertesSGO"
+ maxOccurs="unbounded"
+ type="xdomea:ErfolgOderMisserfolgAussonderungType">
+ <xs:annotation>
+ <xs:documentation>Die Information zum erfolgreichen oder nicht erfolgreichen Import eines Schriftgutobjekts zur Aussonderung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Aussonderung.AussonderungEmpfangBestaetigen.0507">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt den erfolgreichen Empfang der Aussonderung.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkBasisType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Empfangsbestätigung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Aussonderung.AktenplanZurBewertung.0511">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt den Export eines Aktenplans zur Bewertung an ein Archiv nach Anfrage durch das Archiv.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf"
+ type="xdomea:NkNichtFVDatenWeitereEmpfaengerMitEmpfangsbestaetigungType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Aktenplan-Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Aktenplan" type="xdomea:AktenplanBewertungskatalogType">
+ <xs:annotation>
+ <xs:documentation>Der für die Bewertung zu übergebende Aktenplan enthält ein aufgabenbezogenes mehrstufiges Ordnungssystem mit hierarchischer Gliederung für das Bilden und Kennzeichnen von Akten und Vorgängen sowie das Zuordnen von Dokumenten.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Aussonderung.AktenplanZurBewertungEmpfangBestaetigen.0512">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt den erfolgreichen Empfang des Aktenplans zur Bewertung.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkBasisType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Empfangsbestätigung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Aussonderung.Bewertungskatalog.0513">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt den Export eines archivisch bewerteten Aktenplans.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf"
+ type="xdomea:NkNichtFVDatenWeitereEmpfaengerMitEmpfangsbestaetigungType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Bewertungskatalog-Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="BewerteteAktenplaneinheit"
+ maxOccurs="unbounded"
+ type="xdomea:AktenplaneinheitAktenplanBewertungskatalogType">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Voraussetzung für die Implementierung ist, dass das DMS / VBS die UUID, die es jeder Aktenplaneinheit in den Nachrichten zugeordnet hat, auch im System hinterlegt hat.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die bewertete Einheit eines Aktenplans. Eine Aktenplanheit entspricht z.B. einer Hauptgruppe, Obergruppe, Gruppe, Untergruppe oder Betreffseinheit.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Aussonderung.BewertungskatalogImportBestaetigen.0514">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die erfolgreiche oder nicht erfolgreiche Übernahme des Bewertungskataloges.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkBasisType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Importnachricht zu einem Bewertungskatalog.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="BewerteteAktenplaneinheit"
+ maxOccurs="unbounded"
+ type="xdomea:ErfolgOderMisserfolgBewertungskatalogType">
+ <xs:annotation>
+ <xs:documentation>Die Information über den erfolgreichen oder nicht erfolgreichen Import des Wertes in "Aussonderungsart" oder "AussonderungsartKonfigurierbar" zu der jeweiligen Aktenplaneinheit.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Aussonderung.BewerteterAktenplanEmpfangBestaetigen.0515">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt den erfolgreichen Empfang des bewerteten Aktenplans.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkBasisType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Empfangsbestätigung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+</xs:schema>
diff --git a/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-DMS.xsd b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-DMS.xsd
new file mode 100644
index 0000000000000000000000000000000000000000..26526bcce64eb9f0cc087cb8f50ac048bc0b11d0
--- /dev/null
+++ b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-DMS.xsd
@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+ xmlns:xdomea="urn:xoev-de:xdomea:schema:3.0.0"
+ targetNamespace="urn:xoev-de:xdomea:schema:3.0.0"
+ version="3.0.0"
+ elementFormDefault="qualified"
+ attributeFormDefault="unqualified">
+ <xs:annotation>
+ <xs:appinfo>
+ <standard>
+ <nameLang>xdomea - XÖV-Standard für den IT-gestützten Austausch und die IT-gestützte Aussonderung behördlichen Schriftgutes</nameLang>
+ <nameKurz>xdomea</nameKurz>
+ <nameTechnisch>xdomea</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:kosit:standard:xdomea</kennung>
+ <beschreibung>xdomea ist der vom IT-Planungsrat verabschiedete verbindliche Standard für den Austausch von Akten, Vorgängen und Dokumenten im Kontext der Übermittlung, der Abgabe sowie der Aussonderung von Schriftgutobjekten (www.it-planungsrat.de, Beschluss 2017/39). Weiterhin kann xdomea für den Austausch zwischen Fachverfahren und DMS/VBS sowie für die Zwischenarchivierung genutzt werden.
+
+Um diese Anwendungsszenarien bestmöglich zu unterstützen, ist xdomea gemäß des XÖV-Rahmenwerkes nach dem Baukastenprinzip aufgebaut und bietet einzelne Nachrichten(gruppen) für die jeweiligen Prozesse an.
+
+Der Standard xdomea wird von der gleichnamigen Arbeitsgruppe des IT-Planungsrates weiterentwickelt und gepflegt. Der Betrieb des Standards erfolgt durch die Koordinierungsstelle für IT-Standards (KoSIT).
+</beschreibung>
+ </standard>
+ <versionStandard>
+ <version>3.0.0</version>
+ <beschreibung>Die Version 3.0.0 ist durch den IT-Planungsrat beschlossen. Details zum Beschluss sowie zu den Fristen der Umsetzung sind der Veröffentlichung im Bundesanzeiger unter www.bundesanzeiger.de zu entnehmen.</beschreibung>
+ <versionXOEVProfil>1.7.2</versionXOEVProfil>
+ <versionXOEVHandbuch>2.3.1</versionXOEVHandbuch>
+ <versionXGenerator>3.0.1</versionXGenerator>
+ <versionModellierungswerkzeug>19.0</versionModellierungswerkzeug>
+ <nameModellierungswerkzeug>MagicDraw</nameModellierungswerkzeug>
+ </versionStandard>
+ </xs:appinfo>
+ </xs:annotation>
+ <xs:include schemaLocation="xdomea-Nachrichten-AbgabeDurchfuehren.xsd"/>
+ <xs:include schemaLocation="xdomea-Nachrichten-AktenplanAustauschen.xsd"/>
+ <xs:include schemaLocation="xdomea-Nachrichten-AussonderungDurchfuehren.xsd"/>
+ <xs:include schemaLocation="xdomea-Nachrichten-InformationAustauschen.xsd"/>
+</xs:schema>
diff --git a/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-Fachverfahren.xsd b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-Fachverfahren.xsd
new file mode 100644
index 0000000000000000000000000000000000000000..0f79de371787645c740f1f1ebb6e776fff4eb057
--- /dev/null
+++ b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-Fachverfahren.xsd
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+ xmlns:xdomea="urn:xoev-de:xdomea:schema:3.0.0"
+ targetNamespace="urn:xoev-de:xdomea:schema:3.0.0"
+ version="3.0.0"
+ elementFormDefault="qualified"
+ attributeFormDefault="unqualified">
+ <xs:annotation>
+ <xs:appinfo>
+ <standard>
+ <nameLang>xdomea - XÖV-Standard für den IT-gestützten Austausch und die IT-gestützte Aussonderung behördlichen Schriftgutes</nameLang>
+ <nameKurz>xdomea</nameKurz>
+ <nameTechnisch>xdomea</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:kosit:standard:xdomea</kennung>
+ <beschreibung>xdomea ist der vom IT-Planungsrat verabschiedete verbindliche Standard für den Austausch von Akten, Vorgängen und Dokumenten im Kontext der Übermittlung, der Abgabe sowie der Aussonderung von Schriftgutobjekten (www.it-planungsrat.de, Beschluss 2017/39). Weiterhin kann xdomea für den Austausch zwischen Fachverfahren und DMS/VBS sowie für die Zwischenarchivierung genutzt werden.
+
+Um diese Anwendungsszenarien bestmöglich zu unterstützen, ist xdomea gemäß des XÖV-Rahmenwerkes nach dem Baukastenprinzip aufgebaut und bietet einzelne Nachrichten(gruppen) für die jeweiligen Prozesse an.
+
+Der Standard xdomea wird von der gleichnamigen Arbeitsgruppe des IT-Planungsrates weiterentwickelt und gepflegt. Der Betrieb des Standards erfolgt durch die Koordinierungsstelle für IT-Standards (KoSIT).
+</beschreibung>
+ </standard>
+ <versionStandard>
+ <version>3.0.0</version>
+ <beschreibung>Die Version 3.0.0 ist durch den IT-Planungsrat beschlossen. Details zum Beschluss sowie zu den Fristen der Umsetzung sind der Veröffentlichung im Bundesanzeiger unter www.bundesanzeiger.de zu entnehmen.</beschreibung>
+ <versionXOEVProfil>1.7.2</versionXOEVProfil>
+ <versionXOEVHandbuch>2.3.1</versionXOEVHandbuch>
+ <versionXGenerator>3.0.1</versionXGenerator>
+ <versionModellierungswerkzeug>19.0</versionModellierungswerkzeug>
+ <nameModellierungswerkzeug>MagicDraw</nameModellierungswerkzeug>
+ </versionStandard>
+ </xs:appinfo>
+ </xs:annotation>
+ <xs:include schemaLocation="xdomea-Nachrichten-FachverfahrensdatenAustauschen.xsd"/>
+</xs:schema>
diff --git a/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-FachverfahrensdatenAustauschen.xsd b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-FachverfahrensdatenAustauschen.xsd
new file mode 100644
index 0000000000000000000000000000000000000000..b10277c5a5d5154b82aec91e604e15b8cfd18aff
--- /dev/null
+++ b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-FachverfahrensdatenAustauschen.xsd
@@ -0,0 +1,692 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+ xmlns:xdomea="urn:xoev-de:xdomea:schema:3.0.0"
+ targetNamespace="urn:xoev-de:xdomea:schema:3.0.0"
+ version="3.0.0"
+ elementFormDefault="qualified"
+ attributeFormDefault="unqualified">
+ <xs:annotation>
+ <xs:appinfo>
+ <standard>
+ <nameLang>xdomea - XÖV-Standard für den IT-gestützten Austausch und die IT-gestützte Aussonderung behördlichen Schriftgutes</nameLang>
+ <nameKurz>xdomea</nameKurz>
+ <nameTechnisch>xdomea</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:kosit:standard:xdomea</kennung>
+ <beschreibung>xdomea ist der vom IT-Planungsrat verabschiedete verbindliche Standard für den Austausch von Akten, Vorgängen und Dokumenten im Kontext der Übermittlung, der Abgabe sowie der Aussonderung von Schriftgutobjekten (www.it-planungsrat.de, Beschluss 2017/39). Weiterhin kann xdomea für den Austausch zwischen Fachverfahren und DMS/VBS sowie für die Zwischenarchivierung genutzt werden.
+
+Um diese Anwendungsszenarien bestmöglich zu unterstützen, ist xdomea gemäß des XÖV-Rahmenwerkes nach dem Baukastenprinzip aufgebaut und bietet einzelne Nachrichten(gruppen) für die jeweiligen Prozesse an.
+
+Der Standard xdomea wird von der gleichnamigen Arbeitsgruppe des IT-Planungsrates weiterentwickelt und gepflegt. Der Betrieb des Standards erfolgt durch die Koordinierungsstelle für IT-Standards (KoSIT).
+</beschreibung>
+ </standard>
+ <versionStandard>
+ <version>3.0.0</version>
+ <beschreibung>Die Version 3.0.0 ist durch den IT-Planungsrat beschlossen. Details zum Beschluss sowie zu den Fristen der Umsetzung sind der Veröffentlichung im Bundesanzeiger unter www.bundesanzeiger.de zu entnehmen.</beschreibung>
+ <versionXOEVProfil>1.7.2</versionXOEVProfil>
+ <versionXOEVHandbuch>2.3.1</versionXOEVHandbuch>
+ <versionXGenerator>3.0.1</versionXGenerator>
+ <versionModellierungswerkzeug>19.0</versionModellierungswerkzeug>
+ <nameModellierungswerkzeug>MagicDraw</nameModellierungswerkzeug>
+ </versionStandard>
+ <title>Fachverfahrensdaten austauschen</title>
+ </xs:appinfo>
+ </xs:annotation>
+ <xs:include schemaLocation="xdomea-Baukasten.xsd"/>
+ <xs:include schemaLocation="xdomea-Typen-FachverfahrensdatenAustauschen.xsd"/>
+ <xs:element name="FVDaten.DokumentAktualisieren.0601">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Für die Aktualisierung eines Dokuments ist die in den Eingabeparametern übergebene UUID relevant. Die UUID im Element Identifikation des Typs DokumentType ist hierfür irrelevant.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die Nachricht beschreibt die Aktualisierung eines bereits im DMS vorhandenen Dokuments. Als Rückgabeparameter sollte die Bestätigung des erfolgreichen Aktualisierens mit der ID des Dokuments gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="DokumentZumAktualisieren"
+ maxOccurs="unbounded"
+ type="xdomea:DokumentZumAktualisierenType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zu dem Dokument, das im DMS aktualisiert werden soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.SGOAnsehen.0602">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die Übergabe eines Schriftgutobjekts, das im DMS angezeigt werden soll. Als Rückgabeparameter sollte die Bestätigung des erfolgreichen Öffnens des Schriftgutobjekts zur Ansicht mit seiner ID gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SchriftgutobjektZumAnsehen"
+ type="xdomea:SchriftgutobjektZumAnsehenOderBearbeitenType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zu dem Schriftgutobjekt, das angesehen werden soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.SGOBearbeiten.0603">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die Übergabe eines Schriftgutobjekts, das zur Bearbeitung geöffnet werden soll. Als Rückgabeparameter sollte die Bestätigung des erfolgreichen Öffnens des Schriftgutobjekts zur Bearbeitung mit seiner ID gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SchriftgutobjektZumBearbeiten"
+ type="xdomea:SchriftgutobjektZumAnsehenOderBearbeitenType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zu dem Schriftgutobjekt, das bearbeitet werden soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.SGOErstellen.0604">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die Übergabe von neuen Schriftgutobjekten zur Erstellung im DMS. Als Rückgabeparameter sollte jeweils die Bestätigung des erfolgreichen Erstellens des Schriftgutobjekts mit seiner ID im DMS gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SchriftgutobjektZumErstellen"
+ maxOccurs="unbounded"
+ type="xdomea:SchriftgutobjektZumErstellenType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zu dem neuen Schriftgutobjekt, das erstellt werden soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.SGOAblegen.0605">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Als Ergebnis wird immer ein neues Dokument mit einer neuen UUID im DMS angelegt. Daher ist die UUID im Element Identifikation im Typ DokumentType hier zu ignorieren.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die Nachricht beschreibt die Übergabe von neuen Schriftgutobjekten an das DMS zur Ablage. Als Rückgabeparameter sollte jeweils die Bestätigung des erfolgreichen Ablegens des Schriftgutobjekts mit seiner ID gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SchriftgutobjektZumAblegen"
+ maxOccurs="unbounded"
+ type="xdomea:SchriftgutobjektZumAblegenType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zu dem Schriftgutobjekt, das abgelegt werden soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.SGODrucken.0606">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die Übergabe von zu druckenden Schriftgutobjekten. Als Rückgabeparameter sollte jeweils die Bestätigung des erfolgreichen Druckens des Schriftgutobjekts mit seiner ID gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SchriftgutobjektZumDrucken"
+ maxOccurs="unbounded"
+ type="xdomea:SchriftgutobjektZumDruckenType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zum zu druckenden Schriftgutobjekt.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.ProtokolleintragErstellen.0607">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht ermöglicht die Erstellung eines Protokolleintrags zu einem Objekt im DMS. Als Rückgabeparameter sollte jeweils die Bestätigung des erfolgreichen Erstellens des Protokolleintrags mit der dazugehörigen Schriftgutobjekt-ID gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="ProtokolleintragZumErstellen"
+ maxOccurs="unbounded"
+ type="xdomea:ProtokolleintragZumErstellenType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zu dem zu erstellenden Protokolleintrag.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.SGOSuchen.0608">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die Übergabe von Parametern zur Suche nach Schriftgutobjekten im DMS. Als Rückgabeparameter soll die Liste der Schriftgutobjekte mit ihren IDs gesendet werden, auf die die Suchparameter zutreffen.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SchriftgutobjektZumSuchen"
+ type="xdomea:SchriftgutobjektZumSuchenType">
+ <xs:annotation>
+ <xs:documentation>Die Parameter zu einer Suche nach Schriftgutobjekten.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.MetadatenAnlegen.0609">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht ermöglicht das Anlegen eines Metadatums zu einem Objekt im DMS. Als Rückgabeparameter sollte die Bestätigung des erfolgreichen Anlegens der Metadaten mit den entsprechenden Namen und Werten sowie der ID und evtl. der Versionsnummer (nur für Dokumente) des Schriftgutobjekts gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="MetadatenZumAnlegen"
+ maxOccurs="unbounded"
+ type="xdomea:MetadatenZumBearbeitenType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zu dem neuen Metadatum.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.MetadatenAktualisieren.0610">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die Aktualisierung eines bereits existierenden Metadatums. Als Rückgabeparameter sollte die Bestätigung des erfolgreichen Aktualisierens von Metadaten mit entsprechendem Namen und Wert sowie der ID und evtl. der Versionsnummer (nur für Dokumente) des Schriftgutobjekts gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="MetadatenZumAktualisieren"
+ maxOccurs="unbounded"
+ type="xdomea:MetadatenZumBearbeitenType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zu dem zu aktualisierenden Metadatum.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.MetadatenAnsehen.0611">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht ermöglicht das Auslesen des Wertes zu einem Metadatum. Als Rückgabeparameter sollten die Namen und Werte der angeforderten Metadaten gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="MetadatenZumAnsehen"
+ maxOccurs="unbounded"
+ type="xdomea:MetadatenZumBearbeitenType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zu dem Metadatum, das angesehen werden soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.MetadatenLoeschen.0612">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die Übergabe eines zu löschenden Metadatums. Als Rückgabeparameter sollte die Bestätigung des erfolgreichen Löschens der Metadaten mit den entsprechenden Namen und Werten sowie der ID und evtl. der Versionsnummer (nur für Dokumente) des Schriftgutobjekts gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="MetadatenZumLoeschen"
+ maxOccurs="unbounded"
+ type="xdomea:MetadatenZumBearbeitenType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zu dem zu löschenden Metadatum.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.SGOLoeschenMarkieren.0613">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die Übergabe von Schriftgutobjekten, die im DMS zum Löschen markiert werden sollen (4-Augen-Löschen). Als Rückgabeparameter sollte jeweils die Bestätigung des erfolgreichen Markierens des Schriftgutobjekts zur Löschung mit seiner ID gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SchriftgutobjektZumLoeschenMarkieren"
+ maxOccurs="unbounded"
+ type="xdomea:SchriftgutobjektZumLoeschenType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zu dem Schriftgutobjekt, das zum Löschen markiert werden soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.SGOLoeschmarkierungAufheben.0614">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die Übergabe von Schriftgutobjekten, für die die Löschmarkierung im DMS aufgehoben werden soll (4-Augen-Löschen). Als Rückgabeparameter sollte jeweils die Bestätigung des erfolgreichen Aufhebens der Löschmarkierung des Schriftgutobjekts mit seiner ID gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SchriftgutobjektZumLoeschmarkierungAufheben"
+ maxOccurs="unbounded"
+ type="xdomea:SchriftgutobjektZumLoeschenType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zu dem Schriftgutobjekt, dessen Löschmarkierung aufgehoben werden soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.SGOEndgueltigLoeschen.0615">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die Übergabe von Schriftgutobjekten zur endgültigen Löschung im DMS. Als Rückgabeparameter sollte jeweils die Bestätigung des erfolgreichen endgültigen Löschens des Schriftgutobjekts mit seiner ID gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SchriftgutobjektZumEndgueltigLoeschen"
+ maxOccurs="unbounded"
+ type="xdomea:SchriftgutobjektZumLoeschenType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zu dem Schriftgutobjekt, das endgültig gelöscht werden soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.SGOLoeschstatusAbfragen.0616">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die Übergabe von Schriftgutobjekten, zu denen der Löschstatus im DMS abgefragt werden soll. Als Rückgabeparameter sollte jeweils der Löschstatus des Schriftgutobjekts mit seiner ID gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SchriftgutobjektZumLoeschstatusAbfragen"
+ maxOccurs="unbounded"
+ type="xdomea:SchriftgutobjektZumLoeschstatusAbfragenType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zu dem Schriftgutobjekt, dessen Löschstatus abgefragt werden soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.SGOUngueltigKennzeichnen.0617">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die Übergabe von Schriftgutobjekten, die im DMS als ungültig markiert werden sollen. Als Rückgabeparameter sollte jeweils die Bestätigung des erfolgreichen Ungültig-Markierens des Schriftgutobjekts mit seiner ID gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SchriftgutobjektZumUngueltigKennzeichnen"
+ maxOccurs="unbounded"
+ type="xdomea:SchriftgutobjektZumLoeschenType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zu dem Schriftgutobjekt, das als ungültig gekennzeichnet werden soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.DatensatzLoeschen.0618">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die Übergabe eines im Fachverfahren vollständig gelöschten Datensatzes, um alle zugehörigen Objekte im DMS ebenfalls zu löschen. Als Rückgabeparameter sollte die Löschbestätigung zum Datensatz im DMS mit der Datensatz-ID im Fachverfahren gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="DatensatzZumLoeschen"
+ maxOccurs="unbounded"
+ type="xdomea:DatensatzZumLoeschenType">
+ <xs:annotation>
+ <xs:documentation>Die Information zu dem im Fachverfahren gelöschten Datensatz, zu dem auch alle vorhandenen Objekte im DMS gelöscht werden sollen.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.BenachrichtigungAbrufen.0619">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die Abfrage eventuell bereitgestellter Daten (Benachrichtigungen) durch ein Fachverfahren. Die Bereitstellung von Daten (bspw. neuer Dokumente) erfolgt durch ein DMS, das die Daten zum Abruf für ein Fachverfahren zur Verfügung stellt. Als Rückgabeparameter sollten die im System vorliegenden Benachrichtigungen gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.VertretungAktivierenOderDeaktivieren.0620">
+ <xs:annotation>
+ <xs:documentation>Diese Nachricht beschreibt die Übergabe von Informationen zum Aktivieren oder zum Deaktivieren einer Vertretung im DMS. Als Rückgabeparameter sollte die Liste von Vertretern (Benutzer/Rolle) mit ihrem Namen und ihrem Aktivierungsstatus gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="VertretungZumAktivierenOderDeaktivieren"
+ maxOccurs="unbounded"
+ type="xdomea:VertretungZumAktivierenOderDeaktivierenType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zur Aktivierung oder zur Deaktivierung einer Vertretung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.VertretungsstatusAbfragen.0621">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die Abfrage zu den verfügbaren bzw. aktiven Vertretungen eines Benutzers oder einer Rolle im DMS. Als Rückgabeparameter sollte die Liste von Vertretern (Benutzer/Rolle) mit ihrem Namen und ihrem Aktivierungsstatus gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="VertretungsstatusZumAbfragen"
+ maxOccurs="unbounded"
+ type="xdomea:VertretungsstatusZumAbfragenType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zu dem Benutzer oder der Rolle, für den/die die Statusabfrage durchgeführt werden soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.ZustaendigkeitAendern.0622">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die Übergabe von Informationen bei dem Zuständigkeitswechsel eines Schriftgutobjekts im Fachverfahren, z.B. bei Widerspruchsverfahren, mit dem Ziel, die Zuständigkeit im DMS anzupassen. Als Rückgabeparameter sollte die Bestätigung des erfolgreichen Aktualisierens der Metadaten des Schriftgutobjekts mit ID des Schriftgutobjekts, alte und neue zuständige Stelle, alte und neue Aktenplaneinheit, alte und neue Akte sowie weitere geänderte Metadaten gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="ZustaendigkeitZumAendern"
+ maxOccurs="unbounded"
+ type="xdomea:ZustaendigkeitZumAendernType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zu der bisherigen und neuen Zuständigkeit des Schriftgutobjekts.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.GesamtprotokollAblegen.0623">
+ <xs:annotation>
+ <xs:documentation>Diese Nachricht ermöglicht es, alle aktenrelevanten Bearbeitungs- und Protokollinformationen aus einem Fachverfahren in einem DMS abzulegen. Die Nachricht ist immer mit der zdA-Verfügung zu übermitteln. Sie kann zudem manuell aus dem Fachverfahren angestoßen werden. Damit wird sichergestellt, dass im DMS die für die Nachvollziehbarkeit erforderliche vollständige elektronische Akte geführt wird. Als Rückgabeparameter sollte die Bestätigung des erfolgreichen Ablegens mit der dazugehörigen Schriftgutobjekt-ID gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="GesamtprotokollZumAblegen"
+ maxOccurs="unbounded"
+ type="xdomea:GesamtprotokollZumAblegenType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zum Gesamtprotokoll, das an das DMS übermittelt werden soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.SGOZDAVerfuegen.0624">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die Übergabe von Schriftgutobjekten, die zu den Akten verfügt werden sollen. Als Rückgabeparameter sollten jeweils die Bestätigung des erfolgreichen zdA-Verfügens des Schriftgutobjekts mit seiner ID gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SchriftgutobjektZumZDAVerfuegen"
+ maxOccurs="unbounded"
+ type="xdomea:SchriftgutobjektZumZDAVerfuegenType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zu dem Schriftgutobjekt, das zdA-verfügt werden soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.SystemstatusAbfragen.0625">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die Abfrage zum Systemstatus. Als Rückgabeparameter sollte die Liste von Systemstatus mit der SystemstatusID und dem dazugehörigen aktuellen Status gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SystemstatusZumAbfragen"
+ maxOccurs="unbounded"
+ type="xdomea:SystemstatusZumAbfragenType">
+ <xs:annotation>
+ <xs:documentation>Die angeforderte Information zum Systemstatus.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.KonfigurationsparameterErstellen.0626">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt das Anlegen eines neuen Konfigurationsparameters. Als Rückgabeparameter sollte die Bestätigung des erfolgreichen Anlegens eines neuen Konfigurationsparameters mit entsprechendem Namen und Wert gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="KonfigurationsparameterZumErstellen"
+ type="xdomea:KonfigurationsparameterZumErstellenType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zu dem neuen Konfigurationsparameter sowie zu dessen Ersteller.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.KonfigurationsparameterAktualisieren.0627">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die Übergabe eines bereits existierenden Konfigurationsparameters zur Aktualisierung. Als Rückgabeparameter sollte die Bestätigung des erfolgreichen Aktualisierens der Konfigurationsparameter mit entsprechendem Namen und Wert gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="KonfigurationsparameterZumAktualisieren"
+ maxOccurs="unbounded"
+ type="xdomea:FeldType">
+ <xs:annotation>
+ <xs:documentation>Die Information zum zu aktualisierenden Konfigurationsparameter.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.KonfigurationsparameterAbrufen.0628">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt den Abruf eines Konfigurationsparameters. Als Rückgabeparameter sollten der Name (immer) sowie soweit vorhanden der Datentyp, die Beschreibung und der Wert des Konfigurationsparameters gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="KonfigurationsparameterZumAbrufen"
+ maxOccurs="unbounded"
+ type="xdomea:KonfigurationsparameterZumAbrufenType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zu dem abzurufenden Konfigurationsparameter.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.EmpfangBestaetigen.0629">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt den erfolgreichen Empfang einer Fachverfahrensdaten-Nachricht.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Empfangsbestätigung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.ImportBestaetigen.0630">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die erfolgreiche oder nicht erfolgreiche Übernahme von Daten.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkRueckmeldungFVDatenImportType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="ErfolgOderMisserfolg" type="xdomea:ErfolgOderMisserfolgDMSType">
+ <xs:annotation>
+ <xs:documentation>Die Information über den erfolgreichen oder nicht erfolgreichen Import von Daten.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.PrimaerdokumentExportieren.0631">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt den Export von Primärdokumenten zu einem Schriftgutobjekt (Dokument) aus einem DMS in ein Fachverfahren. Als Rückgabeparameter sollte der Ablageort der Primärdokumente gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="DokumentZumExportieren" type="xdomea:DokumentZumExportierenType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zu dem Dokument, dessen Primärdokumente exportiert werden sollen.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="FVDaten.SGOZDAAufheben.0632">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt das Aufheben der zdA-Verfügung eines Schriftgutobjekts. Als Rückgabeparameter sollte die Bestätigung des erfolgreichen Wiederauflebens mit der ID des Schriftgutobjekts gesendet werden.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SGOZumZDAAufheben"
+ maxOccurs="unbounded"
+ type="xdomea:SchriftgutobjektZumZDAAufhebenType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zu dem Schriftgutobjekt, dessen zdA-Verfügung im DMS aufgehoben werden soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+</xs:schema>
diff --git a/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-GeschaeftsgangDurchfuehren.xsd b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-GeschaeftsgangDurchfuehren.xsd
new file mode 100644
index 0000000000000000000000000000000000000000..fcdace56d29aab05ee84d2c87f37bd63aac43b5f
--- /dev/null
+++ b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-GeschaeftsgangDurchfuehren.xsd
@@ -0,0 +1,138 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+ xmlns:xdomea="urn:xoev-de:xdomea:schema:3.0.0"
+ targetNamespace="urn:xoev-de:xdomea:schema:3.0.0"
+ version="3.0.0"
+ elementFormDefault="qualified"
+ attributeFormDefault="unqualified">
+ <xs:annotation>
+ <xs:appinfo>
+ <standard>
+ <nameLang>xdomea - XÖV-Standard für den IT-gestützten Austausch und die IT-gestützte Aussonderung behördlichen Schriftgutes</nameLang>
+ <nameKurz>xdomea</nameKurz>
+ <nameTechnisch>xdomea</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:kosit:standard:xdomea</kennung>
+ <beschreibung>xdomea ist der vom IT-Planungsrat verabschiedete verbindliche Standard für den Austausch von Akten, Vorgängen und Dokumenten im Kontext der Übermittlung, der Abgabe sowie der Aussonderung von Schriftgutobjekten (www.it-planungsrat.de, Beschluss 2017/39). Weiterhin kann xdomea für den Austausch zwischen Fachverfahren und DMS/VBS sowie für die Zwischenarchivierung genutzt werden.
+
+Um diese Anwendungsszenarien bestmöglich zu unterstützen, ist xdomea gemäß des XÖV-Rahmenwerkes nach dem Baukastenprinzip aufgebaut und bietet einzelne Nachrichten(gruppen) für die jeweiligen Prozesse an.
+
+Der Standard xdomea wird von der gleichnamigen Arbeitsgruppe des IT-Planungsrates weiterentwickelt und gepflegt. Der Betrieb des Standards erfolgt durch die Koordinierungsstelle für IT-Standards (KoSIT).
+</beschreibung>
+ </standard>
+ <versionStandard>
+ <version>3.0.0</version>
+ <beschreibung>Die Version 3.0.0 ist durch den IT-Planungsrat beschlossen. Details zum Beschluss sowie zu den Fristen der Umsetzung sind der Veröffentlichung im Bundesanzeiger unter www.bundesanzeiger.de zu entnehmen.</beschreibung>
+ <versionXOEVProfil>1.7.2</versionXOEVProfil>
+ <versionXOEVHandbuch>2.3.1</versionXOEVHandbuch>
+ <versionXGenerator>3.0.1</versionXGenerator>
+ <versionModellierungswerkzeug>19.0</versionModellierungswerkzeug>
+ <nameModellierungswerkzeug>MagicDraw</nameModellierungswerkzeug>
+ </versionStandard>
+ <title>Geschäftsgang durchführen</title>
+ </xs:appinfo>
+ </xs:annotation>
+ <xs:include schemaLocation="xdomea-Baukasten.xsd"/>
+ <xs:include schemaLocation="xdomea-Typen-GeschaeftsgangDurchfuehren.xsd"/>
+ <xs:element name="Geschaeftsgang.Geschaeftsgang.0201">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Nach Versand der Nachricht werden die im Hauptobjekt enthaltenen Dokumente gesperrt. Ausnahme bildet hier der Fall, dass die letzte Bearbeitung nicht durch den Initiator erfolgt: in diesem Fall werden die Dokumente im Hauptobjekt nicht gesperrt.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die Nachricht beschreibt den Export von Schriftgutobjekten - Hauptobjekt (Dokumente) und Anlagen (Akte, Vorgang, Dokument) - zur Bearbeitung durch externe Bearbeitungsstationen in einem anderen System.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkGeschaeftsgangType">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Der Empfänger ist eine Bearbeitungsstation im externen Geschäftsgang.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Geschäftsgangs-Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Anschreiben" minOccurs="0" type="xdomea:DokumentType">
+ <xs:annotation>
+ <xs:documentation>Ein Dokument, das dem Empfänger zur Erläuterung des externen Geschäftsgangs mitgegeben wird.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Hauptobjekt" type="xdomea:HauptobjektType">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Akten oder Vorgänge sind als Element im Hauptobjekt nicht erlaubt.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Ein Container für die Dokumente, auf die sich die Beteiligungsschritte im externen Geschäftsgang beziehen.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="ExternerGeschaeftsgang" type="xdomea:GeschaeftsgangType">
+ <xs:annotation>
+ <xs:documentation>Im externen Geschäftsgang werden die Verfügungen an externe Bearbeitungsstationen festgelegt.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Anlage" minOccurs="0" maxOccurs="unbounded">
+ <xs:annotation>
+ <xs:documentation>Ein Schriftgutobjekt (Akte, Vorgang oder Dokument), das dem Hauptobjekt als Anlage beigefügt wird.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:choice>
+ <xs:element name="Akte" type="xdomea:AkteType">
+ <xs:annotation>
+ <xs:documentation>Eine Akte.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Vorgang" type="xdomea:VorgangType">
+ <xs:annotation>
+ <xs:documentation>Ein Vorgang.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Dokument" type="xdomea:DokumentType">
+ <xs:annotation>
+ <xs:documentation>Ein Dokument.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:choice>
+ </xs:complexType>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Geschaeftsgang.EmpfangBestaetigen.0202">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt den erfolgreichen Empfang des externen Geschäftsgangs.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkRueckmeldungGeschaeftsgangType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Empfangsbestätigung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Geschaeftsgang.GeaendertenLaufwegMitteilen.0203">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die Information eines Geschäftsgang-Initiators über die Änderung des ursprünglichen Laufwegs, z.B. durch Hinzufügen oder Überspringen von Beteiligungsschritten.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkBasisType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Geschäftsgangs-Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="GeaenderterGeschaeftsgang" type="xdomea:GeschaeftsgangType">
+ <xs:annotation>
+ <xs:documentation>Der komplette geänderte Geschäftsgang.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="GeaenderterBeteiligungsschritt"
+ maxOccurs="unbounded"
+ type="xdomea:GeaenderterBeteiligungsschrittType">
+ <xs:annotation>
+ <xs:documentation>Informationen zu geänderten Beteiligungsschritten eines Geschäftsgangs.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+</xs:schema>
diff --git a/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-InformationAustauschen.xsd b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-InformationAustauschen.xsd
new file mode 100644
index 0000000000000000000000000000000000000000..cc0a4bc5164054c367c0ebfb5870b7e8754ea493
--- /dev/null
+++ b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-InformationAustauschen.xsd
@@ -0,0 +1,96 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+ xmlns:xdomea="urn:xoev-de:xdomea:schema:3.0.0"
+ targetNamespace="urn:xoev-de:xdomea:schema:3.0.0"
+ version="3.0.0"
+ elementFormDefault="qualified"
+ attributeFormDefault="unqualified">
+ <xs:annotation>
+ <xs:appinfo>
+ <standard>
+ <nameLang>xdomea - XÖV-Standard für den IT-gestützten Austausch und die IT-gestützte Aussonderung behördlichen Schriftgutes</nameLang>
+ <nameKurz>xdomea</nameKurz>
+ <nameTechnisch>xdomea</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:kosit:standard:xdomea</kennung>
+ <beschreibung>xdomea ist der vom IT-Planungsrat verabschiedete verbindliche Standard für den Austausch von Akten, Vorgängen und Dokumenten im Kontext der Übermittlung, der Abgabe sowie der Aussonderung von Schriftgutobjekten (www.it-planungsrat.de, Beschluss 2017/39). Weiterhin kann xdomea für den Austausch zwischen Fachverfahren und DMS/VBS sowie für die Zwischenarchivierung genutzt werden.
+
+Um diese Anwendungsszenarien bestmöglich zu unterstützen, ist xdomea gemäß des XÖV-Rahmenwerkes nach dem Baukastenprinzip aufgebaut und bietet einzelne Nachrichten(gruppen) für die jeweiligen Prozesse an.
+
+Der Standard xdomea wird von der gleichnamigen Arbeitsgruppe des IT-Planungsrates weiterentwickelt und gepflegt. Der Betrieb des Standards erfolgt durch die Koordinierungsstelle für IT-Standards (KoSIT).
+</beschreibung>
+ </standard>
+ <versionStandard>
+ <version>3.0.0</version>
+ <beschreibung>Die Version 3.0.0 ist durch den IT-Planungsrat beschlossen. Details zum Beschluss sowie zu den Fristen der Umsetzung sind der Veröffentlichung im Bundesanzeiger unter www.bundesanzeiger.de zu entnehmen.</beschreibung>
+ <versionXOEVProfil>1.7.2</versionXOEVProfil>
+ <versionXOEVHandbuch>2.3.1</versionXOEVHandbuch>
+ <versionXGenerator>3.0.1</versionXGenerator>
+ <versionModellierungswerkzeug>19.0</versionModellierungswerkzeug>
+ <nameModellierungswerkzeug>MagicDraw</nameModellierungswerkzeug>
+ </versionStandard>
+ <title>Information austauschen</title>
+ </xs:appinfo>
+ </xs:annotation>
+ <xs:include schemaLocation="xdomea-Baukasten.xsd"/>
+ <xs:element name="Information.Information.0101">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt den Export von Schriftgutobjekten (Akte, Vorgang, Dokument) zur Information oder Übernahme in ein anderes System.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf"
+ type="xdomea:NkNichtFVDatenWeitereEmpfaengerMitEmpfangsbestaetigungType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Informations-Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Anschreiben" minOccurs="0" type="xdomea:DokumentType">
+ <xs:annotation>
+ <xs:documentation>Ein Dokument, das dem Empfänger zur Erläuterung der Information mitgegeben wird.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Schriftgutobjekt" maxOccurs="unbounded">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Beim Zusammenstellen der Nachricht wird entschieden, welche prozess- und aktenrelevanten Metadaten zu dem Schriftgutobjekt übergeben werden.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Ein Schriftgutobjekt (Akte, Vorgang oder Dokument), das mit der Informations-Nachricht an ein anderes System gesandt wird.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:choice>
+ <xs:element name="Akte" type="xdomea:AkteType">
+ <xs:annotation>
+ <xs:documentation>Eine Akte.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Vorgang" type="xdomea:VorgangType">
+ <xs:annotation>
+ <xs:documentation>Ein Vorgang.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Dokument" type="xdomea:DokumentType">
+ <xs:annotation>
+ <xs:documentation>Ein Dokument.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:choice>
+ </xs:complexType>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Information.EmpfangBestaetigen.0102">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt den erfolgreichen Empfang der Information.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkBasisType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Empfangsbestätigung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+</xs:schema>
diff --git a/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-VBS.xsd b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-VBS.xsd
new file mode 100644
index 0000000000000000000000000000000000000000..913db2eed8c8da05b8a4e13f2054a8e658ccde20
--- /dev/null
+++ b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-VBS.xsd
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+ xmlns:xdomea="urn:xoev-de:xdomea:schema:3.0.0"
+ targetNamespace="urn:xoev-de:xdomea:schema:3.0.0"
+ version="3.0.0"
+ elementFormDefault="qualified"
+ attributeFormDefault="unqualified">
+ <xs:annotation>
+ <xs:appinfo>
+ <standard>
+ <nameLang>xdomea - XÖV-Standard für den IT-gestützten Austausch und die IT-gestützte Aussonderung behördlichen Schriftgutes</nameLang>
+ <nameKurz>xdomea</nameKurz>
+ <nameTechnisch>xdomea</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:kosit:standard:xdomea</kennung>
+ <beschreibung>xdomea ist der vom IT-Planungsrat verabschiedete verbindliche Standard für den Austausch von Akten, Vorgängen und Dokumenten im Kontext der Übermittlung, der Abgabe sowie der Aussonderung von Schriftgutobjekten (www.it-planungsrat.de, Beschluss 2017/39). Weiterhin kann xdomea für den Austausch zwischen Fachverfahren und DMS/VBS sowie für die Zwischenarchivierung genutzt werden.
+
+Um diese Anwendungsszenarien bestmöglich zu unterstützen, ist xdomea gemäß des XÖV-Rahmenwerkes nach dem Baukastenprinzip aufgebaut und bietet einzelne Nachrichten(gruppen) für die jeweiligen Prozesse an.
+
+Der Standard xdomea wird von der gleichnamigen Arbeitsgruppe des IT-Planungsrates weiterentwickelt und gepflegt. Der Betrieb des Standards erfolgt durch die Koordinierungsstelle für IT-Standards (KoSIT).
+</beschreibung>
+ </standard>
+ <versionStandard>
+ <version>3.0.0</version>
+ <beschreibung>Die Version 3.0.0 ist durch den IT-Planungsrat beschlossen. Details zum Beschluss sowie zu den Fristen der Umsetzung sind der Veröffentlichung im Bundesanzeiger unter www.bundesanzeiger.de zu entnehmen.</beschreibung>
+ <versionXOEVProfil>1.7.2</versionXOEVProfil>
+ <versionXOEVHandbuch>2.3.1</versionXOEVHandbuch>
+ <versionXGenerator>3.0.1</versionXGenerator>
+ <versionModellierungswerkzeug>19.0</versionModellierungswerkzeug>
+ <nameModellierungswerkzeug>MagicDraw</nameModellierungswerkzeug>
+ </versionStandard>
+ </xs:appinfo>
+ </xs:annotation>
+ <xs:include schemaLocation="xdomea-Nachrichten-AbgabeDurchfuehren.xsd"/>
+ <xs:include schemaLocation="xdomea-Nachrichten-AktenplanAustauschen.xsd"/>
+ <xs:include schemaLocation="xdomea-Nachrichten-AussonderungDurchfuehren.xsd"/>
+ <xs:include schemaLocation="xdomea-Nachrichten-GeschaeftsgangDurchfuehren.xsd"/>
+ <xs:include schemaLocation="xdomea-Nachrichten-InformationAustauschen.xsd"/>
+</xs:schema>
diff --git a/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-ZwischenarchivierungDurchfuehren.xsd b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-ZwischenarchivierungDurchfuehren.xsd
new file mode 100644
index 0000000000000000000000000000000000000000..37dca150e412c956ce035310d285f9ecf0aec94b
--- /dev/null
+++ b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-ZwischenarchivierungDurchfuehren.xsd
@@ -0,0 +1,315 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+ xmlns:xdomea="urn:xoev-de:xdomea:schema:3.0.0"
+ targetNamespace="urn:xoev-de:xdomea:schema:3.0.0"
+ version="3.0.0"
+ elementFormDefault="qualified"
+ attributeFormDefault="unqualified">
+ <xs:annotation>
+ <xs:appinfo>
+ <standard>
+ <nameLang>xdomea - XÖV-Standard für den IT-gestützten Austausch und die IT-gestützte Aussonderung behördlichen Schriftgutes</nameLang>
+ <nameKurz>xdomea</nameKurz>
+ <nameTechnisch>xdomea</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:kosit:standard:xdomea</kennung>
+ <beschreibung>xdomea ist der vom IT-Planungsrat verabschiedete verbindliche Standard für den Austausch von Akten, Vorgängen und Dokumenten im Kontext der Übermittlung, der Abgabe sowie der Aussonderung von Schriftgutobjekten (www.it-planungsrat.de, Beschluss 2017/39). Weiterhin kann xdomea für den Austausch zwischen Fachverfahren und DMS/VBS sowie für die Zwischenarchivierung genutzt werden.
+
+Um diese Anwendungsszenarien bestmöglich zu unterstützen, ist xdomea gemäß des XÖV-Rahmenwerkes nach dem Baukastenprinzip aufgebaut und bietet einzelne Nachrichten(gruppen) für die jeweiligen Prozesse an.
+
+Der Standard xdomea wird von der gleichnamigen Arbeitsgruppe des IT-Planungsrates weiterentwickelt und gepflegt. Der Betrieb des Standards erfolgt durch die Koordinierungsstelle für IT-Standards (KoSIT).
+</beschreibung>
+ </standard>
+ <versionStandard>
+ <version>3.0.0</version>
+ <beschreibung>Die Version 3.0.0 ist durch den IT-Planungsrat beschlossen. Details zum Beschluss sowie zu den Fristen der Umsetzung sind der Veröffentlichung im Bundesanzeiger unter www.bundesanzeiger.de zu entnehmen.</beschreibung>
+ <versionXOEVProfil>1.7.2</versionXOEVProfil>
+ <versionXOEVHandbuch>2.3.1</versionXOEVHandbuch>
+ <versionXGenerator>3.0.1</versionXGenerator>
+ <versionModellierungswerkzeug>19.0</versionModellierungswerkzeug>
+ <nameModellierungswerkzeug>MagicDraw</nameModellierungswerkzeug>
+ </versionStandard>
+ <title>Zwischenarchivierung durchführen</title>
+ </xs:appinfo>
+ </xs:annotation>
+ <xs:include schemaLocation="xdomea-Baukasten.xsd"/>
+ <xs:include schemaLocation="xdomea-Typen-ZwischenarchivierungDurchfuehren.xsd"/>
+ <xs:element name="Zwischenarchivierung.Auslagerung.0701">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt den vollständigen Export von Schriftgutobjekten zur Auslagerung an ein Zwischenarchiv.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkZwischenarchivierungType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Auslagerungs-Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Anschreiben" minOccurs="0" type="xdomea:DokumentType">
+ <xs:annotation>
+ <xs:documentation>Ein Dokument, das dem Empfänger zur Erläuterung der Auslagerung mitgegeben wird.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Schriftgutobjekt" maxOccurs="unbounded">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Bei der Auslagerung müssen zu einem Schriftgutobjekt alle prozess- und aktenrelevanten Metadaten übergeben werden. Die Fristen und die Aussonderungsart werden bei der Auslagerung zu einem Schriftgutobjekt mit übergeben.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Ein Schriftgutobjekt (Akte, Vorgang oder Dokument) zu einer Auslagerung.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:choice>
+ <xs:element name="Akte" type="xdomea:AkteType">
+ <xs:annotation>
+ <xs:documentation>Eine Akte.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Vorgang" type="xdomea:VorgangType">
+ <xs:annotation>
+ <xs:documentation>Ein Vorgang.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Dokument" type="xdomea:DokumentType">
+ <xs:annotation>
+ <xs:documentation>Ein Dokument.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:choice>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Aktenplan" minOccurs="0" type="xdomea:AktenplanType">
+ <xs:annotation>
+ <xs:documentation>Der Aktenplan zu einer Auslagerung enthält ein aufgabenbezogenes mehrstufiges Ordnungssystem mit einer hierarchischer Gliederung für das Bilden und Kennzeichnen von Akten und Vorgängen sowie das Zuordnen von Dokumenten.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Zwischenarchivierung.AuslagerungEmpfangBestaetigen.0702">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt den erfolgreichen Empfang der Auslagerung.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkBasisType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Empfangsbestätigung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Zwischenarchivierung.AuslagerungImportBestaetigen.0703">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die erfolgreiche oder nicht erfolgreiche Übernahme der Auslagerung.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkBasisType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Importnachricht zu einer Auslagerung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="AusgelagertesObjekt"
+ maxOccurs="unbounded"
+ type="xdomea:ErfolgOderMisserfolgZwischenarchivierungType">
+ <xs:annotation>
+ <xs:documentation>Die Information zum erfolgreichen oder nicht erfolgreichen Import eines Schriftgutobjekts zur Auslagerung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Zwischenarchivierung.RueckleiheAnforderung.0711">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die Anforderung zur Rückleihe (nur lesender Zugriff) von ausgelagerten Schriftgutobjekten durch die zuständige Verwaltung.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkBasisType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Rückleihe-Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="RueckzuleihendesObjekt"
+ maxOccurs="unbounded"
+ type="xdomea:stringUUIDType">
+ <xs:annotation>
+ <xs:documentation>Das Identifikationsmerkmal zu einem Schriftgutobjekt, das zurückgeliehen werden soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Zwischenarchivierung.RueckleiheUebergabe.0712">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die durchgeführte Rückleihe (nur lesender Zugriff) von Schriftgutobjekten als Übergabe von einem Zwischenarchiv an ein DMS/VBS.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkZwischenarchivierungType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Rückleihe-Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Anschreiben" minOccurs="0" type="xdomea:DokumentType">
+ <xs:annotation>
+ <xs:documentation>Ein Dokument, das dem Empfänger zur Erläuterung der Rückleihe mitgegeben wird.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Schriftgutobjekt" maxOccurs="unbounded">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Bei der Rückleihe müssen zu einem Schriftgutobjekt alle prozess- und aktenrelevanten Metadaten übergeben werden. Die aufnehmende Behörde übernimmt das Schriftgutobjekt als Kopie in das eigene System. Das Original verbleibt im Zwischenarchiv.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Ein Schriftgutobjekt (Akte, Vorgang oder Dokument) zu einer durchgeführten Rückleihe.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:choice>
+ <xs:element name="Akte" type="xdomea:AkteType">
+ <xs:annotation>
+ <xs:documentation>Eine Akte.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Vorgang" type="xdomea:VorgangType">
+ <xs:annotation>
+ <xs:documentation>Ein Vorgang.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Dokument" type="xdomea:DokumentType">
+ <xs:annotation>
+ <xs:documentation>Ein Dokument.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:choice>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Aktenplan" minOccurs="0" type="xdomea:AktenplanType">
+ <xs:annotation>
+ <xs:documentation>Der Aktenplan zu einer Rückleihe enthält ein aufgabenbezogenes mehrstufiges Ordnungssystem mit einer hierarchischer Gliederung für das Bilden und Kennzeichnen von Akten und Vorgängen sowie das Zuordnen von Dokumenten.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Zwischenarchivierung.RueckleiheEmpfangBestaetigen.0713">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt den erfolgreichen Empfang der Rückleihe.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkBasisType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Empfangsbestätigung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Zwischenarchivierung.RueckuebertragungAnforderung.0721">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die Anforderung zur Rückübertragung (lesender und schreibender Zugriff) von ausgelagerten Schriftgutobjekten durch die zuständige Verwaltung.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkBasisType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Rückübertragungs-Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="RueckzuuebertragendesObjekt"
+ maxOccurs="unbounded"
+ type="xdomea:stringUUIDType">
+ <xs:annotation>
+ <xs:documentation>Das Identifikationsmerkmal zu einem Schriftgutobjekt, das zurückübertragen werden soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Zwischenarchivierung.RueckuebertragungUebergabe.0722">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die vollständige Rückübertragung (lesender und schreibender Zugriff) von Schriftgutobjekten als Übergabe von einem Zwischenarchiv an ein DMS/VBS.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkZwischenarchivierungType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Rückübertragungs-Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Anschreiben" minOccurs="0" type="xdomea:DokumentType">
+ <xs:annotation>
+ <xs:documentation>Ein Dokument, das dem Empfänger zur Erläuterung der Rückübertragung mitgegeben wird.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Schriftgutobjekt" maxOccurs="unbounded">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Bei der Rückübertragung müssen zu einem Schriftgutobjekt alle prozess- und aktenrelevanten Metadaten übergeben werden. Die Fristen und die Aussonderungsart werden bei der Rückübertragung zu einem Schriftgutobjekt mit übergeben. Die aufnehmende Behörde übernimmt das rückübertragene Schriftgutobjekt in ihr System. Das Schriftgutobjekt wird anschließend im Zwischenarchiv gelöscht.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Ein Schriftgutobjekt (Akte, Vorgang oder Dokument) zu einer durchgeführten Rückübertragung.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:choice>
+ <xs:element name="Akte" type="xdomea:AkteType">
+ <xs:annotation>
+ <xs:documentation>Eine Akte.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Vorgang" type="xdomea:VorgangType">
+ <xs:annotation>
+ <xs:documentation>Ein Vorgang.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Dokument" type="xdomea:DokumentType">
+ <xs:annotation>
+ <xs:documentation>Ein Dokument.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:choice>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Aktenplan" minOccurs="0" type="xdomea:AktenplanType">
+ <xs:annotation>
+ <xs:documentation>Der Aktenplan zu einer Rückübertragung enthält ein aufgabenbezogenes mehrstufiges Ordnungssystem mit einer hierarchischer Gliederung für das Bilden und Kennzeichnen von Akten und Vorgängen sowie das Zuordnen von Dokumenten.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Zwischenarchivierung.RueckuebertragungImportBestaetigen.0723">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt die erfolgreiche oder nicht erfolgreiche Übernahme der Rückübertragung.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkBasisType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Importnachricht zu einer Rückübertragung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="RueckuebertragenesObjekt"
+ maxOccurs="unbounded"
+ type="xdomea:ErfolgOderMisserfolgZwischenarchivierungType">
+ <xs:annotation>
+ <xs:documentation>Die Information zum erfolgreichen oder nicht erfolgreichen Import eines Schriftgutobjekts zur Rueckuebertragung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Zwischenarchivierung.RueckuebertragungEmpfangBestaetigen.0724">
+ <xs:annotation>
+ <xs:documentation>Die Nachricht beschreibt den erfolgreichen Empfang der Rückübertragung.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:sequence>
+ <xs:element name="Kopf" type="xdomea:NkBasisType">
+ <xs:annotation>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Empfangsbestätigung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ </xs:element>
+</xs:schema>
diff --git a/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-Zwischenarchivsystem.xsd b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-Zwischenarchivsystem.xsd
new file mode 100644
index 0000000000000000000000000000000000000000..eebc19d5b789cfb58b7b2aa122b5144de23fad93
--- /dev/null
+++ b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Nachrichten-Zwischenarchivsystem.xsd
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+ xmlns:xdomea="urn:xoev-de:xdomea:schema:3.0.0"
+ targetNamespace="urn:xoev-de:xdomea:schema:3.0.0"
+ version="3.0.0"
+ elementFormDefault="qualified"
+ attributeFormDefault="unqualified">
+ <xs:annotation>
+ <xs:appinfo>
+ <standard>
+ <nameLang>xdomea - XÖV-Standard für den IT-gestützten Austausch und die IT-gestützte Aussonderung behördlichen Schriftgutes</nameLang>
+ <nameKurz>xdomea</nameKurz>
+ <nameTechnisch>xdomea</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:kosit:standard:xdomea</kennung>
+ <beschreibung>xdomea ist der vom IT-Planungsrat verabschiedete verbindliche Standard für den Austausch von Akten, Vorgängen und Dokumenten im Kontext der Übermittlung, der Abgabe sowie der Aussonderung von Schriftgutobjekten (www.it-planungsrat.de, Beschluss 2017/39). Weiterhin kann xdomea für den Austausch zwischen Fachverfahren und DMS/VBS sowie für die Zwischenarchivierung genutzt werden.
+
+Um diese Anwendungsszenarien bestmöglich zu unterstützen, ist xdomea gemäß des XÖV-Rahmenwerkes nach dem Baukastenprinzip aufgebaut und bietet einzelne Nachrichten(gruppen) für die jeweiligen Prozesse an.
+
+Der Standard xdomea wird von der gleichnamigen Arbeitsgruppe des IT-Planungsrates weiterentwickelt und gepflegt. Der Betrieb des Standards erfolgt durch die Koordinierungsstelle für IT-Standards (KoSIT).
+</beschreibung>
+ </standard>
+ <versionStandard>
+ <version>3.0.0</version>
+ <beschreibung>Die Version 3.0.0 ist durch den IT-Planungsrat beschlossen. Details zum Beschluss sowie zu den Fristen der Umsetzung sind der Veröffentlichung im Bundesanzeiger unter www.bundesanzeiger.de zu entnehmen.</beschreibung>
+ <versionXOEVProfil>1.7.2</versionXOEVProfil>
+ <versionXOEVHandbuch>2.3.1</versionXOEVHandbuch>
+ <versionXGenerator>3.0.1</versionXGenerator>
+ <versionModellierungswerkzeug>19.0</versionModellierungswerkzeug>
+ <nameModellierungswerkzeug>MagicDraw</nameModellierungswerkzeug>
+ </versionStandard>
+ </xs:appinfo>
+ </xs:annotation>
+ <xs:include schemaLocation="xdomea-Nachrichten-ZwischenarchivierungDurchfuehren.xsd"/>
+</xs:schema>
diff --git a/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Typen-AbgabeDurchfuehren.xsd b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Typen-AbgabeDurchfuehren.xsd
new file mode 100644
index 0000000000000000000000000000000000000000..0b9e7a335c364ff7ac019f5a98991a9588d0f491
--- /dev/null
+++ b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Typen-AbgabeDurchfuehren.xsd
@@ -0,0 +1,97 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+ xmlns:xdomea="urn:xoev-de:xdomea:schema:3.0.0"
+ targetNamespace="urn:xoev-de:xdomea:schema:3.0.0"
+ version="3.0.0"
+ elementFormDefault="qualified"
+ attributeFormDefault="unqualified">
+ <xs:annotation>
+ <xs:appinfo>
+ <standard>
+ <nameLang>xdomea - XÖV-Standard für den IT-gestützten Austausch und die IT-gestützte Aussonderung behördlichen Schriftgutes</nameLang>
+ <nameKurz>xdomea</nameKurz>
+ <nameTechnisch>xdomea</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:kosit:standard:xdomea</kennung>
+ <beschreibung>xdomea ist der vom IT-Planungsrat verabschiedete verbindliche Standard für den Austausch von Akten, Vorgängen und Dokumenten im Kontext der Übermittlung, der Abgabe sowie der Aussonderung von Schriftgutobjekten (www.it-planungsrat.de, Beschluss 2017/39). Weiterhin kann xdomea für den Austausch zwischen Fachverfahren und DMS/VBS sowie für die Zwischenarchivierung genutzt werden.
+
+Um diese Anwendungsszenarien bestmöglich zu unterstützen, ist xdomea gemäß des XÖV-Rahmenwerkes nach dem Baukastenprinzip aufgebaut und bietet einzelne Nachrichten(gruppen) für die jeweiligen Prozesse an.
+
+Der Standard xdomea wird von der gleichnamigen Arbeitsgruppe des IT-Planungsrates weiterentwickelt und gepflegt. Der Betrieb des Standards erfolgt durch die Koordinierungsstelle für IT-Standards (KoSIT).
+</beschreibung>
+ </standard>
+ <versionStandard>
+ <version>3.0.0</version>
+ <beschreibung>Die Version 3.0.0 ist durch den IT-Planungsrat beschlossen. Details zum Beschluss sowie zu den Fristen der Umsetzung sind der Veröffentlichung im Bundesanzeiger unter www.bundesanzeiger.de zu entnehmen.</beschreibung>
+ <versionXOEVProfil>1.7.2</versionXOEVProfil>
+ <versionXOEVHandbuch>2.3.1</versionXOEVHandbuch>
+ <versionXGenerator>3.0.1</versionXGenerator>
+ <versionModellierungswerkzeug>19.0</versionModellierungswerkzeug>
+ <nameModellierungswerkzeug>MagicDraw</nameModellierungswerkzeug>
+ </versionStandard>
+ </xs:appinfo>
+ </xs:annotation>
+ <xs:include schemaLocation="xdomea-Baukasten.xsd"/>
+ <xs:complexType name="ErfolgOderMisserfolgAbgabeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>ErfolgOderMisserfolgAbgabe</title>
+ </xs:appinfo>
+ <xs:documentation>Die Information zum erfolgreichen oder nicht erfolgreichen Import eines abzugebenden Schriftgutobjektes.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="IDSGO" type="xdomea:stringUUIDType">
+ <xs:annotation>
+ <xs:documentation>Die ID des Schriftgutobjekts, das abgegeben werden sollte.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Erfolgreich" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>Die Kennzeichnung des erfolgreichen oder nicht erfolgreichen Imports zu einem abzugebenden Schriftgutobjekt. Der erfolgreiche Import wird mit 1 und der nicht erfolgreiche Import mit 0 gekennzeichnet.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Fehlermeldung"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Information in Form eines Freitextes, aus welchem Grund der Import zum abzugebenden Schriftgutobjekt nicht erfolgreich war.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="FehlermeldungCode"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:SonstigeFehlermeldungCodeType">
+ <xs:annotation>
+ <xs:documentation>Die Information in Form eines Codes, aus welchem Grund der Import zum abzugebenden Schriftgutobjekt nicht erfolgreich war.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="NkAbgabeType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>NkAbgabe</title>
+ </xs:appinfo>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger einer Nachricht, bei der es sich um eine Abgabe handelt.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="xdomea:NkNichtFVDatenWeitereEmpfaengerType">
+ <xs:sequence>
+ <xs:element name="Importbestaetigung" fixed="1" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>Die Angabe, dass eine Importbestätigung vom Empfänger der Nachricht erwünscht wird.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Empfangsbestaetigung" type="xs:boolean">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Für die Umsetzung in den Systemen wird empfohlen, sofern kein anderer Wert hinterlegt wurde, als Standardwert den Wert 0 für "keine Empfangsbestätigung senden" anzugeben.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die Angabe, ob vom Empfänger der Nachricht eine Empfangsbestätigung erwünscht wird. Eine erwünschte Empfangsbestätigung wird mit 1 gekennzeichnet. Wird keine Empfangsbestätigung gewünscht, so wird dies mit 0 gekennzeichnet.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+</xs:schema>
diff --git a/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Typen-AussonderungDurchfuehren.xsd b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Typen-AussonderungDurchfuehren.xsd
new file mode 100644
index 0000000000000000000000000000000000000000..434d076a81bdb44f0dd9f85672767c26d0d06d05
--- /dev/null
+++ b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Typen-AussonderungDurchfuehren.xsd
@@ -0,0 +1,237 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+ xmlns:xdomea="urn:xoev-de:xdomea:schema:3.0.0"
+ targetNamespace="urn:xoev-de:xdomea:schema:3.0.0"
+ version="3.0.0"
+ elementFormDefault="qualified"
+ attributeFormDefault="unqualified">
+ <xs:annotation>
+ <xs:appinfo>
+ <standard>
+ <nameLang>xdomea - XÖV-Standard für den IT-gestützten Austausch und die IT-gestützte Aussonderung behördlichen Schriftgutes</nameLang>
+ <nameKurz>xdomea</nameKurz>
+ <nameTechnisch>xdomea</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:kosit:standard:xdomea</kennung>
+ <beschreibung>xdomea ist der vom IT-Planungsrat verabschiedete verbindliche Standard für den Austausch von Akten, Vorgängen und Dokumenten im Kontext der Übermittlung, der Abgabe sowie der Aussonderung von Schriftgutobjekten (www.it-planungsrat.de, Beschluss 2017/39). Weiterhin kann xdomea für den Austausch zwischen Fachverfahren und DMS/VBS sowie für die Zwischenarchivierung genutzt werden.
+
+Um diese Anwendungsszenarien bestmöglich zu unterstützen, ist xdomea gemäß des XÖV-Rahmenwerkes nach dem Baukastenprinzip aufgebaut und bietet einzelne Nachrichten(gruppen) für die jeweiligen Prozesse an.
+
+Der Standard xdomea wird von der gleichnamigen Arbeitsgruppe des IT-Planungsrates weiterentwickelt und gepflegt. Der Betrieb des Standards erfolgt durch die Koordinierungsstelle für IT-Standards (KoSIT).
+</beschreibung>
+ </standard>
+ <versionStandard>
+ <version>3.0.0</version>
+ <beschreibung>Die Version 3.0.0 ist durch den IT-Planungsrat beschlossen. Details zum Beschluss sowie zu den Fristen der Umsetzung sind der Veröffentlichung im Bundesanzeiger unter www.bundesanzeiger.de zu entnehmen.</beschreibung>
+ <versionXOEVProfil>1.7.2</versionXOEVProfil>
+ <versionXOEVHandbuch>2.3.1</versionXOEVHandbuch>
+ <versionXGenerator>3.0.1</versionXGenerator>
+ <versionModellierungswerkzeug>19.0</versionModellierungswerkzeug>
+ <nameModellierungswerkzeug>MagicDraw</nameModellierungswerkzeug>
+ </versionStandard>
+ </xs:appinfo>
+ </xs:annotation>
+ <xs:include schemaLocation="xdomea-Baukasten.xsd"/>
+ <xs:complexType name="AktenplanBewertungskatalogType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>AktenplanBewertungskatalog</title>
+ </xs:appinfo>
+ <xs:documentation>Der Aktenplan enthält ein aufgabenbezogenes mehrstufiges Ordnungssystem mit einer hierarchischen Gliederung für das Bilden und Kennzeichnen von Akten und Vorgängen sowie das Zuordnen von Dokumenten.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="ID" type="xdomea:stringUUIDType">
+ <xs:annotation>
+ <xs:documentation>Die UUID des Aktenplans.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Bezeichnung" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Name des Aktenplans.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Typ" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Typ des Aktenplans, z.B. Teilaktenplan.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Version" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Version des Aktenplans.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Einheit"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:AktenplaneinheitAktenplanBewertungskatalogType">
+ <xs:annotation>
+ <xs:documentation>Die Einheit eines Aktenplans, die Auskunft über die hierarchische Strukturierung eines Aktenplans gibt. Eine Aktenplanheit entspricht z.B. einer Hauptgruppe, Obergruppe, Gruppe, Untergruppe oder Betreffseinheit.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Gueltigkeit" minOccurs="0" type="xdomea:ZeitraumType">
+ <xs:annotation>
+ <xs:documentation>Die Gültigkeit des Aktenplans mit Beginn und Ende.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Aktenplandatei"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:FormatType">
+ <xs:annotation>
+ <xs:documentation>Die Datei zum Aktenplan als Primärdokument.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="AktenplaneinheitAktenplanBewertungskatalogType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>AktenplaneinheitAktenplanBewertungskatalog</title>
+ </xs:appinfo>
+ <xs:documentation>Eine Aktenplaneinheit gibt Auskunft über die hierarchische Strukturierung eines Aktenplans. Eine Aktenplanheit entspricht z.B. einer Hauptgruppe, Obergruppe, Gruppe, Untergruppe oder Betreffseinheit.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="ID" type="xdomea:stringUUIDType">
+ <xs:annotation>
+ <xs:documentation>Die UUID der Aktenplaneinheit.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Aussonderungsart" type="xdomea:AussonderungsartType">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Die Aussonderungsart vererbt sich auf alle unter einer Hierarchiestufe angelegten Schriftgutobjekte.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die Aussonderungsart gibt das Ergebnis der archivischen Bewertung an. Die Aussonderungsart wird vom Aktenplan (zweistufiges Aussonderungsverfahren) auf zugehörige Akten und Vorgänge vererbt.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="ErfolgOderMisserfolgAussonderungType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>ErfolgOderMisserfolgAussonderung</title>
+ </xs:appinfo>
+ <xs:documentation>Die Information zum erfolgreichen oder nicht erfolgreichen Import eines auszusondernden Schriftgutobjekts.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="IDSGO" type="xdomea:stringUUIDType">
+ <xs:annotation>
+ <xs:documentation>Die ID des Schriftgutobjekts, das ausgesondert werden sollte.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Erfolgreich" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>Die Kennzeichnung des erfolgreichen oder nicht erfolgreichen Imports der Aussonderung zu einem Schriftgutobjekt. Der erfolgreiche Import wird mit 1 und der nicht erfolgreiche Import mit 0 gekennzeichnet.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Fehlermeldung"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Erläuterung des Grundes als Freitext für den nicht erfolgreichen Import einer Aussonderung zu einem Schriftgutobjekt.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="FehlermeldungCode"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:SonstigeFehlermeldungCodeType">
+ <xs:annotation>
+ <xs:documentation>Erläuterung des Grundes als Code für den nicht erfolgreichen Import einer Aussonderung zu einem Schriftgutobjekt.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Archivkennung" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die ID, unter der das ausgesonderte Schriftgutobjekt im Archiv verwahrt wird. Für den Fall, dass "Erfolgreich" positiv belegt ist und von der aussondernden Behörde die Rückgabe der Archivkennungen gewünscht ist ("RueckmeldungArchivkennung" ist positiv belegt), können durch das archivierende System die Archivkennungen zu den einzelnen Schriftgutobjekt übergeben werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="ErfolgOderMisserfolgBewertungskatalogType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>ErfolgOderMisserfolgBewertungskatalog</title>
+ </xs:appinfo>
+ <xs:documentation>Die Information zum erfolgreichen oder nicht erfolgreichen Import einer zu bewertenden Aktenplaneinheit.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="ID" type="xdomea:stringUUIDType">
+ <xs:annotation>
+ <xs:documentation>Die ID der Aktenplaneinheit, die bewertet werden sollte.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Erfolgreich" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>Die Kennzeichnung des erfolgreichen oder nicht erfolgreichen Imports der Bewertung zu einer Aktenplaneinheit. Der erfolgreiche Import wird mit 1 und der nicht erfolgreiche Import mit 0 gekennzeichnet.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Fehlermeldung"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Erläuterung des Grundes als Freitext für den nicht erfolgreichen Import einer Bewertung zu einer Aktenplaneinheit.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="FehlermeldungCode"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:SonstigeFehlermeldungCodeType">
+ <xs:annotation>
+ <xs:documentation>Erläuterung des Grundes als Code für den nicht erfolgreichen Import einer Bewertung zu einer Aktenplaneinheit.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="NkAussonderungType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>NkAussonderung</title>
+ </xs:appinfo>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger einer Nachricht, bei der es sich um die konkrete Aussonderung handelt.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="xdomea:NkBasisType">
+ <xs:sequence>
+ <xs:element name="Importbestaetigung" fixed="1" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>Die Angabe, dass eine Importbestätigung vom Empfänger der Nachricht erwünscht wird.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="RueckmeldungArchivkennung" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>Die Angabe, ob die Rückübermittlung der Archivsignaturen vom Empfänger erwünscht wird. Sollen die Archivsignaturen übermittelt werden, so ist der Wert 1 anzugeben. Sollen keine Archivsignaturen übermittelt werden, so ist der Wert 0 anzugeben.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Empfangsbestaetigung" type="xs:boolean">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Für die Umsetzung in den Systemen wird empfohlen, sofern kein anderer Wert hinterlegt wurde, als Standardwert den Wert 0 für "keine Empfangsbestätigung senden" anzugeben.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die Angabe, ob vom Empfänger der Nachricht eine Empfangsbestätigung erwünscht wird. Eine erwünschte Empfangsbestätigung wird mit 1 gekennzeichnet. Wird keine Empfangsbestätigung gewünscht, so wird dies mit 0 gekennzeichnet.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="RueckgabeparameterAnbietungType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>RueckgabeparameterAnbietung</title>
+ </xs:appinfo>
+ <xs:documentation>Die Rückmeldung des Archivs zu einem zur Bewertung übergegebenen Schriftgutobjekt zur Steuerung des weiteren Aussonderungsprozesses.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="ID" type="xdomea:stringUUIDType">
+ <xs:annotation>
+ <xs:documentation>Die UUID des angebotenen Schriftgutobjektes, in der Regel die eines Vorgangs.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Aussonderungsart" type="xdomea:AussonderungsartType">
+ <xs:annotation>
+ <xs:documentation>Die Beschreibung des Bewertungsergebnisses für ein angebotenes Schriftgutobjekt.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+</xs:schema>
diff --git a/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Typen-FachverfahrensdatenAustauschen.xsd b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Typen-FachverfahrensdatenAustauschen.xsd
new file mode 100644
index 0000000000000000000000000000000000000000..118adb112c056b51430e34c9f4d08916fff1e8f4
--- /dev/null
+++ b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Typen-FachverfahrensdatenAustauschen.xsd
@@ -0,0 +1,1392 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+ xmlns:xdomea="urn:xoev-de:xdomea:schema:3.0.0"
+ targetNamespace="urn:xoev-de:xdomea:schema:3.0.0"
+ version="3.0.0"
+ elementFormDefault="qualified"
+ attributeFormDefault="unqualified">
+ <xs:annotation>
+ <xs:appinfo>
+ <standard>
+ <nameLang>xdomea - XÖV-Standard für den IT-gestützten Austausch und die IT-gestützte Aussonderung behördlichen Schriftgutes</nameLang>
+ <nameKurz>xdomea</nameKurz>
+ <nameTechnisch>xdomea</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:kosit:standard:xdomea</kennung>
+ <beschreibung>xdomea ist der vom IT-Planungsrat verabschiedete verbindliche Standard für den Austausch von Akten, Vorgängen und Dokumenten im Kontext der Übermittlung, der Abgabe sowie der Aussonderung von Schriftgutobjekten (www.it-planungsrat.de, Beschluss 2017/39). Weiterhin kann xdomea für den Austausch zwischen Fachverfahren und DMS/VBS sowie für die Zwischenarchivierung genutzt werden.
+
+Um diese Anwendungsszenarien bestmöglich zu unterstützen, ist xdomea gemäß des XÖV-Rahmenwerkes nach dem Baukastenprinzip aufgebaut und bietet einzelne Nachrichten(gruppen) für die jeweiligen Prozesse an.
+
+Der Standard xdomea wird von der gleichnamigen Arbeitsgruppe des IT-Planungsrates weiterentwickelt und gepflegt. Der Betrieb des Standards erfolgt durch die Koordinierungsstelle für IT-Standards (KoSIT).
+</beschreibung>
+ </standard>
+ <versionStandard>
+ <version>3.0.0</version>
+ <beschreibung>Die Version 3.0.0 ist durch den IT-Planungsrat beschlossen. Details zum Beschluss sowie zu den Fristen der Umsetzung sind der Veröffentlichung im Bundesanzeiger unter www.bundesanzeiger.de zu entnehmen.</beschreibung>
+ <versionXOEVProfil>1.7.2</versionXOEVProfil>
+ <versionXOEVHandbuch>2.3.1</versionXOEVHandbuch>
+ <versionXGenerator>3.0.1</versionXGenerator>
+ <versionModellierungswerkzeug>19.0</versionModellierungswerkzeug>
+ <nameModellierungswerkzeug>MagicDraw</nameModellierungswerkzeug>
+ </versionStandard>
+ </xs:appinfo>
+ </xs:annotation>
+ <xs:include schemaLocation="xdomea-Baukasten.xsd"/>
+ <xs:complexType name="BearbeitungFVType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>BearbeitungFV</title>
+ </xs:appinfo>
+ <xs:documentation>BearbeitungFV enthält Angaben zur Bearbeitung eines Schriftgutobjekts mit der Möglichkeit, den Bearbeiter, den Bearbeitungszeitpunkt und eine Notiz mitzugeben.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Bearbeiter" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Person, die die Bearbeitung vorgenommen hat. Wird die Bearbeitung automatisch durch das System und nicht manuell durch eine Person vorgenommen, so ist das entsprechende System anzugeben.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Datum" type="xs:date">
+ <xs:annotation>
+ <xs:documentation>Das Datum der zu protokollierenden Bearbeitung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Uhrzeit" minOccurs="0" type="xs:time">
+ <xs:annotation>
+ <xs:documentation>Der Zeitpunkt der zu protokollierenden Bearbeitung.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Notiz" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Anmerkung, die Aufschluss über die durchgeführte(n) Aktion(en) während einer Bearbeitung gibt.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="DatensatzZumLoeschenType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>DatensatzZumLoeschen</title>
+ </xs:appinfo>
+ <xs:documentation>DatensatzZumLoeschen enthält Informationen zu einem FV-Datensatz, zu dem die entsprechenden Objekte im DMS gelöscht werden sollen. Wird die Nachricht im Stapelbetrieb übergeben, so erfolgt hier zusätzlich die Übergabe der Nummer im Stapel zu jedem angegebenen FV-Datensatz.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="NummerImStapel" minOccurs="0" type="xs:unsignedInt">
+ <xs:annotation>
+ <xs:documentation>Die Nummer des übergebenen Elements im Stapel. Anhand dieser Nummer können im Rückmeldestapel die Rückmeldungen den einzelnen Elementen im Stapel zugeordnet werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="FachverfahrenDatensatzID" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die ID des Datensatzes im Fachverfahren.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="DokumentZumAktualisierenType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>DokumentZumAktualisieren</title>
+ </xs:appinfo>
+ <xs:documentation>DokumentZumAktualisieren enthält Informationen zu einem Dokument (z.B. Ablageort), dessen Daten im empfangenden System aktualisiert werden sollen. Wird die Nachricht im Stapelbetrieb übergeben, so erfolgt hier zusätzlich die Übergabe der Nummer im Stapel zu jedem angegebenen Dokument.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="NummerImStapel" minOccurs="0" type="xs:unsignedInt">
+ <xs:annotation>
+ <xs:documentation>Die Nummer des übergebenen Elements im Stapel. Anhand dieser Nummer können im Rückmeldestapel die Rückmeldungen den einzelnen Elementen im Stapel zugeordnet werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="IDDokument" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>ID des zu aktualisierenden Dokumentes im DMS, die dem Fachverfahren beim Anlegen des Dokuments vom DMS mitgeteilt wurde.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Ablageort" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Ablageort des Schriftgutobjekts, das im DMS abgelegt werden soll. Die Primärdokumente zu Dokumenten finden sich in Dateien, die durch Primaerdokument.Dateiname spezifiziert werden. In Abhängigkeit des Konfigurationsparameters Datenaustauschart kann dieser Parameter unterschiedliche Werte annehmen: Übergabe über ein freigegebenes Verzeichnis: Name des Verzeichnisses. Übergabe per WebDAV und http(s): URL. Übergabe über eine Datenbank: der Parameter bleibt leer (bzw. wird ignoriert).</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="NeueVersionErstellen" minOccurs="0" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>Über NeueVersionErstellen kann die Erzeugung einer neuen Version erzwungen werden. Wird kein Wert für diesen Parameter oder der Wert 0 angegeben, so wird keine neue Version erzeugt. Soll die Erzeugung einer neuen Version über diesen Parameter erzwungen werden, so ist der Wert 1 anzugeben.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Dokument" type="xdomea:DokumentType">
+ <xs:annotation>
+ <xs:documentation>Das Dokument, das aktualisiert werden soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="DokumentZumExportierenType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>DokumentZumExportieren</title>
+ </xs:appinfo>
+ <xs:documentation>DokumentZumExportieren enthält Informationen zu den Primärdokumenten eines Schriftgutobjekts (Dokument), die in einem DMS abgelegt wurden und in das empfangende Fachverfahren exportiert werden sollen.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="IDSGO" type="xdomea:stringUUIDType">
+ <xs:annotation>
+ <xs:documentation>Die ID des Schriftgutobjekts im DMS, zu dem Primärdokumente exportiert werden sollen.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Versionsnummer" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Wird keine Versionsnummer übergeben, so wird der aktuelle Stand des Dokuments exportiert.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die Versionsnummer des Dokuments.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="ErfolgOderMisserfolgDMSType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>ErfolgOderMisserfolgDMS</title>
+ <implementationHint>Es ist durch die Implementierer darauf zu achten, dass Rückmeldungen auf der Nachrichtenebene mit denen auf der Parameterebene in Einklang stehen und ihnen nicht widersprechen.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die Information zum erfolgreichen oder nicht erfolgreichen Import von Daten.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Rueckmeldung" maxOccurs="unbounded">
+ <xs:annotation>
+ <xs:documentation>Die Beschreibung der Rückmeldungsart, die zu dem Import der empfangenen Daten an das sendende System zurückübermittelt wird.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:choice>
+ <xs:element name="AllgemeineRueckmeldung"
+ type="xdomea:AllgemeineRueckmeldungCodeType">
+ <xs:annotation>
+ <xs:documentation>Eine allgemeine Rückmeldung, z.B. Verbindungsabbruch, Übertragungsfehler.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0601"
+ type="xdomea:SpezifischeFehlermeldung0601CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0601.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0602"
+ type="xdomea:SpezifischeFehlermeldung0602CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0602.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0603"
+ type="xdomea:SpezifischeFehlermeldung0603CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0603.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0604"
+ type="xdomea:SpezifischeFehlermeldung0604CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0604.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0605"
+ type="xdomea:SpezifischeFehlermeldung0605CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0605.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0606"
+ type="xdomea:SpezifischeFehlermeldung0606CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0606.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0607"
+ type="xdomea:SpezifischeFehlermeldung0607CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0607.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0608"
+ type="xdomea:SpezifischeFehlermeldung0608CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0608.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0609"
+ type="xdomea:SpezifischeFehlermeldung0609CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0609.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0610"
+ type="xdomea:SpezifischeFehlermeldung0610CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0610.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0611"
+ type="xdomea:SpezifischeFehlermeldung0611CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0611.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0612"
+ type="xdomea:SpezifischeFehlermeldung0612CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0612.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0613"
+ type="xdomea:SpezifischeFehlermeldung0613CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0613.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0614"
+ type="xdomea:SpezifischeFehlermeldung0614CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0614.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0615"
+ type="xdomea:SpezifischeFehlermeldung0615CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0615.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0616"
+ type="xdomea:SpezifischeFehlermeldung0616CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0616.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0617"
+ type="xdomea:SpezifischeFehlermeldung0617CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0617.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0618"
+ type="xdomea:SpezifischeFehlermeldung0618CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0618.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0619"
+ type="xdomea:SpezifischeFehlermeldung0619CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0619.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0620"
+ type="xdomea:SpezifischeFehlermeldung0620CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0620.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0621"
+ type="xdomea:SpezifischeFehlermeldung0621CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0621.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0622"
+ type="xdomea:SpezifischeFehlermeldung0622CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0622.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0623"
+ type="xdomea:SpezifischeFehlermeldung0623CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0623.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0624"
+ type="xdomea:SpezifischeFehlermeldung0624CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0624.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0625"
+ type="xdomea:SpezifischeFehlermeldung0625CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0625.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0626"
+ type="xdomea:SpezifischeFehlermeldung0626CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0626.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0627"
+ type="xdomea:SpezifischeFehlermeldung0627CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0627.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0628"
+ type="xdomea:SpezifischeFehlermeldung0628CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0628.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0631"
+ type="xdomea:SpezifischeFehlermeldung0631CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0631.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0632"
+ type="xdomea:SpezifischeFehlermeldung0632CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0632.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SonstigeFehlermeldung" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Eine sonstige, nicht näher definierte Fehlermeldung, die als Freitext formuliert werden kann.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SonstigeFehlermeldungCode"
+ type="xdomea:SonstigeFehlermeldungCodeType">
+ <xs:annotation>
+ <xs:documentation>Eine sonstige, nicht näher in xdomea definierte Fehlermeldung, die als Code angegeben werden kann.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:choice>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Rueckgabeparameter"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:RueckgabeparameterFVDatenType">
+ <xs:annotation>
+ <xs:documentation>Die Beschreibung der Daten, die bei einem erfolgreichen oder nicht erfolgreichen Import der empfangenen Daten an das sendende System zurückübermittelt werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="GesamtprotokollZumAblegenType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>GesamtprotokollZumAblegen</title>
+ </xs:appinfo>
+ <xs:documentation>GesamtprotokollZumAblegen beschreibt alle aktenrelevanten Bearbeitungs- und Protokollinformationen zu einem Schriftgutobjekt, die aus einem Fachverfahren in einem DMS abzulegen sind. Wird die Nachricht im Stapelbetrieb übergeben, so erfolgt hier zusätzlich die Übergabe der Nummer im Stapel zu jedem angegebenen Gesamtprotokoll.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="NummerImStapel" minOccurs="0" type="xs:unsignedInt">
+ <xs:annotation>
+ <xs:documentation>Die Nummer des übergebenen Elements im Stapel. Anhand dieser Nummer können im Rückmeldestapel die Rückmeldungen den einzelnen Elementen im Stapel zugeordnet werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="IDSGO" type="xdomea:stringUUIDType">
+ <xs:annotation>
+ <xs:documentation>Die ID des Schriftgutobjektes im DMS.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Ablageort" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Ablageort des Schriftgutobjekts, das im DMS abgelegt werden soll. Die Primärdokumente zu Dokumenten finden sich in Dateien, die durch Primaerdokument.Dateiname spezifiziert werden. In Abhängigkeit des Konfigurationsparameters Datenaustauschart kann dieser Parameter unterschiedliche Werte annehmen: Übergabe über ein freigegebenes Verzeichnis: Name des Verzeichnisses. Übergabe per WebDAV und http(s): URL. Übergabe über eine Datenbank: der Parameter bleibt leer (bzw. wird ignoriert).</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Dokument" minOccurs="0" type="xdomea:DokumentType">
+ <xs:annotation>
+ <xs:documentation>Das Gesamtprotokoll als Dokument.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Geschaeftsgang"
+ minOccurs="0"
+ type="xdomea:GeschaeftsgangType">
+ <xs:annotation>
+ <xs:documentation>Die Bearbeitungsinformationen im Rahmen eines Geschäftsgangs zu dem Schriftgutobjekt.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="HistorienProtokollInformation"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:HistorienProtokollInformationType">
+ <xs:annotation>
+ <xs:documentation>Die Bearbeitungs- und Protokollinformationen eines Schriftgutobjekts.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="KonfigurationsparameterType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Konfigurationsparameter</title>
+ </xs:appinfo>
+ <xs:documentation>Ein Parameter zur Konfiguration eines anderen Systems.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Parameter" type="xdomea:KonfigurationsparameterCodeType">
+ <xs:annotation>
+ <xs:documentation>Der Name des Konfigurationsparameters.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Datentyp" minOccurs="0" type="xdomea:DatentypCodeType">
+ <xs:annotation>
+ <xs:documentation>Der Datentyp des Konfigurationsparameters.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Wert" minOccurs="0">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Für einen zu erstellenden Konfigurationsparameter muss der Wert zwingend übergeben werden.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Der Wert des Konfigurationsparameters.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:choice>
+ <xs:element name="WertOffen" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Wert ist nicht näher definiert und kann als Freitext übermittelt werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Transportweg" type="xdomea:TransportwegCodeType">
+ <xs:annotation>
+ <xs:documentation>Es handelt sich bei dem Wert des Konfigurationsparameters um einen Transportweg.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Datenaustauschart" type="xdomea:DatenaustauschartCodeType">
+ <xs:annotation>
+ <xs:documentation>Es handelt sich bei dem Wert des Konfigurationsparameters um eine Datenaustauschart.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="KomprimierterDatenaustausch" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>Es handelt sich bei dem Wert des Konfigurationsparameters um die Aussage zum komprimierten Datenaustausch. Findet eine Komprimierung der Daten statt, so ist der Wert 1 anzugeben. Findet keine Datenkomprimierung statt, so ist der Wert 0 anzugeben.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Kompressionsverfahren"
+ type="xdomea:KompressionsverfahrenCodeType">
+ <xs:annotation>
+ <xs:documentation>Es handelt sich bei dem Wert des Konfigurationsparameters um ein Kompressionsverfahren.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Standardablage" type="xdomea:StandardablageType">
+ <xs:annotation>
+ <xs:documentation>Es handelt sich bei dem Wert des Konfigurationsparameters um Angaben zur Standardablage.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:choice>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Gruppe" type="xdomea:KonfigurationsparameterGruppeCodeType">
+ <xs:annotation>
+ <xs:documentation>Die Gruppe von Parametern, zu der der Konfigurationsparameter gehört.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="KonfigurationsparameterZumAbrufenType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>KonfigurationsparameterZumAbrufen</title>
+ </xs:appinfo>
+ <xs:documentation>Der Name eines Konfigurationsparameters, der abgerufen werden soll.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:restriction base="xdomea:FeldType">
+ <xs:sequence>
+ <xs:element name="Name" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Name des Feldes.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:restriction>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="KonfigurationsparameterZumErstellenType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>KonfigurationsparameterZumErstellen</title>
+ <implementationHint>Je nach Anwendungsfall ist mindestens eines der Elemente Konfigurationsparameter bzw. DefinierterKonfigurationsparameter mit Daten zu befüllen.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die Zusammenfassung von Konfigurationsparametern, die durch einen Benutzer oder eine Rolle erstellt werden sollen.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="BenutzerOderRolle" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Benutzer oder die Rolle, der/die den/die Konfigurationsparameter erstellt hat.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="DefinierterKonfigurationsparameter"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:KonfigurationsparameterType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zu dem (den) zu erstellenden Konfigurationsparameter(n), die bereits näher klassifiziert sind.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Konfigurationsparameter"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:FeldType">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Für einen zu erstellenden Konfigurationsparameter muss der Wert zwingend übergeben werden.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die Informationen zu dem (den) zu erstellenden Konfigurationsparameter(n).</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="MetadatenZumBearbeitenType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>MetadatenZumBearbeiten</title>
+ </xs:appinfo>
+ <xs:documentation>Die Zusammenfassung von Metadaten, die zu einem Schriftgutobjekt bearbeitet werden sollen. Wird die Nachricht im Stapelbetrieb übergeben, so erfolgt hier zusätzlich die Übergabe der Nummer im Stapel zu jedem angegebenen Metadatum.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="NummerImStapel" minOccurs="0" type="xs:unsignedInt">
+ <xs:annotation>
+ <xs:documentation>Die Nummer des übergebenen Elements im Stapel. Anhand dieser Nummer können im Rückmeldestapel die Rückmeldungen den einzelnen Elementen im Stapel zugeordnet werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="IDSGO" type="xdomea:stringUUIDType">
+ <xs:annotation>
+ <xs:documentation>Die ID des Schriftgutobjekts im DMS, zu dem die übergegebenen Metadaten bearbeitet werden sollen.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Metadatum" maxOccurs="unbounded" type="xdomea:FeldType">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Für ein anzulegendes Metadatum müssen der Datentyp und der Wert zwingend übergeben werden. Für ein zu aktualisierendes Metadatum muss der Wert zwingend übergeben werden. Die Beschreibung und der Datentyp sollten nicht übergeben werden, da sie meist nicht geändert werden.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die Informationen zu einem zu bearbeitenden Metadatum, das nicht in xdomea vordefiniert ist.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="NkKeineRueckmeldungFVDatenType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>NkKeineRueckmeldungFVDaten</title>
+ </xs:appinfo>
+ <xs:documentation>Der Kopf für Nachrichten von einem Fachverfahren zu einem DMS bzw. zu einem Fachverfahren enthält allgemeine Informationen für die Bereitstellung der Nachricht sowie für den Empfänger der Nachricht selbst.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="xdomea:NkFVDatenType">
+ <xs:sequence>
+ <xs:element name="WeiteresEmpfangendesSystem"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:SystemType">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zu dem System, das ebenfalls die Daten erhalten soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Empfangsbestaetigung" type="xs:boolean">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Für die Umsetzung in den Systemen wird empfohlen, sofern kein anderer Wert hinterlegt wurde, als Standardwert den Wert 0 für "keine Empfangsbestätigung senden" anzugeben.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die Angabe, ob vom Empfänger der Nachricht eine Empfangsbestätigung erwünscht wird. Eine erwünschte Empfangsbestätigung wird mit 1 gekennzeichnet. Wird keine Empfangsbestätigung gewünscht, so wird dies mit 0 gekennzeichnet.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Importbestaetigung" fixed="1" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>Die Angabe, dass eine Importbestätigung vom Empfänger der Nachricht erwünscht wird.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Erstellerkennung" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Benutzerkennung des Nachrichtenerstellers.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="ErstellerRolle" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Rolle des Nachrichtenerstellers.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Stapel" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>Stapel gibt an, ob die Nachricht mehrere Objekte in der Stapelverarbeitung oder ein Objekt in der Einzelverarbeitung übergibt. Soll eine Stapelverarbeitung erfolgen, so ist der Wert 1 anzugeben. Soll eine Einzelverarbeitung erfolgen, so ist der Wert 0 anzugeben.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Stapellaenge" minOccurs="0" type="xs:unsignedInt">
+ <xs:annotation>
+ <xs:documentation>Die Länge des Stapels.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="DMSSessionID" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die DMS-Session-ID wird verwendet, um den Benutzer bzw. die Rolle gegenüber dem DMS zu authentifizieren. Sie wird bei der Anmeldung im DMS erzeugt und wird nach einer konfigurierbaren Zeit der Inaktivität ungültig.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="NkRueckmeldungFVDatenImportType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>NkRueckmeldungFVDatenImport</title>
+ </xs:appinfo>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen zu einer Rückmeldung eines Datenimports.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="xdomea:NkFVDatenType">
+ <xs:sequence>
+ <xs:element name="FVSessionID" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die FV-Session-ID wird verwendet, um den Benutzer bzw. die Rolle aus dem DMS gegenüber dem Fachverfahren zu authentifizieren. Sie wird bei der Anmeldung im Fachverfahren erzeugt und wird nach einer konfigurierbaren Zeit der Inaktivität ungültig.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="ProtokolleintragZumErstellenType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>ProtokolleintragZumErstellen</title>
+ </xs:appinfo>
+ <xs:documentation>ProtokolleintragZumErstellen enthält Informationen zu einem Protokolleintrag i. S. eines Funktionsprotokolls, der zu einem Schriftgutobjekt erstellt wird. Wird die Nachricht im Stapelbetrieb übergeben, so erfolgt hier zusätzlich die Übergabe der Nummer im Stapel zu jedem angegebenen Protokolleintrag.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="NummerImStapel" minOccurs="0" type="xs:unsignedInt">
+ <xs:annotation>
+ <xs:documentation>Die Nummer des übergebenen Elements im Stapel. Anhand dieser Nummer können im Rückmeldestapel die Rückmeldungen den einzelnen Elementen im Stapel zugeordnet werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="IDSGO" type="xdomea:stringUUIDType">
+ <xs:annotation>
+ <xs:documentation>Die ID des Schriftgutobjekts im DMS, zu dem ein Protokolleintrag erstellt werden soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Protokolleintrag" type="xdomea:BearbeitungFVType">
+ <xs:annotation>
+ <xs:documentation>Der Protokolleintrag zu dem Schriftgutobjekt.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="RueckgabeparameterFVDatenType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>RueckgabeparameterFVDaten</title>
+ </xs:appinfo>
+ <xs:documentation>Die Rückmeldung des DMS zu den gelieferten Daten des Fachverfahrens.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="NummerImStapel" minOccurs="0" type="xs:unsignedInt">
+ <xs:annotation>
+ <xs:documentation>Die Nummer des übergebenen Elements im Stapel. Anhand dieser Nummer können im Rückmeldestapel die Rückmeldungen den einzelnen Elementen im Stapel zugeordnet werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="IDSGO" minOccurs="0" type="xdomea:stringUUIDType">
+ <xs:annotation>
+ <xs:documentation>Die ID des Schriftgutobjekts im DMS, zu dem die Rückmeldung erfolgt.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Parameter">
+ <xs:annotation>
+ <xs:documentation>Die Informationen zum Parameterwert.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:choice>
+ <xs:element name="AllgemeinerRueckgabeparameter" type="xdomea:FeldType">
+ <xs:annotation>
+ <xs:documentation>Es handelt sich bei dem Wert um einen allgemeinen, nicht näher im Standard definierten Rückgabeparameterwert.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="ZumLoeschenMarkiert" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>Es handelt sich bei dem Wert um eine Löschmarkierung. Wurde ein Objekt zum Löschen markiert, so wird der Wert 1 angegeben. Wurde kein Objekt zum Löschen markiert, so wird der Wert 0 angegeben.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Vertretungsstatus"
+ maxOccurs="unbounded"
+ type="xdomea:RueckgabeparameterVertretungsstatusType">
+ <xs:annotation>
+ <xs:documentation>Es handelt sich bei dem Wert um Angaben zu einem Vertretungsstatus.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Ablageort" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Ablageort des Schriftgutobjekts</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:choice>
+ </xs:complexType>
+ </xs:element>
+ <xs:element name="Erfolgreich" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>Die Kennzeichnung des erfolgreichen oder nicht erfolgreichen Imports eines Datenelements. Der erfolgreiche Import wird mit 1 und der nicht erfolgreiche Import mit 0 gekennzeichnet.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Rueckmeldung" minOccurs="0" maxOccurs="unbounded">
+ <xs:annotation>
+ <xs:documentation>Die Rückmeldung enthält weiterführende Informationen zu dem Import eines Datenelements, z.B. eine spezifische Fehlermeldung.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:choice>
+ <xs:element name="SpezifischeFehlermeldung0601"
+ type="xdomea:SpezifischeFehlermeldung0601CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0601.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0602"
+ type="xdomea:SpezifischeFehlermeldung0602CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0602.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0603"
+ type="xdomea:SpezifischeFehlermeldung0603CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0603.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0604"
+ type="xdomea:SpezifischeFehlermeldung0604CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0604.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0605"
+ type="xdomea:SpezifischeFehlermeldung0605CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0605.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0606"
+ type="xdomea:SpezifischeFehlermeldung0606CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0606.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0607"
+ type="xdomea:SpezifischeFehlermeldung0607CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0607.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0608"
+ type="xdomea:SpezifischeFehlermeldung0608CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0608.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0609"
+ type="xdomea:SpezifischeFehlermeldung0609CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0609.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0610"
+ type="xdomea:SpezifischeFehlermeldung0610CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0610.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0611"
+ type="xdomea:SpezifischeFehlermeldung0611CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0611.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0612"
+ type="xdomea:SpezifischeFehlermeldung0612CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0612.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0613"
+ type="xdomea:SpezifischeFehlermeldung0613CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0613.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0614"
+ type="xdomea:SpezifischeFehlermeldung0614CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0614.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0615"
+ type="xdomea:SpezifischeFehlermeldung0615CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0615.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0616"
+ type="xdomea:SpezifischeFehlermeldung0616CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0616.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0617"
+ type="xdomea:SpezifischeFehlermeldung0617CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0617.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0618"
+ type="xdomea:SpezifischeFehlermeldung0618CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0618.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0619"
+ type="xdomea:SpezifischeFehlermeldung0619CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0619.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0620"
+ type="xdomea:SpezifischeFehlermeldung0620CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0620.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0621"
+ type="xdomea:SpezifischeFehlermeldung0621CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0621.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0622"
+ type="xdomea:SpezifischeFehlermeldung0622CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0622.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0623"
+ type="xdomea:SpezifischeFehlermeldung0623CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0623.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0624"
+ type="xdomea:SpezifischeFehlermeldung0624CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0624.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0625"
+ type="xdomea:SpezifischeFehlermeldung0625CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0625.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0626"
+ type="xdomea:SpezifischeFehlermeldung0626CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0626.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0627"
+ type="xdomea:SpezifischeFehlermeldung0627CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0627.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0628"
+ type="xdomea:SpezifischeFehlermeldung0628CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0628.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0631"
+ type="xdomea:SpezifischeFehlermeldung0631CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0631.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SpezifischeFehlermeldung0632"
+ type="xdomea:SpezifischeFehlermeldung0632CodeType">
+ <xs:annotation>
+ <xs:documentation>Eine spezifische Fehlermeldung für die Nachricht 0632.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SonstigeFehlermeldung" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Eine sonstige, nicht näher definierte Fehlermeldung, die als Freitext formuliert werden kann.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="SonstigeFehlermeldungCode"
+ type="xdomea:SonstigeFehlermeldungCodeType">
+ <xs:annotation>
+ <xs:documentation>Eine sonstige, nicht näher in xdomea definierte Fehlermeldung, die als Code angegeben werden kann.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:choice>
+ </xs:complexType>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="RueckgabeparameterVertretungsstatusType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>RueckgabeparameterVertretungsstatus</title>
+ </xs:appinfo>
+ <xs:documentation>Informationen, die Angaben eines Rückgabeparameters zu einem Vertretungsstatus näher beschreiben.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="BenutzerOderRolle" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Benutzer oder die Rolle, für den/die der Vertretungsstatus abgefragt wird.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="VertretungAktiv" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>Der Status zur Vertretung, der abgefragt wird. Für aktive Vertretungen ist der Wert 1 anzugeben, für inaktive der Wert 0.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="SchriftgutobjektZumAblegenOderErstellenType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>SchriftgutobjektZumAblegenOderErstellen</title>
+ </xs:appinfo>
+ <xs:documentation>SchriftgutobjektZumAblegenOderErstellen enthält Informationen zu einem Schriftgutobjekt, das in einem Fachverfahren erstellt wurde und im empfangenden DMS abgelegt oder erstellt werden soll. Wird die Nachricht im Stapelbetrieb übergeben, so erfolgt hier zusätzlich die Übergabe der Nummer im Stapel zu jedem angegebenen Schriftgutobjekt.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="NummerImStapel" minOccurs="0" type="xs:unsignedInt">
+ <xs:annotation>
+ <xs:documentation>Die Nummer des übergebenen Elements im Stapel. Anhand dieser Nummer können im Rückmeldestapel die Rückmeldungen den einzelnen Elementen im Stapel zugeordnet werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="FachverfahrenObjektID" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die ID des Schriftgutobjektes im Fachverfahren.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="IDContainer" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die ID des übergeordneten Schriftgutobjekts, in dem das Schriftgutobjekt erstellt werden soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Schriftgutobjekt">
+ <xs:annotation>
+ <xs:documentation>Das Schriftgutobjekt, das abgelegt oder erstellt werden soll.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:choice>
+ <xs:element name="Akte" type="xdomea:AkteType">
+ <xs:annotation>
+ <xs:documentation>Eine Akte.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Vorgang" type="xdomea:VorgangType">
+ <xs:annotation>
+ <xs:documentation>Ein Vorgang.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Dokument" type="xdomea:DokumentType">
+ <xs:annotation>
+ <xs:documentation>Ein Dokument.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:choice>
+ </xs:complexType>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="SchriftgutobjektZumAblegenType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>SchriftgutobjektZumAblegen</title>
+ </xs:appinfo>
+ <xs:documentation>SchriftgutobjektZumAblegen enthält Informationen zu einem Schriftgutobjekt, das in einem Fachverfahren erstellt wurde und im empfangenden DMS abgelegt werden soll.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="xdomea:SchriftgutobjektZumAblegenOderErstellenType">
+ <xs:sequence>
+ <xs:element name="Ablageort" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Sollte als Austauschart nicht Datenbank oder XML-Datenstrom angegeben sein, so muss für den Ablageort zwingend ein Wert angegeben werden.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Der Ablageort des Schriftgutobjekts, das im DMS abgelegt werden soll. Die Primärdokumente zu Dokumenten finden sich in Dateien, die durch Primaerdokument.Dateiname spezifiziert werden. In Abhängigkeit des Konfigurationsparameters Datenaustauschart kann dieser Parameter unterschiedliche Werte annehmen: Übergabe über ein freigegebenes Verzeichnis: Name des Verzeichnisses. Übergabe per WebDAV und http(s): URL. Übergabe über eine Datenbank: der Parameter bleibt leer (bzw. wird ignoriert).</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SchriftgutobjektZumAnsehenOderBearbeitenType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>SchriftgutobjektZumAnsehenOderBearbeiten</title>
+ </xs:appinfo>
+ <xs:documentation>SchriftgutobjektZumAnsehenOderBearbeiten enthält Informationen zu einem Schriftgutobjekt, das in einem Fachverfahren erstellt wurde und im empfangenden DMS angesehen oder bearbeitet werden soll.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="IDSGO" type="xdomea:stringUUIDType">
+ <xs:annotation>
+ <xs:documentation>Die ID des Schriftgutobjekts im DMS, das angesehen oder bearbeitet werden soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Versionsnummer" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Die Versionsnummer kann nur für Dokumente angegeben werden - für Akte und Vorgang ist dies nicht möglich.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die Versionsnummer des Dokuments.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Client" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Neben der Benennung des Clients z.B. über eine IP-Adresse können auch Daten zur Identifizierung von Terminalserversitzungen angegeben werden.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Der Client, auf dem das Schriftgutobjekt zu öffnen ist.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="SchriftgutobjektZumDruckenType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>SchriftgutobjektZumDrucken</title>
+ </xs:appinfo>
+ <xs:documentation>SchriftgutobjektZumDrucken enthält Informationen zu einem Schriftgutobjekt, das in einem Fachverfahren erstellt wurde und gedruckt werden soll. Wird die Nachricht im Stapelbetrieb übergeben, so erfolgt hier zusätzlich die Übergabe der Nummer im Stapel zu jedem angegebenen Schriftgutobjekt.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="NummerImStapel" minOccurs="0" type="xs:unsignedInt">
+ <xs:annotation>
+ <xs:documentation>Die Nummer des übergebenen Elements im Stapel. Anhand dieser Nummer können im Rückmeldestapel die Rückmeldungen den einzelnen Elementen im Stapel zugeordnet werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="IDSGO" type="xdomea:stringUUIDType">
+ <xs:annotation>
+ <xs:documentation>Die ID des Schriftgutobjekts im DMS, das gedruckt werden soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Drucker" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Name des Druckers. Wird kein Druckername angegeben, so wird der Druck auf dem Standarddrucker des Clients ausgegeben.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="MetadatenDrucken" type="xs:boolean">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Für die Umsetzung in den Systemen wird empfohlen, sofern kein anderer Wert hinterlegt wurde, als Standardwert den Wert 0 für "keine Metadaten drucken" anzugeben.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>MetadatenDrucken legt fest, ob zu einem Schriftgutobjekt auch die Metadaten ausgedruckt werden sollen. Soll auch ein Druck der Metadaten zu Schriftgutobjekten stattfinden, so ist der Wert 1 anzugeben. Soll kein Druck der Metadaten zu Schriftgutobjekten stattfinden, so ist der Wert 0 anzugeben.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="PrimaerdokumentDrucken" type="xs:boolean">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Für die Umsetzung in den Systemen wird empfohlen, sofern kein anderer Wert hinterlegt wurde, als Standardwert den Wert 0 für "kein Primärdokument drucken" anzugeben.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>PrimaerdokumentDrucken legt fest, ob die Primärdokumente zu dem Schriftgutobjekt gedruckt werden. Sollen die Primärdokumente zu dem Schriftgutobjekt gedruckt werden, so ist der Wert 1 anzugeben. Soll kein Druck der Primärdokumente zum Schriftgutobjekt stattfinden, so ist der Wert 0 anzugeben.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="UnterSGODrucken" type="xs:boolean">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Für die Umsetzung in den Systemen wird empfohlen, sofern kein anderer Wert hinterlegt wurde, als Standardwert den Wert 0 für "kein untergeordnetes Schriftgutobjekt drucken" anzugeben.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>UnterSGODrucken legt fest, ob sich innerhalb des übergegebenen Schriftgutobjekts befindliche Schriftgutobjekte gedruckt werden sollen, z.B. eine Akte mit ihren Vorgängen und Dokumenten. Sollen die untergeordneten Schriftgutobjekte gedruckt werden, so ist der Wert 1 anzugeben. Soll kein Druck der untergeordneten Schriftgutobjekte erfolgen, so ist der Wert 0 anzugeben.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="UnterSGOTyp"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xs:string">
+ <xs:annotation>
+ <xs:documentation>UnterSGOTyp legt fest, dass nur die Schriftgutobjekte eines angegebenen Typs gedruckt werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Versionsnummer" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Die Versionsnummer kann nur für Dokumente angegeben werden - für Akte und Vorgang ist dies nicht möglich.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die Versionsnummer des Dokuments.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Client" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Neben der Benennung des Clients z.B. über eine IP-Adresse können auch Daten zur Identifizierung von Terminalserversitzungen angegeben werden.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Der Client, von dem aus das Schriftgutobjekt gedruckt wird.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="SchriftgutobjektZumErstellenType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>SchriftgutobjektZumErstellen</title>
+ </xs:appinfo>
+ <xs:documentation>SchriftgutobjektZumErstellen enthält Informationen zu einem Schriftgutobjekt, das in einem Fachverfahren erzeugt wurde und im empfangenden DMS erstellt werden soll.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="xdomea:SchriftgutobjektZumAblegenOderErstellenType">
+ <xs:sequence>
+ <xs:element name="SGOOeffnen" minOccurs="0" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>SGOOeffnen legt fest, ob das Schriftgutobjekt nach der Erstellung in dem DMS mit einer externen Applikation oder mit dem DMS z.B. zur weiteren Bearbeitung geöffnet werden soll. Soll das Schriftgutobjekt geöffnet werden, so ist der Wert 1 anzugeben. Soll das Schriftgutobjekt nicht geöffnet werden, so ist der Wert 0 anzugeben.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Client" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Das Schriftgutobjekt wird auf dem spezifizierten Client geöffnet, wenn der Client angegeben ist und der Parameter "SGOOeffnen" positiv belegt ist. Neben der Benennung des Clients z.B. über eine IP-Adresse können auch Daten zur Identifizierung von Terminalserversitzungen angegeben werden.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Der Client, auf dem das Schriftgutobjekt zu öffnen ist.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="SchriftgutobjektZumLoeschenType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>SchriftgutobjektZumLoeschen</title>
+ </xs:appinfo>
+ <xs:documentation>SchriftgutobjektZumLoeschen enthält Informationen zu einem Schriftgutobjekt, das im DMS gelöscht bzw. dessen Löschmarkierung aufgehoben werden soll. Wird die Nachricht im Stapelbetrieb übergeben, so erfolgt hier zusätzlich die Übergabe der Nummer im Stapel zu jedem angegebenen Schriftgutobjekt.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="NummerImStapel" minOccurs="0" type="xs:unsignedInt">
+ <xs:annotation>
+ <xs:documentation>Die Nummer des übergebenen Elements im Stapel. Anhand dieser Nummer können im Rückmeldestapel die Rückmeldungen den einzelnen Elementen im Stapel zugeordnet werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="IDSGO" type="xdomea:stringUUIDType">
+ <xs:annotation>
+ <xs:documentation>Die ID des Schriftgutobjekts im DMS.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="SchriftgutobjektZumLoeschstatusAbfragenType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>SchriftgutobjektZumLoeschstatusAbfragen</title>
+ </xs:appinfo>
+ <xs:documentation>SchriftgutobjektZumLoeschStatusAbfragen enthält Informationen zu einem Schriftgutobjekt, dessen Löschstatus im DMS abgefragt werden soll.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="NummerImStapel" minOccurs="0" type="xs:unsignedInt">
+ <xs:annotation>
+ <xs:documentation>Die Nummer des übergebenen Elements im Stapel. Anhand dieser Nummer können im Rückmeldestapel die Rückmeldungen den einzelnen Elementen im Stapel zugeordnet werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="IDSGO" type="xdomea:stringUUIDType">
+ <xs:annotation>
+ <xs:documentation>Die ID des Schriftgutobjekts im DMS, dessen Löschtstatus abgefragt werden soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="SchriftgutobjektZumSuchenType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>SchriftgutobjektZumSuchen</title>
+ </xs:appinfo>
+ <xs:documentation>SchriftgutobjektZumSuchen enthält Informationen zur Suche nach Schriftgutobjekten im DMS.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Suchbegriffe" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Suchbegriffe sind Kriterien, mit deren Hilfe im DMS nach Schriftgutobjekten gesucht wird. Sie werden über eine UND-Verknüpfung ausgewertet.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Volltext" type="xs:boolean">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Für die Umsetzung in den Systemen wird empfohlen, sofern kein anderer Wert hinterlegt wurde, als Standardwert den Wert 1 für "Volltextsuche durchführen" anzugeben.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Volltext legt fest, ob die Suche auch in den Primärdokumenten der Schriftgutobjekte durchgeführt werden soll. Soll die Suche auch in den Primärdokumenten durchgeführt werden, so ist der Wert 1 anzugeben. Soll eine solche Suche in den Primärdokumenten nicht erfolgen, so ist der Wert 0 anzugeben.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Metadaten" type="xs:boolean">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Für die Umsetzung in den Systemen wird empfohlen, sofern kein anderer Wert hinterlegt wurde, als Standardwert den Wert 1 für "Metadaten durchsuchen" anzugeben.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Metadaten legt fest, ob die Suche auch in den Metadaten der Schriftgutobjekte durchgeführt werden soll. Soll eine Suche auch in den Metadaten der Schriftgutobjekte stattfinden, so ist der Wert 1 anzugeben. Soll keine Suche in den Metadaten der Schriftgutobjekte stattfinden, so ist der Wert 0 anzugeben.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="SchriftgutobjektZumZDAAufhebenType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>SchriftgutobjektZumZDAAufheben</title>
+ </xs:appinfo>
+ <xs:documentation>SGOZumZDAAufheben enthält Informationen zu einem Schriftgutobjekt, dessen Daten im empfangenden System wiederaufleben sollen. Wird die Nachricht im Stapelbetrieb übergeben, so erfolgt hier zusätzlich die Übergabe der Nummer im Stapel zu jedem angegebenen Schriftgutobjekt.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="NummerImStapel" minOccurs="0" type="xs:unsignedInt">
+ <xs:annotation>
+ <xs:documentation>Die Nummer des übergebenen Elements im Stapel. Anhand dieser Nummer können im Rückmeldestapel die Rückmeldungen den einzelnen Elementen im Stapel zugeordnet werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="IDSGO" type="xdomea:stringUUIDType">
+ <xs:annotation>
+ <xs:documentation>Die ID des Schriftgutobjektes, dessen zdA-Verfügung aufgehoben werden soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="SchriftgutobjektZumZDAVerfuegenType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>SchriftgutobjektZumZDAVerfuegen</title>
+ </xs:appinfo>
+ <xs:documentation>SchriftgutobjektZumZDAVerfuegen enthält Informationen zu einem Schriftgutobjekt, das im DMS zdA-verfügt werden soll. Wird die Nachricht im Stapelbetrieb übergeben, so erfolgt hier zusätzlich die Übergabe der Nummer im Stapel zu jedem angegebenen Schriftgutobjekt.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="NummerImStapel" minOccurs="0" type="xs:unsignedInt">
+ <xs:annotation>
+ <xs:documentation>Die Nummer des übergebenen Elements im Stapel. Anhand dieser Nummer können im Rückmeldestapel die Rückmeldungen den einzelnen Elementen im Stapel zugeordnet werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="IDSGO" type="xdomea:stringUUIDType">
+ <xs:annotation>
+ <xs:documentation>Die ID des Schriftgutobjekts im DMS, das zdA-verfügt werden soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="StandardablageType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Standardablage</title>
+ </xs:appinfo>
+ <xs:documentation>Standardablage beschreibt Informationen, an denen routinemäßig für einen bestimmten Benutzer oder eine bestimmte Rolle Daten abgelegt werden.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Ablageort" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Standard-Ablageort. In Abhängigkeit des Konfigurationsparameters Datenaustauschart kann dieser Parameter unterschiedliche Werte annehmen: Übergabe über ein freigegebenes Verzeichnis: Name des Verzeichnisses. Übergabe per WebDAV und http(s): URL. Übergabe über eine Datenbank: der Parameter bleibt leer (bzw. wird ignoriert).</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="BenutzerOderRolle" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Benutzer oder die Rolle, dem/der der Ablageort zugewiesen wird.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="SystemstatusZumAbfragenType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>SystemstatusZumAbfragen</title>
+ </xs:appinfo>
+ <xs:documentation>SystemstatusZumAbfragen enthält Informationen zu einer Statusabfrage des empfangenden Systems.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="SystemstatusID" type="xs:integer">
+ <xs:annotation>
+ <xs:documentation>Die ID der Systemstatus-Information, die abgefragt werden soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="VertretungZumAktivierenOderDeaktivierenType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>VertretungZumAktivierenOderDeaktivieren</title>
+ </xs:appinfo>
+ <xs:documentation>VertretungZumAktivierenOderDeaktivieren enthält Informationen zu einer Vertretung, die aktiviert oder deaktiviert werden soll.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="ZuVertretender" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Benutzer oder die Rolle, für den/die die Vertretung aktiviert bzw. deaktiviert werden soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Vertreter" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Benutzer oder die Rolle, der/die die Vertretung übernehmen bzw. wieder abgeben soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Aktivieren" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>Aktivieren bestimmt, ob eine Vertretung aktiviert oder deaktiviert werden soll. Hat Aktivieren den Wert 1, so wird die Vertretung aktiviert. Hat Aktivieren den Wert 0, so wird die Vertretung deaktiviert.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="VertretungsstatusZumAbfragenType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>VertretungsstatusZumAbfragen</title>
+ </xs:appinfo>
+ <xs:documentation>VertretungsstatusZumAbfragen enthält Informationen zur Abfrage des Vertretungsstatus eines Benutzers oder einer Rolle.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="BenutzerOderRolle" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Benutzer oder die Rolle, für den/die der Vertretungsstatus abgefragt wird.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="ZustaendigkeitZumAendernType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>ZustaendigkeitZumAendern</title>
+ </xs:appinfo>
+ <xs:documentation>ZustaendigkeitZumAendern enthält Informationen zur Zuständigkeitsänderung eines Schriftgutobjekts. Wird die Nachricht im Stapelbetrieb übergeben, so erfolgt hier zusätzlich die Übergabe der Nummer im Stapel zu jedem angegebenen Schriftgutobjekt.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="NummerImStapel" minOccurs="0" type="xs:unsignedInt">
+ <xs:annotation>
+ <xs:documentation>Die Nummer des übergebenen Elements im Stapel. Anhand dieser Nummer können im Rückmeldestapel die Rückmeldungen den einzelnen Elementen im Stapel zugeordnet werden.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="IDSGO" type="xdomea:stringUUIDType">
+ <xs:annotation>
+ <xs:documentation>Die ID des Schriftgutobjekts im DMS, für das die Zuständigkeit angepasst werden soll.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="JetztZustaendig" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Benutzer oder die Rolle, welcher/welche nach der Zuständigkeitsänderung für das Schriftgutobjekt zuständig ist.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="BisherZustaendig" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Der Benutzer oder die Rolle, welcher/welche bisher für das Schriftgutobjekt zuständig war.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="AufnehmendAktenplaneinheitKennzeichen"
+ minOccurs="0"
+ type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Das Kennzeichen des übergeordneten Schriftgutobjekts, zu dem das von der Zuständigkeitsänderung betroffene Schriftgutobjekt nach der Änderung gehört.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="AufnehmendID" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die ID des übergeordneten Schriftgutobjekts, zu dem das Schriftgutobjekt nach der Zuständigkeitsänderung gehört.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="AbgebendAktenplaneinheitKennzeichen"
+ minOccurs="0"
+ type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Das Kennzeichen des übergeordneten Schriftgutobjekts, zu dem das von der Zuständigkeitsänderung betroffene Schriftgutobjekt vor der Änderung gehörte.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="AbgebendID" minOccurs="0" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die ID des übergeordneten Schriftgutobjekts, zu dem das Schriftgutobjekt vor der Zuständigkeitsänderung gehörte.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Metadatum"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:FeldType">
+ <xs:annotation>
+ <xs:documentation>Ein im Rahmen der Zuständigkeitsänderung angepasstes Metadatum zu dem Schriftgutobjekt.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+</xs:schema>
diff --git a/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Typen-GeschaeftsgangDurchfuehren.xsd b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Typen-GeschaeftsgangDurchfuehren.xsd
new file mode 100644
index 0000000000000000000000000000000000000000..fd1061cd1022fdfd11e1006b365c6f9ce0b90657
--- /dev/null
+++ b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Typen-GeschaeftsgangDurchfuehren.xsd
@@ -0,0 +1,133 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+ xmlns:xdomea="urn:xoev-de:xdomea:schema:3.0.0"
+ targetNamespace="urn:xoev-de:xdomea:schema:3.0.0"
+ version="3.0.0"
+ elementFormDefault="qualified"
+ attributeFormDefault="unqualified">
+ <xs:annotation>
+ <xs:appinfo>
+ <standard>
+ <nameLang>xdomea - XÖV-Standard für den IT-gestützten Austausch und die IT-gestützte Aussonderung behördlichen Schriftgutes</nameLang>
+ <nameKurz>xdomea</nameKurz>
+ <nameTechnisch>xdomea</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:kosit:standard:xdomea</kennung>
+ <beschreibung>xdomea ist der vom IT-Planungsrat verabschiedete verbindliche Standard für den Austausch von Akten, Vorgängen und Dokumenten im Kontext der Übermittlung, der Abgabe sowie der Aussonderung von Schriftgutobjekten (www.it-planungsrat.de, Beschluss 2017/39). Weiterhin kann xdomea für den Austausch zwischen Fachverfahren und DMS/VBS sowie für die Zwischenarchivierung genutzt werden.
+
+Um diese Anwendungsszenarien bestmöglich zu unterstützen, ist xdomea gemäß des XÖV-Rahmenwerkes nach dem Baukastenprinzip aufgebaut und bietet einzelne Nachrichten(gruppen) für die jeweiligen Prozesse an.
+
+Der Standard xdomea wird von der gleichnamigen Arbeitsgruppe des IT-Planungsrates weiterentwickelt und gepflegt. Der Betrieb des Standards erfolgt durch die Koordinierungsstelle für IT-Standards (KoSIT).
+</beschreibung>
+ </standard>
+ <versionStandard>
+ <version>3.0.0</version>
+ <beschreibung>Die Version 3.0.0 ist durch den IT-Planungsrat beschlossen. Details zum Beschluss sowie zu den Fristen der Umsetzung sind der Veröffentlichung im Bundesanzeiger unter www.bundesanzeiger.de zu entnehmen.</beschreibung>
+ <versionXOEVProfil>1.7.2</versionXOEVProfil>
+ <versionXOEVHandbuch>2.3.1</versionXOEVHandbuch>
+ <versionXGenerator>3.0.1</versionXGenerator>
+ <versionModellierungswerkzeug>19.0</versionModellierungswerkzeug>
+ <nameModellierungswerkzeug>MagicDraw</nameModellierungswerkzeug>
+ </versionStandard>
+ </xs:appinfo>
+ </xs:annotation>
+ <xs:include schemaLocation="xdomea-Baukasten.xsd"/>
+ <xs:complexType name="GeaenderterBeteiligungsschrittType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>GeaenderterBeteiligungsschritt</title>
+ </xs:appinfo>
+ <xs:documentation>Informationen zu einem geänderten Beteiligungsschritt eines Geschäftsgangs. Geändert kann in diesem Zusammenhang neu erstellt bzw. übersprungen heißen.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Nummer" type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Nummer des Beteiligungsschrittes innerhalb der fortlaufenden Nummerierung im Geschäftsgang. Die Nummerierung ist innerhalb eines xdomea-Geschäftsgangsobjekts eindeutig. Werden in den xdomea-Geschäftsgang neue Bearbeitungsschritte eingefügt, werden dementsprechend die Nummern der nachfolgenden Beteiligungsschritte verändert. Beteiligungsschritte, die abgeschlossen sind, sind unveränderlich.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Aenderungsart">
+ <xs:annotation>
+ <xs:documentation>Die Änderungsart eines Beteiligungsschrittes.</xs:documentation>
+ </xs:annotation>
+ <xs:complexType>
+ <xs:choice>
+ <xs:element name="Neu" fixed="1" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>Der Beteiligungsschritt wurde dem Laufweg eines Geschäftsgangs neu hinzugefügt.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Uebersprungen" fixed="1" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>Der Beteiligungsschritt wird in dem Laufweg als übersprungen markiert, d.h. der Schritt bleibt im Geschäftsgang erhalten, wird jedoch nicht mehr aktiv beteiligt.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:choice>
+ </xs:complexType>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="HauptobjektType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>Hauptobjekt</title>
+ <implementationHint>Akten oder Vorgänge sind als Element im Hauptobjekt nicht erlaubt.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Ein Container für die Dokumente, auf die sich die Beteiligungsschritte im externen Geschäftsgang beziehen.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="Dokument" maxOccurs="unbounded" type="xdomea:DokumentType">
+ <xs:annotation>
+ <xs:documentation>Ein in der Geschäftsgangs-Nachricht enthaltenes Dokument, auf das sich die Verfügungen im externen Geschäftsgang beziehen.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="NkGeschaeftsgangType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>NkGeschaeftsgang</title>
+ </xs:appinfo>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger einer Nachricht, bei der es sich um einen Geschäftsgang handelt.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="xdomea:NkBasisType">
+ <xs:sequence>
+ <xs:element name="EmpfangsbestaetigungAnInitiator" type="xs:boolean">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Für die Umsetzung in den Systemen wird empfohlen, sofern kein anderer Wert hinterlegt wurde, als Standardwert den Wert 0 für "keine Empfangsbestätigung senden" anzugeben.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die Angabe, ob vom Empfänger der Nachricht eine Empfangsbestätigung für den Initiator des Geschäftsgangs erwünscht wird. Eine erwünschte Empfangsbestätigung wird mit 1 gekennzeichnet. Wird keine Empfangsbestätigung gewünscht, so wird dies mit 0 gekennzeichnet.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="EmpfangsbestaetigungAnVorgaenger" type="xs:boolean">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Für die Umsetzung in den Systemen wird empfohlen, sofern kein anderer Wert hinterlegt wurde, als Standardwert den Wert 0 für "keine Empfangsbestätigung senden" anzugeben.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die Angabe, ob vom Empfänger der Nachricht eine Empfangsbestätigung für den Absender der Nachricht erwünscht wird. Eine erwünschte Empfangsbestätigung wird mit 1 gekennzeichnet. Wird keine Empfangsbestätigung gewünscht, so wird dies mit 0 gekennzeichnet.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+ <xs:complexType name="NkRueckmeldungGeschaeftsgangType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>NkRueckmeldungGeschaeftsgang</title>
+ </xs:appinfo>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger der Empfangs-/Importnachricht zu einer in Beziehung stehenden Nachricht, die durch den Empfänger versendet wurde und sich auf einen Geschäftsgang bezieht.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="xdomea:NkBasisType">
+ <xs:sequence>
+ <xs:element name="WeitererEmpfaenger" minOccurs="0" type="xdomea:KontaktType">
+ <xs:annotation>
+ <xs:documentation>Der weitere Empfänger der Nachricht.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+</xs:schema>
diff --git a/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Typen-ZwischenarchivierungDurchfuehren.xsd b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Typen-ZwischenarchivierungDurchfuehren.xsd
new file mode 100644
index 0000000000000000000000000000000000000000..6795daa0473e4f35f553446de65fd93d452a31ab
--- /dev/null
+++ b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea-Typen-ZwischenarchivierungDurchfuehren.xsd
@@ -0,0 +1,97 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+ xmlns:xdomea="urn:xoev-de:xdomea:schema:3.0.0"
+ targetNamespace="urn:xoev-de:xdomea:schema:3.0.0"
+ version="3.0.0"
+ elementFormDefault="qualified"
+ attributeFormDefault="unqualified">
+ <xs:annotation>
+ <xs:appinfo>
+ <standard>
+ <nameLang>xdomea - XÖV-Standard für den IT-gestützten Austausch und die IT-gestützte Aussonderung behördlichen Schriftgutes</nameLang>
+ <nameKurz>xdomea</nameKurz>
+ <nameTechnisch>xdomea</nameTechnisch>
+ <kennung>urn:xoev-de:xdomea:kosit:standard:xdomea</kennung>
+ <beschreibung>xdomea ist der vom IT-Planungsrat verabschiedete verbindliche Standard für den Austausch von Akten, Vorgängen und Dokumenten im Kontext der Übermittlung, der Abgabe sowie der Aussonderung von Schriftgutobjekten (www.it-planungsrat.de, Beschluss 2017/39). Weiterhin kann xdomea für den Austausch zwischen Fachverfahren und DMS/VBS sowie für die Zwischenarchivierung genutzt werden.
+
+Um diese Anwendungsszenarien bestmöglich zu unterstützen, ist xdomea gemäß des XÖV-Rahmenwerkes nach dem Baukastenprinzip aufgebaut und bietet einzelne Nachrichten(gruppen) für die jeweiligen Prozesse an.
+
+Der Standard xdomea wird von der gleichnamigen Arbeitsgruppe des IT-Planungsrates weiterentwickelt und gepflegt. Der Betrieb des Standards erfolgt durch die Koordinierungsstelle für IT-Standards (KoSIT).
+</beschreibung>
+ </standard>
+ <versionStandard>
+ <version>3.0.0</version>
+ <beschreibung>Die Version 3.0.0 ist durch den IT-Planungsrat beschlossen. Details zum Beschluss sowie zu den Fristen der Umsetzung sind der Veröffentlichung im Bundesanzeiger unter www.bundesanzeiger.de zu entnehmen.</beschreibung>
+ <versionXOEVProfil>1.7.2</versionXOEVProfil>
+ <versionXOEVHandbuch>2.3.1</versionXOEVHandbuch>
+ <versionXGenerator>3.0.1</versionXGenerator>
+ <versionModellierungswerkzeug>19.0</versionModellierungswerkzeug>
+ <nameModellierungswerkzeug>MagicDraw</nameModellierungswerkzeug>
+ </versionStandard>
+ </xs:appinfo>
+ </xs:annotation>
+ <xs:include schemaLocation="xdomea-Baukasten.xsd"/>
+ <xs:complexType name="ErfolgOderMisserfolgZwischenarchivierungType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>ErfolgOderMisserfolgZwischenarchivierung</title>
+ </xs:appinfo>
+ <xs:documentation>Die Information zum erfolgreichen oder nicht erfolgreichen Import eines auszulagernden Schriftgutobjektes.</xs:documentation>
+ </xs:annotation>
+ <xs:sequence>
+ <xs:element name="IDSGO" type="xdomea:stringUUIDType">
+ <xs:annotation>
+ <xs:documentation>Die ID des Schriftgutobjekts, das ausgelagert werden sollte.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Erfolgreich" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>Die Kennzeichnung des erfolgreichen oder nicht erfolgreichen Imports zu einem auszulagernden Schriftgutobjekt. Der erfolgreiche Import wird mit 1 und der nicht erfolgreiche Import mit 0 gekennzeichnet.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Fehlermeldung"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xs:string">
+ <xs:annotation>
+ <xs:documentation>Die Information in Form eines Freitextes, aus welchem Grund der Import zum auszulagernden Schriftgutobjekt nicht erfolgreich war.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="FehlermeldungCode"
+ minOccurs="0"
+ maxOccurs="unbounded"
+ type="xdomea:SonstigeFehlermeldungCodeType">
+ <xs:annotation>
+ <xs:documentation>Die Information in Form eines Codes, aus welchem Grund der Import zum auszulagernden Schriftgutobjekt nicht erfolgreich war.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:complexType>
+ <xs:complexType name="NkZwischenarchivierungType">
+ <xs:annotation>
+ <xs:appinfo>
+ <title>NkAuslagerung</title>
+ </xs:appinfo>
+ <xs:documentation>Der Kopf der Nachricht enthält allgemeine Informationen für den Empfänger einer Nachricht, bei der es sich um eine Auslagerung handelt.</xs:documentation>
+ </xs:annotation>
+ <xs:complexContent>
+ <xs:extension base="xdomea:NkNichtFVDatenWeitereEmpfaengerType">
+ <xs:sequence>
+ <xs:element name="Importbestaetigung" fixed="1" type="xs:boolean">
+ <xs:annotation>
+ <xs:documentation>Die Angabe, dass eine Importbestätigung vom Empfänger der Nachricht erwünscht wird.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ <xs:element name="Empfangsbestaetigung" type="xs:boolean">
+ <xs:annotation>
+ <xs:appinfo>
+ <implementationHint>Für die Umsetzung in den Systemen wird empfohlen, sofern kein anderer Wert hinterlegt wurde, als Standardwert den Wert 0 für "keine Empfangsbestätigung senden" anzugeben.</implementationHint>
+ </xs:appinfo>
+ <xs:documentation>Die Angabe, ob vom Empfänger der Nachricht eine Empfangsbestätigung erwünscht wird. Eine erwünschte Empfangsbestätigung wird mit 1 gekennzeichnet. Wird keine Empfangsbestätigung gewünscht, so wird dies mit 0 gekennzeichnet.</xs:documentation>
+ </xs:annotation>
+ </xs:element>
+ </xs:sequence>
+ </xs:extension>
+ </xs:complexContent>
+ </xs:complexType>
+</xs:schema>
diff --git a/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea.xsd b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea.xsd
new file mode 100644
index 0000000000000000000000000000000000000000..79642b4d3e9408ec090a03553c981549909010fc
--- /dev/null
+++ b/alfa-xdomea/src/main/resources/xdomea_3-0-0_XML-Schemata/xdomea.xsd
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+ targetNamespace="urn:xoev-de:xdomea:schema:3.0.0"
+ version="3.0.0"
+ elementFormDefault="qualified"
+ attributeFormDefault="unqualified">
+ <xs:include schemaLocation="xdomea-Baukasten.xsd"/>
+ <xs:include schemaLocation="xdomea-Datentypen.xsd"/>
+ <xs:include schemaLocation="xdomea-Nachrichten-AbgabeDurchfuehren.xsd"/>
+ <xs:include schemaLocation="xdomea-Nachrichten-AktenplanAustauschen.xsd"/>
+ <xs:include schemaLocation="xdomea-Nachrichten-Archivsystem.xsd"/>
+ <xs:include schemaLocation="xdomea-Nachrichten-AussonderungDurchfuehren.xsd"/>
+ <xs:include schemaLocation="xdomea-Nachrichten-DMS.xsd"/>
+ <xs:include schemaLocation="xdomea-Nachrichten-Fachverfahren.xsd"/>
+ <xs:include schemaLocation="xdomea-Nachrichten-FachverfahrensdatenAustauschen.xsd"/>
+ <xs:include schemaLocation="xdomea-Nachrichten-GeschaeftsgangDurchfuehren.xsd"/>
+ <xs:include schemaLocation="xdomea-Nachrichten-InformationAustauschen.xsd"/>
+ <xs:include schemaLocation="xdomea-Nachrichten-VBS.xsd"/>
+ <xs:include schemaLocation="xdomea-Nachrichten-ZwischenarchivierungDurchfuehren.xsd"/>
+ <xs:include schemaLocation="xdomea-Nachrichten-Zwischenarchivsystem.xsd"/>
+ <xs:include schemaLocation="xdomea-Typen-AbgabeDurchfuehren.xsd"/>
+ <xs:include schemaLocation="xdomea-Typen-AussonderungDurchfuehren.xsd"/>
+ <xs:include schemaLocation="xdomea-Typen-FachverfahrensdatenAustauschen.xsd"/>
+ <xs:include schemaLocation="xdomea-Typen-GeschaeftsgangDurchfuehren.xsd"/>
+ <xs:include schemaLocation="xdomea-Typen-ZwischenarchivierungDurchfuehren.xsd"/>
+</xs:schema>
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/bescheid/BescheidExportDataTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/bescheid/BescheidExportDataTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..e731e4838f28f5056d77210640b33845c7f4ef1b
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/bescheid/BescheidExportDataTestFactory.java
@@ -0,0 +1,24 @@
+package de.ozgcloud.alfa.bescheid;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.ozgcloud.alfa.export.DokumentTypeTestFactory;
+import de.xoev.xdomea.DokumentType;
+
+public class BescheidExportDataTestFactory {
+
+ public static final DokumentType DOKUMENT_TYPE = DokumentTypeTestFactory.create();
+ public static final OzgFile ATTACHMENT = OzgFileTestFactory.createWithUniqueId();
+ public static final OzgFile DOCUMENT = OzgFileTestFactory.createWithUniqueId();
+
+ public static BescheidExportData create() {
+ return createBuilder().build();
+ }
+
+ public static BescheidExportData.BescheidExportDataBuilder createBuilder() {
+ return BescheidExportData.builder()
+ .dokumentType(DOKUMENT_TYPE)
+ .file(DOCUMENT)
+ .file(ATTACHMENT);
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/bescheid/BescheidExportInputTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/bescheid/BescheidExportInputTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..fbee5d69b45774fcfac881ab2f4550284704c447
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/bescheid/BescheidExportInputTestFactory.java
@@ -0,0 +1,26 @@
+package de.ozgcloud.alfa.bescheid;
+
+import java.util.List;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.ozgcloud.alfa.vorgang.ZustaendigeStelleTestFactory;
+
+public class BescheidExportInputTestFactory {
+
+ public final static Bescheid BESCHEID = BescheidTestFactory.create();
+ public final static String ORGANISATIONSEINHEITEN_ID = ZustaendigeStelleTestFactory.ORGANISATIONSEINHEITEN_ID;
+ public final static List<OzgFile> FILES = List.of(OzgFileTestFactory.createWithUniqueId());
+
+ public static BescheidExportInput create() {
+ return createBuilder().build();
+ }
+
+ public static BescheidExportInput.BescheidExportInputBuilder createBuilder() {
+ return BescheidExportInput.builder()
+ .bescheid(BESCHEID)
+ .organisationseinheitenId(ORGANISATIONSEINHEITEN_ID)
+ .files(FILES);
+ }
+
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/bescheid/DokumentTypeBuilderTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/bescheid/DokumentTypeBuilderTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..55e271e0050a302b0890245d0ca1bdc9f5adaa93
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/bescheid/DokumentTypeBuilderTest.java
@@ -0,0 +1,293 @@
+package de.ozgcloud.alfa.bescheid;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.List;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.Spy;
+
+import com.thedeanda.lorem.LoremIpsum;
+
+import de.ozgcloud.alfa.common.AnlageDokumentTypeBuilder;
+import de.ozgcloud.alfa.common.AnlageDokumentTypeTestFactory;
+import de.ozgcloud.alfa.common.DateConverter;
+import de.ozgcloud.alfa.common.HistorienProtokollInformationTypeTestFactory;
+import de.ozgcloud.alfa.common.IdentifikationObjektTypeBuilder;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.ozgcloud.alfa.common.user.UserProfileTestFactory;
+import de.ozgcloud.alfa.export.AllgemeineMetadatenTypeTestFactory;
+import de.ozgcloud.alfa.export.IdentifikationObjektTypeTestFactory;
+import de.ozgcloud.alfa.vorgang.ZustaendigeStelleTestFactory;
+import de.xoev.xdomea.AllgemeineMetadatenType;
+import de.xoev.xdomea.AnlageDokumentType;
+import de.xoev.xdomea.HistorienProtokollInformationType;
+import de.xoev.xdomea.IdentifikationObjektType;
+
+class DokumentTypeBuilderTest {
+ private final String fullName = UserProfileTestFactory.FULLNAME;
+ private final Bescheid bescheid = BescheidTestFactory.create();
+ private final OzgFile document = OzgFileTestFactory.createWithUniqueId();
+
+ @Spy
+ private final DokumentTypeBuilder builder = DokumentTypeBuilder.builder()
+ .withBescheid(bescheid)
+ .withOrganisationseinheitenId(ZustaendigeStelleTestFactory.ORGANISATIONSEINHEITEN_ID)
+ .withFullName(fullName)
+ .withFiles(List.of(document));
+
+ @Nested
+ class TestBuild {
+ private static final String TYP = "Bescheid";
+
+ private MockedStatic<IdentifikationObjektTypeBuilder> identifikationObjektTypeBuilderMockedStatic;
+ @Mock
+ private IdentifikationObjektTypeBuilder identifikationObjektTypeBuilder;
+ private final IdentifikationObjektType identifikationObjektType = IdentifikationObjektTypeTestFactory.create();
+
+ private final HistorienProtokollInformationType historienProtokollInformation = HistorienProtokollInformationTypeTestFactory.create();
+ private final AllgemeineMetadatenType metadatenType = AllgemeineMetadatenTypeTestFactory.create();
+ private final AnlageDokumentType anlageDokumentDocument = AnlageDokumentTypeTestFactory.create();
+
+ @BeforeEach
+ void setUp() {
+ identifikationObjektTypeBuilderMockedStatic = mockStatic(IdentifikationObjektTypeBuilder.class);
+ identifikationObjektTypeBuilderMockedStatic.when(IdentifikationObjektTypeBuilder::builder).thenReturn(identifikationObjektTypeBuilder);
+ when(identifikationObjektTypeBuilder.withObjectID(BescheidTestFactory.ID)).thenReturn(identifikationObjektTypeBuilder);
+ when(identifikationObjektTypeBuilder.build()).thenReturn(identifikationObjektType);
+ doReturn(anlageDokumentDocument).when(builder).createAnlage(document);
+ }
+
+ @AfterEach
+ void tearDown() {
+ identifikationObjektTypeBuilderMockedStatic.close();
+ }
+
+ @Test
+ void shouldSetObjectId() {
+ builder.build();
+
+ verify(identifikationObjektTypeBuilder).withObjectID(bescheid.getId());
+ }
+
+ @Test
+ void shouldBuildIdentifikationObjectType() {
+ builder.build();
+
+ verify(identifikationObjektTypeBuilder).build();
+ }
+
+ @Test
+ void shouldHaveIdentifikation() {
+ var dokument = builder.build();
+
+ assertThat(dokument.getIdentifikation()).isEqualTo(identifikationObjektType);
+ }
+
+ @Test
+ void shouldHaveTyp() {
+ var dokument = builder.build();
+
+ assertThat(dokument.getTyp()).isEqualTo(TYP);
+ }
+
+ @Test
+ void shouldHaveBezugWithBetreff() {
+ var subject = LoremIpsum.getInstance().getWords(5);
+ builder.withBescheid(BescheidTestFactory.createBuilder().nachrichtSubject(subject).build());
+
+ var dokument = builder.build();
+
+ assertThat(dokument.getBezug()).isEqualTo(subject);
+ }
+
+ @Test
+ void shouldHaveEmptyBezug() {
+ builder.withBescheid(BescheidTestFactory.createBuilder().nachrichtSubject(null).build());
+
+ var dokument = builder.build();
+
+ assertThat(dokument.getBezug()).isEmpty();
+ }
+
+ @Test
+ void shouldHaveMetadaten() {
+ doReturn(metadatenType).when(builder).createAllgemeineMetadaten();
+
+ var dokument = builder.build();
+
+ assertThat(dokument.getAllgemeineMetadaten()).isEqualTo(metadatenType);
+ }
+
+ @Test
+ void shouldHaveHistorienProtokollInformation() {
+ doReturn(historienProtokollInformation).when(builder).createHistorienProtokollInformation();
+
+ var dokument = builder.build();
+
+ assertThat(dokument.getHistorienProtokollInformation()).containsExactly(historienProtokollInformation);
+ }
+
+ @Nested
+ class TestWithoutAnlage {
+ @Test
+ void shouldHaveNoAnlage() {
+ var dokument = builder.build();
+
+ assertThat(dokument.getAnlage()).containsExactly(anlageDokumentDocument);
+ }
+
+ }
+
+ @Nested
+ class TestWithOneAnlage {
+ private final AnlageDokumentType anlageDokumentAttachment = AnlageDokumentTypeTestFactory.create();
+ private final OzgFile attachment = OzgFileTestFactory.createWithUniqueId();
+
+ @Test
+ void shouldHaveOneAnlage() {
+ builder.withFiles(List.of(document, attachment));
+ doReturn(anlageDokumentAttachment).when(builder).createAnlage(attachment);
+
+ var dokument = builder.build();
+
+ assertThat(dokument.getAnlage()).containsExactly(anlageDokumentDocument, anlageDokumentAttachment);
+ }
+ }
+ }
+
+ @Nested
+ class TestCreateAllgemeineMetadaten {
+ private final static String GENEHMIGT = "Bescheid wurde genehmigt.";
+ private final static String ABGELEHNT = "Bescheid wurde abgelehnt.";
+
+ @Test
+ void shouldHaveBemerkungGenehmigt() {
+ builder.withBescheid(BescheidTestFactory.createBuilder().bewilligt(true).build());
+
+ var metadaten = builder.createAllgemeineMetadaten();
+
+ assertThat(metadaten.getBemerkung()).isEqualTo(GENEHMIGT);
+ }
+
+ @Test
+ void shouldHaveBemerkungAbgelehnt() {
+ builder.withBescheid(BescheidTestFactory.createBuilder().bewilligt(false).build());
+
+ var metadaten = builder.createAllgemeineMetadaten();
+
+ assertThat(metadaten.getBemerkung()).isEqualTo(ABGELEHNT);
+ }
+ }
+
+ @Nested
+ class TestCreateHistorienProtokollInformation {
+ private final static String GESPEICHERT = "Bescheid gespeichert";
+ private final static String GESENDET = "Bescheid an Antragsteller gesendet";
+
+ @Test
+ void shouldHaveMetadatumName() {
+ var text = LoremIpsum.getInstance().getHtmlParagraphs(1, 1);
+ builder.withBescheid(BescheidTestFactory.createBuilder().nachrichtText(text).build());
+
+ var protokollInfo = builder.createHistorienProtokollInformation();
+
+ assertThat(protokollInfo.getMetadatumName()).isEqualTo(text);
+ }
+
+ @Test
+ void shouldHaveEmptyMetadatumName() {
+ builder.withBescheid(BescheidTestFactory.createBuilder().nachrichtText(null).build());
+
+ var protokollInfo = builder.createHistorienProtokollInformation();
+
+ assertThat(protokollInfo.getMetadatumName()).isEmpty();
+ }
+
+ @Test
+ void shouldHaveAkteur() {
+ var protokollInfo = builder.createHistorienProtokollInformation();
+
+ assertThat(protokollInfo.getAkteur()).isEqualTo(fullName + "; " + ZustaendigeStelleTestFactory.ORGANISATIONSEINHEITEN_ID);
+ }
+
+ @Test
+ void shouldHaveDatumUhrzeit() {
+ var protokollInfo = builder.createHistorienProtokollInformation();
+
+ assertThat(protokollInfo.getDatumUhrzeit()).isEqualTo(DateConverter.toXmlGregorianCalendar(SentInfoTestFactory.SENT_AT));
+ }
+
+ @Test
+ void shouldHaveGespeichertInAktion() {
+ builder.withBescheid(BescheidTestFactory.createBuilder().sendBy(SendBy.MANUAL).build());
+
+ var protokollInfo = builder.createHistorienProtokollInformation();
+
+ assertThat(protokollInfo.getAktion()).isEqualTo(GESPEICHERT);
+ }
+
+ @Test
+ void shouldHaveGesendetInAktion() {
+ builder.withBescheid(BescheidTestFactory.createBuilder().sendBy(SendBy.NACHRICHT).build());
+
+ var protokollInfo = builder.createHistorienProtokollInformation();
+
+ assertThat(protokollInfo.getAktion()).isEqualTo(GESENDET);
+ }
+ }
+
+ @Nested
+ class TestCreateAnlage {
+ private MockedStatic<AnlageDokumentTypeBuilder> anlageDokumentTypeBuilderMockedStatic;
+ @Mock
+ private AnlageDokumentTypeBuilder anlageDokumentTypeBuilder;
+ private final AnlageDokumentType expectedAnlage = AnlageDokumentTypeTestFactory.create();
+ private final OzgFile attachment = OzgFileTestFactory.createWithUniqueId();
+
+ @BeforeEach
+ void setUp() {
+ anlageDokumentTypeBuilderMockedStatic = mockStatic(AnlageDokumentTypeBuilder.class);
+ anlageDokumentTypeBuilderMockedStatic.when(AnlageDokumentTypeBuilder::builder).thenReturn(anlageDokumentTypeBuilder);
+ when(anlageDokumentTypeBuilder.withOzgFile(attachment)).thenReturn(anlageDokumentTypeBuilder);
+ when(anlageDokumentTypeBuilder.build()).thenReturn(expectedAnlage);
+ }
+
+ @AfterEach
+ void tearDown() {
+ anlageDokumentTypeBuilderMockedStatic.close();
+ }
+
+ @Test
+ void shouldSetOzgFile() {
+ callCreateAnlage();
+
+ verify(anlageDokumentTypeBuilder).withOzgFile(attachment);
+ }
+
+ @Test
+ void shouldBuildAnlageDokumentType() {
+ callCreateAnlage();
+
+ verify(anlageDokumentTypeBuilder).build();
+ }
+
+ @Test
+ void shouldReturnBuiltAnlage() {
+ var resultAnlage = callCreateAnlage();
+
+ assertThat(resultAnlage).isEqualTo(expectedAnlage);
+ }
+
+ private AnlageDokumentType callCreateAnlage() {
+ return builder.createAnlage(attachment);
+ }
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/bescheid/ExportBescheidServiceTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/bescheid/ExportBescheidServiceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..c502ffde25714570e0897df946cf97c6cd72bc6f
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/bescheid/ExportBescheidServiceTest.java
@@ -0,0 +1,419 @@
+package de.ozgcloud.alfa.bescheid;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.Spy;
+
+import de.ozgcloud.alfa.bescheid.BescheidExportData.BescheidExportDataBuilder;
+import de.ozgcloud.alfa.common.binaryfile.BinaryFileService;
+import de.ozgcloud.alfa.common.binaryfile.FileId;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.ozgcloud.alfa.common.user.UserProfile;
+import de.ozgcloud.alfa.common.user.UserProfileTestFactory;
+import de.ozgcloud.alfa.common.user.UserService;
+import de.ozgcloud.alfa.export.DokumentTypeTestFactory;
+import de.ozgcloud.alfa.vorgang.VorgangHeaderTestFactory;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingangTestFactory;
+import de.xoev.xdomea.DokumentType;
+
+class ExportBescheidServiceTest {
+
+ @InjectMocks
+ @Spy
+ private ExportBescheidService service;
+
+ @Mock
+ private BescheidService bescheidService;
+
+ @Mock
+ private BinaryFileService binaryFileService;
+
+ @Mock
+ private DocumentService documentService;
+
+ @Mock
+ private UserService userService;
+
+ @Nested
+ class TestCreateExportData {
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+ private final Bescheid bescheid = BescheidTestFactory.create();
+ private final BescheidExportData exportData = BescheidExportDataTestFactory.create();
+ private final BescheidExportInput input = BescheidExportInputTestFactory.create();
+
+ private MockedStatic<BescheidExportData> bescheidExportDataMockedStatic;
+ @Mock
+ private BescheidExportDataBuilder exportDataBuilder;
+
+ @BeforeEach
+ void setUpMocks() {
+ bescheidExportDataMockedStatic = mockStatic(BescheidExportData.class);
+ bescheidExportDataMockedStatic.when(BescheidExportData::builder).thenReturn(exportDataBuilder);
+
+ doReturn(Stream.of(bescheid)).when(service).getBescheids(vorgang.getId());
+ when(exportDataBuilder.build()).thenReturn(exportData);
+ doReturn(input).when(service).createBescheidExportInput(bescheid, vorgang);
+ doNothing().when(service).addBescheidExportData(input, exportDataBuilder);
+ }
+
+ @AfterEach
+ void tearDown() {
+ bescheidExportDataMockedStatic.close();
+ }
+
+ @Test
+ void shouldGetBescheids() {
+ callService();
+
+ verify(service).getBescheids(vorgang.getId());
+ }
+
+ @Test
+ void shouldCreateInputData() {
+ callService();
+
+ verify(service).createBescheidExportInput(bescheid, vorgang);
+ }
+
+ @Test
+ void shouldAddInputToBuilder() {
+ callService();
+
+ verify(service).addBescheidExportData(input, exportDataBuilder);
+ }
+
+ @Test
+ void shouldBuildExportData() {
+ callService();
+
+ verify(exportDataBuilder).build();
+ }
+
+ @Test
+ void shouldReturnBuiltExportData() {
+ var result = callService();
+
+ assertThat(result).isEqualTo(exportData);
+ }
+
+ private BescheidExportData callService() {
+ return service.createExportData(vorgang);
+ }
+ }
+
+ @Nested
+ class TestGetBescheids {
+ private final String vorgangId = VorgangHeaderTestFactory.ID;
+ private final Bescheid bescheid = BescheidTestFactory.createBuilder().status(BescheidStatus.SENT).build();
+ private final Bescheid bescheidDraft = BescheidTestFactory.createBuilder().status(BescheidStatus.DRAFT).build();
+
+ @Test
+ void shouldCallBescheidService() {
+ callService();
+
+ verify(bescheidService).findByVorgangIdSorted(vorgangId);
+ }
+
+ @Test
+ void shouldReturnBescheids() {
+ when(bescheidService.findByVorgangIdSorted(vorgangId)).thenReturn(Stream.of(bescheid));
+
+ var resultBescheids = callService();
+
+ assertThat(resultBescheids).containsExactly(bescheid);
+ }
+
+ @Test
+ void shouldNotReturnDrafts() {
+ when(bescheidService.findByVorgangIdSorted(vorgangId)).thenReturn(Stream.of(bescheid, bescheidDraft));
+
+ var resultBescheids = callService();
+
+ assertThat(resultBescheids).containsExactly(bescheid);
+ }
+
+ private Stream<Bescheid> callService() {
+ return service.getBescheids(vorgangId);
+ }
+ }
+
+ @Nested
+ class TestCreateBescheidExportInput {
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+ private final Bescheid bescheid = BescheidTestFactory.create();
+ private final OzgFile document = OzgFileTestFactory.createWithUniqueId();
+ private final OzgFile attachment = OzgFileTestFactory.createWithUniqueId();
+
+ @BeforeEach
+ void setUpMocks() {
+ doReturn(Stream.of(attachment)).when(service).getAttachments(bescheid);
+ doReturn(document).when(service).getDocument(bescheid);
+ }
+
+ @Test
+ void shouldCallGetAttachents() {
+ callService();
+
+ verify(service).getAttachments(bescheid);
+ }
+
+ @Test
+ void shouldCallGetDocument() {
+ callService();
+
+ verify(service).getDocument(bescheid);
+ }
+
+ @Test
+ void shouldReturnInputData() {
+ var resultInput = callService();
+
+ assertThat(resultInput).usingRecursiveComparison()
+ .isEqualTo(BescheidExportInputTestFactory.createBuilder().files(List.of(document, attachment)).build());
+ }
+
+ private BescheidExportInput callService() {
+ return service.createBescheidExportInput(bescheid, vorgang);
+ }
+ }
+
+ @Nested
+ class TestGetDocument {
+ private final Bescheid bescheid = BescheidTestFactory.create();
+ private final Document document = DocumentTestFactory.create();
+ private final OzgFile ozgDocument = OzgFileTestFactory.create();
+
+ @BeforeEach
+ void setUpMock() {
+ when(documentService.getDocument(bescheid.getBescheidDocument())).thenReturn(document);
+ }
+
+ @Test
+ void shouldCallDocumentService() {
+ callService();
+
+ verify(documentService).getDocument(bescheid.getBescheidDocument());
+ }
+
+ @Test
+ void shouldCallBinaryFileService() {
+ callService();
+
+ verify(binaryFileService).getFile(DocumentTestFactory.FILE_ID);
+ }
+
+ @Test
+ void shouldReturnOzgFile() {
+ when(binaryFileService.getFile(DocumentTestFactory.FILE_ID)).thenReturn(ozgDocument);
+
+ var resultDocument = callService();
+
+ assertThat(resultDocument).isEqualTo(ozgDocument);
+ }
+
+ private OzgFile callService() {
+ return service.getDocument(bescheid);
+ }
+ }
+
+ @Nested
+ class TestGetAttachments {
+ private final Bescheid bescheid = BescheidTestFactory.create();
+ private final List<FileId> fileIds = BescheidTestFactory.ATTACHMENTS;
+
+ @Test
+ void shouldCallBinaryFileServiceGetFile() {
+ service.getAttachments(bescheid);
+
+ verify(binaryFileService).getFiles(fileIds);
+ }
+
+ @Test
+ void shouldReturnGottenOzgFiles() {
+ var expectedOzgFile = OzgFileTestFactory.createWithUniqueId();
+ when(binaryFileService.getFiles(fileIds)).thenReturn(Stream.of(expectedOzgFile));
+
+ var resultOzgFiles = service.getAttachments(bescheid);
+
+ assertThat(resultOzgFiles).containsExactly(expectedOzgFile);
+ }
+ }
+
+ @Nested
+ class TestAddBescheidExportData {
+ private final List<OzgFile> files = BescheidExportInputTestFactory.FILES;
+ private final DokumentType dokumentType = DokumentTypeTestFactory.create();
+ private final BescheidExportInput exportInput = BescheidExportInputTestFactory.create();
+
+ @Mock
+ private BescheidExportDataBuilder exportDataBuilder;
+
+ @BeforeEach
+ void setUpMocks() {
+ doReturn(dokumentType).when(service).buildDokumentType(exportInput);
+ when(exportDataBuilder.dokumentType(dokumentType)).thenReturn(exportDataBuilder);
+ }
+
+ @Test
+ void shouldAddAttachmentsToBuilder() {
+ callService();
+
+ verify(exportDataBuilder).files(files);
+ }
+
+ @Test
+ void shouldBuildDokumentType() {
+ callService();
+
+ verify(service).buildDokumentType(exportInput);
+ }
+
+ @Test
+ void shouldAddDokumentTypeToBuilder() {
+ callService();
+
+ verify(exportDataBuilder).dokumentType(dokumentType);
+ }
+
+ private void callService() {
+ service.addBescheidExportData(exportInput, exportDataBuilder);
+ }
+ }
+
+ @Nested
+ class TestBuildDokumentType {
+ private final BescheidExportInput exportInput = BescheidExportInputTestFactory.create();
+ private final Bescheid bescheid = BescheidExportInputTestFactory.BESCHEID;
+ private final List<OzgFile> files = BescheidExportInputTestFactory.FILES;
+ private final String fullName = UserProfileTestFactory.FULLNAME;
+
+ private MockedStatic<DokumentTypeBuilder> dokumentTypeBuilderMockedStatic;
+ @Mock
+ private DokumentTypeBuilder dokumentTypeBuilder;
+
+ @BeforeEach
+ void setUp() {
+ dokumentTypeBuilderMockedStatic = mockStatic(DokumentTypeBuilder.class);
+ dokumentTypeBuilderMockedStatic.when(DokumentTypeBuilder::builder).thenReturn(dokumentTypeBuilder);
+
+ when(dokumentTypeBuilder.withBescheid(bescheid)).thenReturn(dokumentTypeBuilder);
+ when(dokumentTypeBuilder.withFiles(files)).thenReturn(dokumentTypeBuilder);
+ when(dokumentTypeBuilder.withFullName(fullName)).thenReturn(dokumentTypeBuilder);
+ when(dokumentTypeBuilder.withOrganisationseinheitenId(BescheidExportInputTestFactory.ORGANISATIONSEINHEITEN_ID))
+ .thenReturn(dokumentTypeBuilder);
+
+ doReturn(fullName).when(service).getFullName(bescheid);
+ }
+
+ @AfterEach
+ void tearDown() {
+ dokumentTypeBuilderMockedStatic.close();
+ }
+
+ @Test
+ void shouldCallBuilder() {
+ callService();
+
+ dokumentTypeBuilderMockedStatic.verify(DokumentTypeBuilder::builder);
+ }
+
+ @Test
+ void shouldBuildWithBescheid() {
+ callService();
+
+ verify(dokumentTypeBuilder).withBescheid(bescheid);
+ }
+
+ @Test
+ void shouldBuildWithOzgFiles() {
+ callService();
+
+ verify(dokumentTypeBuilder).withFiles(files);
+ }
+
+ @Test
+ void shouldGetFullName() {
+ callService();
+
+ verify(service).getFullName(bescheid);
+ }
+
+ @Test
+ void shouldBuildWithFullName() {
+ callService();
+
+ verify(dokumentTypeBuilder).withFullName(fullName);
+ }
+
+ @Test
+ void shouldBuildWithOrganisationseinheitenId() {
+ callService();
+
+ verify(dokumentTypeBuilder).withOrganisationseinheitenId(BescheidExportInputTestFactory.ORGANISATIONSEINHEITEN_ID);
+ }
+
+ @Test
+ void shouldBuild() {
+ callService();
+
+ verify(dokumentTypeBuilder).build();
+ }
+
+ @Test
+ void shouldReturnBuiltDokumentType() {
+ var expectedDokumentType = DokumentTypeTestFactory.create();
+ when(dokumentTypeBuilder.build()).thenReturn(expectedDokumentType);
+
+ var resultDokumentType = callService();
+
+ assertThat(resultDokumentType).isEqualTo(expectedDokumentType);
+ }
+
+ private DokumentType callService() {
+ return service.buildDokumentType(exportInput);
+ }
+ }
+
+ @Nested
+ class TestGetFullName {
+ private final Bescheid bescheid = BescheidTestFactory.create();
+ private final UserProfile userProfile = UserProfileTestFactory.create();
+ private final String expectedFullName = UserProfileTestFactory.FULLNAME;
+
+ @BeforeEach
+ void mockUserService() {
+ when(userService.getById(SentInfoTestFactory.SENT_BY)).thenReturn(userProfile);
+ }
+
+ @Test
+ void shouldCallUserServiceGetbyId() {
+ callService();
+
+ verify(userService).getById(SentInfoTestFactory.SENT_BY);
+ }
+
+ @Test
+ void shouldReturnOptionalOfUserProfile() {
+ var fullName = callService();
+
+ assertThat(fullName).isEqualTo(expectedFullName);
+ }
+
+ private String callService() {
+ return service.getFullName(bescheid);
+ }
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/AnlageDokumentTypeBuilderTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/AnlageDokumentTypeBuilderTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..de772e2c7761a3135c5699ed06045d216c3a1b19
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/AnlageDokumentTypeBuilderTest.java
@@ -0,0 +1,110 @@
+package de.ozgcloud.alfa.common;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.time.ZonedDateTime;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.Spy;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.ozgcloud.alfa.export.IdentifikationObjektTypeTestFactory;
+import de.xoev.xdomea.IdentifikationObjektType;
+import de.xoev.xdomea.VersionType;
+
+class AnlageDokumentTypeBuilderTest {
+
+ private final OzgFile ozgFile = OzgFileTestFactory.create();
+ private final static ZonedDateTime CREATED_AT = ZonedDateTime.now();
+ @Spy
+ private AnlageDokumentTypeBuilder builder = AnlageDokumentTypeBuilder.builder().withOzgFile(ozgFile).withCreatedAt(CREATED_AT);
+
+ @Nested
+ class TestBuild {
+ private MockedStatic<IdentifikationObjektTypeBuilder> identifikationObjektTypeBuilderMockedStatic;
+ @Mock
+ private IdentifikationObjektTypeBuilder identifikationObjektTypeBuilder;
+ private final IdentifikationObjektType identifikationObjektType = IdentifikationObjektTypeTestFactory.create();
+
+ private MockedStatic<VersionTypeBuilder> versionTypeBuilderMockedStatic;
+ @Mock
+ private VersionTypeBuilder versionTypeBuilder;
+ private final VersionType version = VersionTypeTestFactory.create();
+
+ @BeforeEach
+ void setUp() {
+ identifikationObjektTypeBuilderMockedStatic = mockStatic(IdentifikationObjektTypeBuilder.class);
+ identifikationObjektTypeBuilderMockedStatic.when(IdentifikationObjektTypeBuilder::builder).thenReturn(identifikationObjektTypeBuilder);
+ when(identifikationObjektTypeBuilder.withObjectID(OzgFileTestFactory.ID.toString())).thenReturn(identifikationObjektTypeBuilder);
+ when(identifikationObjektTypeBuilder.build()).thenReturn(identifikationObjektType);
+
+ versionTypeBuilderMockedStatic = mockStatic(VersionTypeBuilder.class);
+ versionTypeBuilderMockedStatic.when(VersionTypeBuilder::builder).thenReturn(versionTypeBuilder);
+ when(versionTypeBuilder.withCreatedAt(CREATED_AT)).thenReturn(versionTypeBuilder);
+ when(versionTypeBuilder.withOzgFile(ozgFile)).thenReturn(versionTypeBuilder);
+ when(versionTypeBuilder.build()).thenReturn(version);
+ }
+
+ @AfterEach
+ void tearDown() {
+ identifikationObjektTypeBuilderMockedStatic.close();
+ versionTypeBuilderMockedStatic.close();
+ }
+
+ @Test
+ void shouldSetObjectId() {
+ builder.build();
+
+ verify(identifikationObjektTypeBuilder).withObjectID(ozgFile.getId().toString());
+ }
+
+ @Test
+ void shouldBuildIdentifikationObjectType() {
+ builder.build();
+
+ verify(identifikationObjektTypeBuilder).build();
+ }
+
+ @Test
+ void shouldHaveIdentifikation() {
+ var anlage = builder.build();
+
+ assertThat(anlage.getIdentifikation()).isEqualTo(identifikationObjektType);
+ }
+
+ @Test
+ void shouldSetCreatedAt() {
+ builder.build();
+
+ verify(versionTypeBuilder).withCreatedAt(CREATED_AT);
+ }
+
+ @Test
+ void shouldSetOzgFile() {
+ builder.build();
+
+ verify(versionTypeBuilder).withOzgFile(ozgFile);
+ }
+
+ @Test
+ void shouldBuildVersionType() {
+ builder.build();
+
+ verify(versionTypeBuilder).build();
+ }
+
+ @Test
+ void shouldHaveVersion() {
+ var anlage = builder.build();
+
+ assertThat(anlage.getVersion()).contains(version);
+ }
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/AnlageDokumentTypeTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/AnlageDokumentTypeTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..f932ea1d538e812148824460da9a0dd9bae5e494
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/AnlageDokumentTypeTestFactory.java
@@ -0,0 +1,11 @@
+package de.ozgcloud.alfa.common;
+
+import de.xoev.xdomea.AnlageDokumentType;
+
+public class AnlageDokumentTypeTestFactory {
+
+ public static AnlageDokumentType create() {
+ return new AnlageDokumentType();
+ }
+
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/DateConverterTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/DateConverterTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..d6673fc2325d7ef87fed22b5d7c920812308d5b0
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/DateConverterTest.java
@@ -0,0 +1,88 @@
+package de.ozgcloud.alfa.common;
+
+import static org.assertj.core.api.Assertions.*;
+
+import java.time.ZonedDateTime;
+import java.util.Optional;
+
+import javax.xml.datatype.DatatypeConfigurationException;
+import javax.xml.datatype.DatatypeFactory;
+import javax.xml.datatype.XMLGregorianCalendar;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.mockito.MockedStatic;
+import org.mockito.Mockito;
+
+import de.ozgcloud.common.errorhandling.TechnicalException;
+
+class DateConverterTest {
+
+ @Nested
+ class TestConvertGermanFormatToISO {
+
+ private static final int YEAR = 2023;
+ private static final int MONTH = 2;
+ private static final int DAY = 14;
+
+ private static final String DATE = String.format("%s.%s%s.%s", DAY, 0, MONTH, YEAR);
+
+ @Test
+ void shouldConvert() {
+ var converted = callConverter(DATE);
+
+ assertThat(converted).get().extracting(XMLGregorianCalendar::getYear, XMLGregorianCalendar::getMonth, XMLGregorianCalendar::getDay)
+ .containsExactly(YEAR, MONTH, DAY);
+ }
+
+ @ParameterizedTest
+ @ValueSource(strings = { "2005-10-10", "abc", "19. February 1970", " ", "" })
+ void shouldReturnEmpty(String dateStr) {
+ var converted = callConverter(dateStr);
+
+ assertThat(converted).isEmpty();
+ }
+
+ @Test
+ void shouldReturnEmptyIfDateIsNull() {
+ var converted = callConverter(null);
+
+ assertThat(converted).isEmpty();
+ }
+
+ private Optional<XMLGregorianCalendar> callConverter(String dateStr) {
+ return DateConverter.convertGermanFormatToISO(dateStr);
+ }
+ }
+
+ @Nested
+ class TestCreateDatatypeFactory {
+
+ @Test
+ void shouldThrowTechnicalException() {
+ try (MockedStatic<DatatypeFactory> datatypeFactory = Mockito.mockStatic(DatatypeFactory.class)) {
+ datatypeFactory.when(DatatypeFactory::newInstance).thenThrow(DatatypeConfigurationException.class);
+
+ assertThatThrownBy(() -> DateConverter.createDatatypeFactory()).isInstanceOf(TechnicalException.class);
+ }
+ }
+ }
+
+ @Nested
+ class TestToXmlGregorianCalendar {
+
+ @Test
+ void shouldConvertZonedDateTime() {
+ var date = ZonedDateTime.now();
+
+ var xmlGregorianCalendar = DateConverter.toXmlGregorianCalendar(date);
+
+ assertThat(xmlGregorianCalendar.getYear()).isEqualTo(date.getYear());
+ assertThat(xmlGregorianCalendar.getMonth()).isEqualTo(date.getMonthValue());
+ assertThat(xmlGregorianCalendar.getDay()).isEqualTo(date.getDayOfMonth());
+ }
+
+ }
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/DateiformatCodeTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/DateiformatCodeTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..51be0e165911b9ddf5398b2a69b62abba8f0812b
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/DateiformatCodeTest.java
@@ -0,0 +1,70 @@
+package de.ozgcloud.alfa.common;
+
+import static org.assertj.core.api.Assertions.*;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.NullAndEmptySource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+class DateiformatCodeTest {
+
+ @Nested
+ class TestGetXdomeaCode {
+
+ @Test
+ void shouldReturnCode() {
+ var code = DateiformatCode.getXdomeaCode("application/pdf", "pdf");
+
+ assertThat(code).isEqualTo("018");
+ }
+
+ @Test
+ void shouldReturnSonstiges() {
+ var code = DateiformatCode.getXdomeaCode("abc", "abc");
+
+ assertThat(code).isEqualTo(DateiformatCode.SONSTIGES_CODE);
+ }
+
+ @ParameterizedTest
+ @NullAndEmptySource
+ void shouldReturnCodeOnSingleFileExtensionMapping(String extension) {
+ var code = DateiformatCode.getXdomeaCode("application/pdf", extension);
+
+ assertThat(code).isEqualTo("018");
+ }
+
+ @Test
+ void shouldReturnCodeOnMultipleFileExtensionMapping() {
+ var code = DateiformatCode.getXdomeaCode("image/jpeg", "jpg");
+
+ assertThat(code).isEqualTo("011");
+ }
+
+ @ParameterizedTest
+ @NullAndEmptySource
+ void shouldReturnSonstigesOnMultipleFileExtensionMapping(String extension) {
+ var code = DateiformatCode.getXdomeaCode("image/jpeg", extension);
+
+ assertThat(code).isEqualTo(DateiformatCode.SONSTIGES_CODE);
+ }
+
+ @ParameterizedTest
+ @NullAndEmptySource
+ void shouldReturnSonstigesOnEmptyMimeType(String mimeType) {
+ var code = DateiformatCode.getXdomeaCode(mimeType, "pdf");
+
+ assertThat(code).isEqualTo(DateiformatCode.SONSTIGES_CODE);
+ }
+
+ @ParameterizedTest
+ @ValueSource(strings = { "application/xml", "text/xml" })
+ void shouldReturnXml(String mimeType) {
+ var code = DateiformatCode.getXdomeaCode(mimeType, "xml");
+
+ assertThat(code).isEqualTo("030");
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/DateiformatCodeTypeTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/DateiformatCodeTypeTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..299391ad928a9c7bacba0101e474592f55874c8a
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/DateiformatCodeTypeTestFactory.java
@@ -0,0 +1,11 @@
+package de.ozgcloud.alfa.common;
+
+import de.xoev.xdomea.DateiformatCodeType;
+
+public class DateiformatCodeTypeTestFactory {
+
+ public static DateiformatCodeType create() {
+ return new DateiformatCodeType();
+ }
+
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/FormatTypeTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/FormatTypeTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..ea0393aea974a6b7f00fad540c30e630d9e6e520
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/FormatTypeTestFactory.java
@@ -0,0 +1,10 @@
+package de.ozgcloud.alfa.common;
+
+import de.xoev.xdomea.FormatType;
+
+public class FormatTypeTestFactory {
+
+ public static FormatType create() {
+ return new FormatType();
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/HistorienProtokollInformationTypeTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/HistorienProtokollInformationTypeTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..425a9731e62f3055a703ef2aecd623ba5603ea83
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/HistorienProtokollInformationTypeTestFactory.java
@@ -0,0 +1,11 @@
+package de.ozgcloud.alfa.common;
+
+import de.xoev.xdomea.HistorienProtokollInformationType;
+
+public class HistorienProtokollInformationTypeTestFactory {
+
+ public static HistorienProtokollInformationType create() {
+ return new HistorienProtokollInformationType();
+ }
+
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/IdentifikationObjektTypeBuilderTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/IdentifikationObjektTypeBuilderTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..55aeed8af0216295c413cab2c1e48443b105558a
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/IdentifikationObjektTypeBuilderTest.java
@@ -0,0 +1,63 @@
+package de.ozgcloud.alfa.common;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.Random;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.MockedStatic;
+import org.mockito.Spy;
+
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.ozgcloud.alfa.export.IdentifikationObjektTypeTestFactory;
+
+class IdentifikationObjektTypeBuilderTest {
+ private static final Long DOKUMENT_ORDINAL_NUMBER = new Random().nextLong();
+
+ @Spy
+ private IdentifikationObjektTypeBuilder builder = IdentifikationObjektTypeBuilder.builder().withObjectID(OzgFileTestFactory.ID.toString())
+ .withOrdinalNumber(DOKUMENT_ORDINAL_NUMBER);
+
+ @Nested
+ class TestBuild {
+ private MockedStatic<UUIDConverter> uuidConverterMockedStatic;
+
+ @BeforeEach
+ void setUp() {
+ uuidConverterMockedStatic = mockStatic(UUIDConverter.class);
+ uuidConverterMockedStatic.when(() -> UUIDConverter.fromObjectId(OzgFileTestFactory.ID.toString()))
+ .thenReturn(IdentifikationObjektTypeTestFactory.ID);
+ }
+
+ @AfterEach
+ void tearDown() {
+ uuidConverterMockedStatic.close();
+ }
+
+ @Test
+ void shouldConvertOzgFileId() {
+ builder.build();
+
+ uuidConverterMockedStatic.verify(() -> UUIDConverter.fromObjectId(OzgFileTestFactory.ID.toString()));
+ }
+
+ @Test
+ void shouldHaveId() {
+ var identifikation = builder.build();
+
+ assertThat(identifikation.getID()).isEqualTo(IdentifikationObjektTypeTestFactory.ID);
+ }
+
+ @Test
+ void shouldHaveNummerImUebergeordnetenContainer() {
+ var identifikation = builder.build();
+
+ assertThat(identifikation.getNummerImUebergeordnetenContainer()).isEqualTo(DOKUMENT_ORDINAL_NUMBER);
+ }
+ }
+
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/PrimaerdokumentTypeBuilderTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/PrimaerdokumentTypeBuilderTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..c269f1948b14a8484a0250f77b29fcbe95fe8906
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/PrimaerdokumentTypeBuilderTest.java
@@ -0,0 +1,106 @@
+package de.ozgcloud.alfa.common;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.time.ZonedDateTime;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.MockedStatic;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+
+class PrimaerdokumentTypeBuilderTest {
+
+ private final PrimaerdokumentTypeBuilder builder = PrimaerdokumentTypeBuilder.builder().withOzgFile(OzgFileTestFactory.createWithUniqueId());
+
+ @Nested
+ class TestBuild {
+
+ private MockedStatic<ExportFilenameGenerator> exportFilenameGeneratorMockedStatic;
+
+ private static final String ERSTELLER = "Ersteller";
+ private static final String GENERATED_FILE_NAME = "file_name";
+ private static final ZonedDateTime CREATED_AT = ZonedDateTime.now();
+ private final OzgFile ozgFile = OzgFileTestFactory.createWithUniqueId();
+
+ @BeforeEach
+ void setUp() {
+ exportFilenameGeneratorMockedStatic = mockStatic(ExportFilenameGenerator.class);
+ exportFilenameGeneratorMockedStatic.when(() -> ExportFilenameGenerator.generateExportFilename(ozgFile)).thenReturn(GENERATED_FILE_NAME);
+ }
+
+ @AfterEach
+ void tearDown() {
+ exportFilenameGeneratorMockedStatic.close();
+ }
+
+ @Test
+ void shouldGenerateExportFilename() {
+ builder.withOzgFile(ozgFile).build();
+
+ exportFilenameGeneratorMockedStatic.verify(() -> ExportFilenameGenerator.generateExportFilename(ozgFile));
+ }
+
+ @Test
+ void shouldHaveDateiname() {
+ var primaerdokumentType = builder.withOzgFile(ozgFile).build();
+
+ assertThat(primaerdokumentType.getDateiname()).isEqualTo(GENERATED_FILE_NAME);
+ }
+
+ @Test
+ void shouldNotHaveDateiname() {
+ var primaerdokumentType = builder.build();
+
+ assertThat(primaerdokumentType.getDateiname()).isNull();
+ }
+
+ @Test
+ void shouldHaveDateinameOriginal() {
+ var primaerdokumentType = builder.withOzgFile(ozgFile).build();
+
+ assertThat(primaerdokumentType.getDateinameOriginal()).isEqualTo(OzgFileTestFactory.NAME);
+ }
+
+ @Test
+ void shouldHaveErsteller() {
+ var primaerdokumentType = builder.withErsteller(ERSTELLER).build();
+
+ assertThat(primaerdokumentType.getErsteller()).isEqualTo(ERSTELLER);
+ }
+
+ @Test
+ void shouldNotHaveErsteller() {
+ var primaerdokumentType = builder.build();
+
+ assertThat(primaerdokumentType.getErsteller()).isNull();
+ }
+
+ @Test
+ void shouldHaveDatumUhrzeit() {
+ var primaerdokumentType = builder.withCreatedAt(CREATED_AT).build();
+
+ assertThat(primaerdokumentType.getDatumUhrzeit()).isEqualTo(DateConverter.toXmlGregorianCalendar(CREATED_AT));
+ }
+
+ @Test
+ void shouldNotHaveDatumUhrzeit() {
+ var primaerdokumentType = builder.build();
+
+ assertThat(primaerdokumentType.getDatumUhrzeit()).isNull();
+ }
+
+ @Test
+ void shouldThrowIllegalgStateException() {
+ builder.withOzgFile(null);
+
+ assertThatThrownBy(builder::build).isInstanceOf(IllegalStateException.class);
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/PrimaerdokumentTypeTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/PrimaerdokumentTypeTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..9ea20bb8172b6528091a928726a3e4beff46448c
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/PrimaerdokumentTypeTestFactory.java
@@ -0,0 +1,10 @@
+package de.ozgcloud.alfa.common;
+
+import de.xoev.xdomea.PrimaerdokumentType;
+
+public class PrimaerdokumentTypeTestFactory {
+
+ public static PrimaerdokumentType create() {
+ return new PrimaerdokumentType();
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/VersionTypeBuilderTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/VersionTypeBuilderTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..219cca4fdeb0a561cf52a66fd6af6414fcc2fd3f
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/VersionTypeBuilderTest.java
@@ -0,0 +1,208 @@
+package de.ozgcloud.alfa.common;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.time.ZonedDateTime;
+
+import org.apache.commons.io.FilenameUtils;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.Spy;
+
+import com.thedeanda.lorem.LoremIpsum;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.xoev.xdomea.DateiformatCodeType;
+import de.xoev.xdomea.FormatType;
+
+class VersionTypeBuilderTest {
+ private static final String FILE_NAME = "TestFile.ext";
+ private final OzgFile ozgFile = OzgFileTestFactory.createBuilder().name(FILE_NAME).build();
+ private final static ZonedDateTime CREATED_AT = ZonedDateTime.now();
+ private final static String ERSTELLER = LoremIpsum.getInstance().getName();
+ private final static String SONSTIGER_NAME = LoremIpsum.getInstance().getName();
+ @Spy
+ private VersionTypeBuilder builder = VersionTypeBuilder.builder().withOzgFile(ozgFile).withCreatedAt(CREATED_AT).withErsteller(ERSTELLER)
+ .withSonstigerName(SONSTIGER_NAME);
+
+ @Nested
+ class TestBuild {
+ private final FormatType formatType = FormatTypeTestFactory.create();
+
+ @BeforeEach
+ void setUp() {
+ doReturn(formatType).when(builder).createFormatType();
+ }
+
+ @Test
+ void shouldCallCreateFormatType() {
+ builder.build();
+
+ verify(builder).createFormatType();
+ }
+
+ @Test
+ void shouldHaveNummer() {
+ var version = builder.build();
+
+ assertThat(version.getNummer()).isEqualTo(VersionTypeBuilder.VERSION_NUMMER);
+ }
+
+ @Test
+ void shouldHaveFormatType() {
+ var version = builder.build();
+
+ assertThat(version.getFormat()).contains(formatType);
+ }
+ }
+
+ @Nested
+ class TestCreateFormatType {
+ private MockedStatic<PrimaerdokumentTypeBuilder> primaerdokumentTypeBuilderMockedStatic;
+ @Mock
+ private PrimaerdokumentTypeBuilder primaerdokumentTypeBuilder;
+
+ private final DateiformatCodeType dateiformatCodeType = DateiformatCodeTypeTestFactory.create();
+
+ @BeforeEach
+ void setUp() {
+ primaerdokumentTypeBuilderMockedStatic = mockStatic(PrimaerdokumentTypeBuilder.class);
+ primaerdokumentTypeBuilderMockedStatic.when(PrimaerdokumentTypeBuilder::builder).thenReturn(primaerdokumentTypeBuilder);
+ when(primaerdokumentTypeBuilder.withOzgFile(ozgFile)).thenReturn(primaerdokumentTypeBuilder);
+ when(primaerdokumentTypeBuilder.withCreatedAt(CREATED_AT)).thenReturn(primaerdokumentTypeBuilder);
+ when(primaerdokumentTypeBuilder.withErsteller(ERSTELLER)).thenReturn(primaerdokumentTypeBuilder);
+ doReturn(dateiformatCodeType).when(builder).createDateiformatCodeType();
+ }
+
+ @AfterEach
+ void tearDown() {
+ primaerdokumentTypeBuilderMockedStatic.close();
+ }
+
+ @Test
+ void shouldBuildPrimaerdokument() {
+ callCreateFormatType();
+
+ verify(primaerdokumentTypeBuilder).build();
+ }
+
+ @Test
+ void shouldSetOzgFile() {
+ callCreateFormatType();
+
+ verify(primaerdokumentTypeBuilder).withOzgFile(ozgFile);
+ }
+
+ @Test
+ void shouldSetCreatedAt() {
+ callCreateFormatType();
+
+ verify(primaerdokumentTypeBuilder).withCreatedAt(CREATED_AT);
+ }
+
+ @Test
+ void shouldSetErsteller() {
+ callCreateFormatType();
+
+ verify(primaerdokumentTypeBuilder).withErsteller(ERSTELLER);
+ }
+
+ @Test
+ void shouldHaveEmptyVersion() {
+ var formatType = callCreateFormatType();
+
+ assertThat(formatType.getVersion()).isEmpty();
+ }
+
+ @Test
+ void shouldCreateDateiformatCode() {
+ callCreateFormatType();
+
+ verify(builder).createDateiformatCodeType();
+ }
+
+ @Test
+ void shouldHaveName() {
+ var formatType = callCreateFormatType();
+
+ assertThat(formatType.getName()).isEqualTo(dateiformatCodeType);
+ }
+
+ @Test
+ void shouldHaveSonstigerName() {
+ var formatType = callCreateFormatType();
+
+ assertThat(formatType.getSonstigerName()).isEqualTo(SONSTIGER_NAME);
+ }
+
+ private FormatType callCreateFormatType() {
+ return builder.createFormatType();
+ }
+ }
+
+ @Nested
+ class TestCreateDateiformatCodeType {
+
+ private static final String CODE = "111";
+
+ private MockedStatic<DateiformatCode> dateiformatCodeMockedStatic;
+
+ @BeforeEach
+ void setUp() {
+ dateiformatCodeMockedStatic = mockStatic(DateiformatCode.class);
+ dateiformatCodeMockedStatic.when(
+ () -> DateiformatCode.getXdomeaCode(OzgFileTestFactory.CONTENT_TYPE, FilenameUtils.getExtension(FILE_NAME)))
+ .thenReturn(CODE);
+ }
+
+ @AfterEach
+ void tearDown() {
+ dateiformatCodeMockedStatic.close();
+ }
+
+ @Test
+ void shouldHaveListURI() {
+ var dateiformatCode = builder.createDateiformatCodeType();
+
+ assertThat(dateiformatCode.getListURI()).isEqualTo(VersionTypeBuilder.DATEI_FORMAT_LIST_URI);
+ }
+
+ @Test
+ void shouldHaveListVersionID() {
+ var dateiformatCode = builder.createDateiformatCodeType();
+
+ assertThat(dateiformatCode.getListVersionID()).isEqualTo(VersionTypeBuilder.LIST_VERSION_ID);
+ }
+
+ @Test
+ void shouldGetXdomeaCode() {
+ builder.createDateiformatCodeType();
+
+ dateiformatCodeMockedStatic.verify(
+ () -> DateiformatCode.getXdomeaCode(OzgFileTestFactory.CONTENT_TYPE, FilenameUtils.getExtension(FILE_NAME)));
+ }
+
+ @Test
+ void shouldTransformExtensionToLowerCase() {
+ builder.withOzgFile(OzgFileTestFactory.createBuilder().name("TestFile.EXT").build());
+
+ builder.createDateiformatCodeType();
+
+ dateiformatCodeMockedStatic.verify(
+ () -> DateiformatCode.getXdomeaCode(OzgFileTestFactory.CONTENT_TYPE, FilenameUtils.getExtension(FILE_NAME)));
+ }
+
+ @Test
+ void shouldHaveCode() {
+ var dateiformatCode = builder.createDateiformatCodeType();
+
+ assertThat(dateiformatCode.getCode()).isEqualTo(CODE);
+ }
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/VersionTypeTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/VersionTypeTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..f2fcd270fad8435d51170bd8963b3883baf7aa27
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/common/VersionTypeTestFactory.java
@@ -0,0 +1,12 @@
+package de.ozgcloud.alfa.common;
+
+import de.xoev.xdomea.VersionType;
+
+public class VersionTypeTestFactory {
+
+ public static VersionType create() {
+ var versionType = new VersionType();
+ versionType.getFormat().add(FormatTypeTestFactory.create());
+ return versionType;
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/AbgabeAbgabe0401TestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/AbgabeAbgabe0401TestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..16ea606a308c0864e06bf26d32138166313b4b1a
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/AbgabeAbgabe0401TestFactory.java
@@ -0,0 +1,10 @@
+package de.ozgcloud.alfa.export;
+
+import de.xoev.xdomea.AbgabeAbgabe0401;
+
+public class AbgabeAbgabe0401TestFactory {
+
+ public static AbgabeAbgabe0401 create() {
+ return new AbgabeAbgabe0401();
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/AkteTypeTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/AkteTypeTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..a13852e5a7eb4ad6cf42af49f7cf983d81a0e8a1
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/AkteTypeTestFactory.java
@@ -0,0 +1,10 @@
+package de.ozgcloud.alfa.export;
+
+import de.xoev.xdomea.AkteType;
+
+public class AkteTypeTestFactory {
+
+ public static AkteType create() {
+ return new AkteType();
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/AllgemeineMetadatenTypeTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/AllgemeineMetadatenTypeTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..fc7dd301486edbb9fc0ba13bef92329bdf208872
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/AllgemeineMetadatenTypeTestFactory.java
@@ -0,0 +1,16 @@
+package de.ozgcloud.alfa.export;
+
+import com.thedeanda.lorem.LoremIpsum;
+
+import de.xoev.xdomea.AllgemeineMetadatenType;
+
+public class AllgemeineMetadatenTypeTestFactory {
+
+ public static final String KENNZEICHEN = LoremIpsum.getInstance().getWords(1);
+
+ public static AllgemeineMetadatenType create() {
+ var allgemeineMetadatenType = new AllgemeineMetadatenType();
+ allgemeineMetadatenType.setKennzeichen(KENNZEICHEN);
+ return allgemeineMetadatenType;
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/DokumentTypeTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/DokumentTypeTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..8de8ed3e01318e4883481d704d6db97012b0c708
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/DokumentTypeTestFactory.java
@@ -0,0 +1,11 @@
+package de.ozgcloud.alfa.export;
+
+import de.xoev.xdomea.DokumentType;
+
+public class DokumentTypeTestFactory {
+
+ public static DokumentType create() {
+ var dokument = new DokumentType();
+ return dokument;
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportConfigurationTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportConfigurationTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..4dc62c958303b3a467bd9c32a432df417fcdab87
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportConfigurationTest.java
@@ -0,0 +1,77 @@
+package de.ozgcloud.alfa.export;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.Map;
+
+import jakarta.xml.bind.Marshaller;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Spy;
+import org.springframework.oxm.jaxb.Jaxb2Marshaller;
+
+class ExportConfigurationTest {
+
+ @Spy
+ @InjectMocks
+ private ExportConfiguration configuration;
+
+ @Mock
+ private XdomeaNamespacePrefixMapper prefixMapper;
+
+ @Nested
+ class TestCreateMarshallerProperties {
+
+ @Test
+ void shouldFromatMarshalledXml() {
+ var props = configuration.createMarshallerProperties();
+
+ assertThat(props).containsEntry(Marshaller.JAXB_FORMATTED_OUTPUT, ExportConfiguration.JAXB_FORMATTED_OUTPUT);
+ }
+
+ @Test
+ void shouldUseNamespacePrefixMapper() {
+ var props = configuration.createMarshallerProperties();
+
+ assertThat(props).containsEntry(ExportConfiguration.PROPERTY_NAMESPACE_PREFIX_MAPPER, prefixMapper);
+ }
+ }
+
+ @Nested
+ class TestMarshaller {
+
+ private final Map<String, Object> marshallerProps = Map.of();
+
+ @BeforeEach
+ void init() {
+ doReturn(marshallerProps).when(configuration).createMarshallerProperties();
+ }
+
+ @Test
+ void shouldSetContextPath() {
+ var marshaller = configuration.marshaller();
+
+ assertThat(marshaller.getContextPath()).isEqualTo(ExportConfiguration.CONTEXT_PATH);
+ }
+
+ @Test
+ void shouldCreateMarshallerProperties() {
+ configuration.marshaller();
+
+ verify(configuration).createMarshallerProperties();
+ }
+
+ @Test
+ void shouldReturnMarshaller() {
+ var marshaller = configuration.marshaller();
+
+ assertThat(marshaller).isNotNull().isInstanceOf(Jaxb2Marshaller.class);
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportDataTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportDataTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..84f4c718b85e1b76c6fa69fa3103fbd0c62fbe51
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportDataTestFactory.java
@@ -0,0 +1,25 @@
+package de.ozgcloud.alfa.export;
+
+import java.util.Set;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.xoev.xdomea.AbgabeAbgabe0401;
+
+class ExportDataTestFactory {
+
+ public static final String EXPORT_FILENAME = "file.zip";
+ public static final OzgFile OZG_FILE = OzgFileTestFactory.create();
+ public static final AbgabeAbgabe0401 ABGABE = AbgabeAbgabe0401TestFactory.create();
+
+ public static ExportData create() {
+ return createBuilder().build();
+ }
+
+ public static ExportData.ExportDataBuilder createBuilder() {
+ return ExportData.builder()
+ .exportFilename(EXPORT_FILENAME)
+ .abgabe(ABGABE)
+ .exportFiles(Set.of(OZG_FILE));
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportFilenameGeneratorTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportFilenameGeneratorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..0cf25b49436886e9478b67c4e204ff824c9abed9
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportFilenameGeneratorTest.java
@@ -0,0 +1,59 @@
+package de.ozgcloud.alfa.export;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.MockedStatic;
+
+import de.ozgcloud.alfa.common.ExportFilenameGenerator;
+import de.ozgcloud.alfa.common.AlfaTestUtils;
+import de.ozgcloud.alfa.common.UUIDConverter;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+
+class ExportFilenameGeneratorTest {
+
+ private MockedStatic<UUIDConverter> uuidConverter;
+
+ @Nested
+ class TestGenerateExportFilename {
+
+ private static final String UUID = "64a820d3-6285-172a-c028-0000000026d0";
+
+ private final OzgFile ozgFile = OzgFileTestFactory.create();
+
+ @BeforeEach
+ void init() {
+ uuidConverter = mockStatic(UUIDConverter.class);
+ uuidConverter.when(() -> UUIDConverter.fromObjectId(ozgFile.getId().toString())).thenReturn(UUID);
+ }
+
+ @AfterEach
+ void cleanup() {
+ uuidConverter.close();
+ }
+
+ @Test
+ void shouldConvertObjectId() {
+ callGenerator();
+
+ uuidConverter.verify(() -> UUIDConverter.fromObjectId(ozgFile.getId().toString()));
+ }
+
+ @Test
+ void shouldGenerate() {
+ var filename = callGenerator();
+
+ assertThat(filename).matches(String.format("^%s_%s$", AlfaTestUtils.UUID_REGEX, ozgFile.getName()));
+ }
+
+ private String callGenerator() {
+ return ExportFilenameGenerator.generateExportFilename(ozgFile);
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportServiceITCase.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportServiceITCase.java
new file mode 100644
index 0000000000000000000000000000000000000000..a55f463cb200af363bfef7d3a08e39c15066b0d2
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportServiceITCase.java
@@ -0,0 +1,87 @@
+package de.ozgcloud.alfa.export;
+
+import static de.ozgcloud.alfa.common.AlfaTestUtils.*;
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import java.io.ByteArrayOutputStream;
+import java.util.UUID;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.mock.mockito.MockBean;
+import org.springframework.boot.test.mock.mockito.SpyBean;
+
+import de.ozgcloud.alfa.bescheid.BescheidExportDataTestFactory;
+import de.ozgcloud.alfa.bescheid.ExportBescheidService;
+import de.ozgcloud.alfa.common.binaryfile.BinaryFileService;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.ozgcloud.alfa.common.user.UserProfileTestFactory;
+import de.ozgcloud.alfa.common.user.UserService;
+import de.ozgcloud.alfa.file.ExportFileService;
+import de.ozgcloud.alfa.historie.ExportHistorieService;
+import de.ozgcloud.alfa.kommentar.ExportKommentarService;
+import de.ozgcloud.alfa.kommentar.KommentarsExportDataTestFactory;
+import de.ozgcloud.alfa.postfach.ExportNachrichtService;
+import de.ozgcloud.alfa.postfach.PostfachMail;
+import de.ozgcloud.alfa.postfach.PostfachMailExportDataTestFactory;
+import de.ozgcloud.alfa.postfach.PostfachMailTestFactory;
+import de.ozgcloud.alfa.vorgang.ExportVorgangService;
+import de.ozgcloud.alfa.vorgang.VorgangHeaderTestFactory;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingangTestFactory;
+import de.ozgcloud.common.test.ITCase;
+
+@ITCase
+class ExportServiceITCase {
+
+ @SpyBean
+ private ExportFileService exportFileService;
+ @SpyBean
+ private ExportVorgangService exportVorgangService;
+ @MockBean
+ private ExportHistorieService exportHistorieService;
+ @MockBean
+ private ExportKommentarService exportKommentarService;
+ @MockBean
+ private BinaryFileService binaryFileService;
+ @MockBean
+ private ExportNachrichtService exportNachrichtService;
+ @MockBean
+ private ExportBescheidService exportBescheidService;
+ @MockBean
+ private UserService userService;
+ @Autowired
+ private ExportService exportService;
+
+ @Nested
+ class TestWriteExport {
+
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+ private final PostfachMail postfachMail = PostfachMailTestFactory.createBuilder().id(createMongoDbObjectId()).build();
+
+ @BeforeEach
+ void setup() {
+ doReturn(vorgang).when(exportVorgangService).getVorgang(VorgangHeaderTestFactory.ID);
+ doReturn(Stream.of(OzgFileTestFactory.createWithUniqueId())).when(exportFileService).getRepresentations(vorgang);
+ doReturn(Stream.of(OzgFileTestFactory.createWithUniqueId())).when(exportFileService).getAttachments(vorgang);
+ doReturn(Stream.of(OzgFileTestFactory.createWithUniqueId())).when(binaryFileService).getFiles(postfachMail.getAttachments());
+ doReturn(UserProfileTestFactory.create()).when(userService).getById(UserProfileTestFactory.ID);
+ doNothing().when(exportFileService).writeOzgFile(any(), any());
+ when(exportHistorieService.createHistorienProtokollInformationTypes(vorgang)).thenReturn(Stream.empty());
+ when(exportKommentarService.createExportData(vorgang)).thenReturn(KommentarsExportDataTestFactory.create());
+ when(exportNachrichtService.createExportData(vorgang)).thenReturn(PostfachMailExportDataTestFactory.create());
+ when(exportBescheidService.createExportData(vorgang)).thenReturn(BescheidExportDataTestFactory.create());
+ }
+
+ @Test
+ void shouldNotThrowException() {
+ assertDoesNotThrow(
+ () -> exportService.writeExport(VorgangHeaderTestFactory.ID, UUID.randomUUID().toString(), new ByteArrayOutputStream()));
+ }
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportServiceTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportServiceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..35bc4766a34a31b28701ce62ee9ec29a4033bf53
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportServiceTest.java
@@ -0,0 +1,642 @@
+package de.ozgcloud.alfa.export;
+
+import static de.ozgcloud.alfa.common.AlfaTestUtils.*;
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+import java.util.UUID;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.Spy;
+
+import de.ozgcloud.alfa.bescheid.BescheidExportData;
+import de.ozgcloud.alfa.bescheid.BescheidExportDataTestFactory;
+import de.ozgcloud.alfa.bescheid.ExportBescheidService;
+import de.ozgcloud.alfa.common.ExportFilenameGenerator;
+import de.ozgcloud.alfa.common.HistorienProtokollInformationTypeTestFactory;
+import de.ozgcloud.alfa.common.AlfaTestUtils;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.ozgcloud.alfa.file.ExportFileService;
+import de.ozgcloud.alfa.historie.ExportHistorieService;
+import de.ozgcloud.alfa.kommentar.ExportKommentarService;
+import de.ozgcloud.alfa.kommentar.KommentarsExportData;
+import de.ozgcloud.alfa.kommentar.KommentarsExportDataTestFactory;
+import de.ozgcloud.alfa.postfach.ExportNachrichtService;
+import de.ozgcloud.alfa.postfach.PostfachMailExportData;
+import de.ozgcloud.alfa.postfach.PostfachMailExportDataTestFactory;
+import de.ozgcloud.alfa.vorgang.EingangHeaderTestFactory;
+import de.ozgcloud.alfa.vorgang.EingangTestFactory;
+import de.ozgcloud.alfa.vorgang.ExportVorgangService;
+import de.ozgcloud.alfa.vorgang.VorgangHeaderTestFactory;
+import de.ozgcloud.alfa.vorgang.VorgangTypeTestFactory;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingangTestFactory;
+import de.ozgcloud.common.errorhandling.TechnicalException;
+import de.xoev.xdomea.AbgabeAbgabe0401;
+import de.xoev.xdomea.AkteType;
+import de.xoev.xdomea.DokumentType;
+import de.xoev.xdomea.HistorienProtokollInformationType;
+import de.xoev.xdomea.NkAbgabeType;
+import de.xoev.xdomea.VorgangType;
+import lombok.SneakyThrows;
+
+class ExportServiceTest {
+
+ @Spy
+ @InjectMocks
+ private ExportService service;
+
+ @Mock
+ private XdomeaXmlMarshaller xdomeaXmlMarshaller;
+
+ @Mock
+ private ExportFileService exportFileService;
+ @Mock
+ private ExportVorgangService exportVorgangService;
+ @Mock
+ private ExportHistorieService exportHistorieService;
+ @Mock
+ private ExportKommentarService exportKommentarService;
+ @Mock
+ private ExportNachrichtService exportNachrichtService;
+ @Mock
+ private ExportBescheidService exportBescheidService;
+
+ @DisplayName("Write exportToXdomea")
+ @Nested
+ class TestWriteExport {
+
+ private static final String FILENAME_ID = UUID.randomUUID().toString();
+ private final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+ private final ExportData exportData = ExportDataTestFactory.create();
+
+ @Mock
+ private File zipFile;
+
+ @BeforeEach
+ void setUp() {
+ doReturn(exportData).when(service).collectExportData(VorgangHeaderTestFactory.ID, FILENAME_ID);
+ doReturn(zipFile).when(service).createZipFile(exportData);
+ doNothing().when(service).writeZipFileContent(zipFile, outputStream);
+ }
+
+ @Test
+ void shouldCollectExportData() {
+ callService();
+
+ verify(service).collectExportData(VorgangHeaderTestFactory.ID, FILENAME_ID);
+ }
+
+ @Test
+ void shouldCreateZipFile() {
+ callService();
+
+ verify(service).createZipFile(exportData);
+ }
+
+ @Test
+ void shouldWriteZipFileContentToOutputStream() {
+ callService();
+
+ verify(service).writeZipFileContent(zipFile, outputStream);
+ }
+
+ private void callService() {
+ service.writeExport(VorgangHeaderTestFactory.ID, FILENAME_ID, outputStream);
+ }
+ }
+
+ @Nested
+ class TestCollectExportData {
+
+ private MockedStatic<XdomeaNachrichtBuilder> xdomeaNachrichtBuilderMockedStatic;
+
+ private static final String FILENAME_ID = UUID.randomUUID().toString();
+ private static final String FILE_NAME = "file.zip";
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+ private final VorgangType vorgangType = VorgangTypeTestFactory.create();
+ private final NkAbgabeType kopfType = NkAbgabeTypeTestFactory.create();
+ private final AbgabeAbgabe0401 abgabe = AbgabeAbgabe0401TestFactory.create();
+ private final AkteType akteType = AkteTypeTestFactory.create();
+ private final List<OzgFile> representations = List.of(OzgFileTestFactory.createWithUniqueId());
+ private final List<OzgFile> attachments = List.of(OzgFileTestFactory.createWithUniqueId());
+ private final List<DokumentType> representationsDokumentTypes = List.of(DokumentTypeTestFactory.create());
+ private final List<DokumentType> attachmentsDokumentTypes = List.of(DokumentTypeTestFactory.create());
+ private final List<HistorienProtokollInformationType> historienProtokollInformationTypes = List.of(
+ HistorienProtokollInformationTypeTestFactory.create());
+ private final KommentarsExportData kommentarsExportData = KommentarsExportDataTestFactory.create();
+ private final PostfachMailExportData postfachMailExportData = PostfachMailExportDataTestFactory.create();
+ private final BescheidExportData bescheidExportData = BescheidExportDataTestFactory.create();
+
+ @Mock
+ private XdomeaNachrichtBuilder xdomeaNachrichtBuilder;
+
+ @BeforeEach
+ void setUp() {
+ setUpVorgangService();
+ setUpXdomeaNachrichtBuilder();
+ setUpExportFileService();
+ setUpExportHistorieService();
+ setUpExportKommentarService();
+ setUpExportNachrichtService();
+ setUpExportBescheidService();
+
+ doReturn(FILE_NAME).when(service).buildXmlFilename(FILENAME_ID);
+ doReturn(EingangHeaderTestFactory.FORM_ENGINE_NAME).when(service).getFormEngineName(vorgang);
+
+ }
+
+ private void setUpVorgangService() {
+ when(exportVorgangService.getVorgang(VorgangHeaderTestFactory.ID)).thenReturn(vorgang);
+ when(exportVorgangService.createVorgangType(vorgang)).thenReturn(vorgangType);
+ when(exportVorgangService.createKopf(vorgang)).thenReturn(kopfType);
+ when(exportVorgangService.createAkteType(vorgang)).thenReturn(akteType);
+ }
+
+ private void setUpXdomeaNachrichtBuilder() {
+ xdomeaNachrichtBuilderMockedStatic = mockStatic(XdomeaNachrichtBuilder.class);
+ when(xdomeaNachrichtBuilder.withKopf(kopfType)).thenReturn(xdomeaNachrichtBuilder);
+ when(xdomeaNachrichtBuilder.withVorgang(vorgangType)).thenReturn(xdomeaNachrichtBuilder);
+ when(xdomeaNachrichtBuilder.withAktenzeichen(akteType)).thenReturn(xdomeaNachrichtBuilder);
+ when(xdomeaNachrichtBuilder.withRepresentations(representationsDokumentTypes)).thenReturn(xdomeaNachrichtBuilder);
+ when(xdomeaNachrichtBuilder.withAttachments(attachmentsDokumentTypes)).thenReturn(xdomeaNachrichtBuilder);
+ when(xdomeaNachrichtBuilder.withHistorie(historienProtokollInformationTypes)).thenReturn(xdomeaNachrichtBuilder);
+ when(xdomeaNachrichtBuilder.withKommentare(kommentarsExportData.getDokumentTypes())).thenReturn(xdomeaNachrichtBuilder);
+ when(xdomeaNachrichtBuilder.withPostfachMails(postfachMailExportData.getDokumentTypes())).thenReturn(xdomeaNachrichtBuilder);
+ when(xdomeaNachrichtBuilder.withBescheids(bescheidExportData.getDokumentTypes())).thenReturn(xdomeaNachrichtBuilder);
+ xdomeaNachrichtBuilderMockedStatic.when(XdomeaNachrichtBuilder::builder).thenReturn(xdomeaNachrichtBuilder);
+ when(xdomeaNachrichtBuilder.build()).thenReturn(abgabe);
+ }
+
+ private void setUpExportFileService() {
+ mockStreamToList(representations, stream -> when(exportFileService.getRepresentations(vorgang)).thenReturn(stream));
+ mockStreamToList(attachments, stream -> when(exportFileService.getAttachments(vorgang)).thenReturn(stream));
+ mockStreamToList(representationsDokumentTypes,
+ stream -> when(exportFileService.createDokumentTypes(representations, EingangHeaderTestFactory.FORM_ENGINE_NAME))
+ .thenReturn(stream));
+ mockStreamToList(attachmentsDokumentTypes,
+ stream -> when(exportFileService.createDokumentTypes(attachments, EingangHeaderTestFactory.FORM_ENGINE_NAME)).thenReturn(stream));
+ }
+
+ private void setUpExportHistorieService() {
+ mockStreamToList(historienProtokollInformationTypes,
+ stream -> when(exportHistorieService.createHistorienProtokollInformationTypes(vorgang)).thenReturn(stream));
+ }
+
+ private void setUpExportKommentarService() {
+ when(exportKommentarService.createExportData(vorgang)).thenReturn(kommentarsExportData);
+ }
+
+ private void setUpExportNachrichtService() {
+ when(exportNachrichtService.createExportData(vorgang)).thenReturn(postfachMailExportData);
+ }
+
+ private void setUpExportBescheidService() {
+ when(exportBescheidService.createExportData(vorgang)).thenReturn(bescheidExportData);
+ }
+
+ @AfterEach
+ void tearDown() {
+ xdomeaNachrichtBuilderMockedStatic.close();
+ }
+
+ @Test
+ void shouldLoadVorgang() {
+ callService();
+
+ verify(exportVorgangService).getVorgang(VorgangHeaderTestFactory.ID);
+ }
+
+ @Test
+ void shouldGenerateXmlFilename() {
+ callService();
+
+ verify(service).buildXmlFilename(FILENAME_ID);
+ }
+
+ @Test
+ void shouldGetRepresentations() {
+ callService();
+
+ verify(exportFileService).getRepresentations(vorgang);
+ }
+
+ @Test
+ void shouldGetAttachments() {
+ callService();
+
+ verify(exportFileService).getAttachments(vorgang);
+ }
+
+ @Test
+ void shouldCreateKopf() {
+ callService();
+
+ verify(exportVorgangService).createKopf(vorgang);
+ }
+
+ @Test
+ void shouldCreateVorgangType() {
+ callService();
+
+ verify(exportVorgangService).createVorgangType(vorgang);
+ }
+
+ @Test
+ void shouldCreateRepresentationsDokumentTypes() {
+ callService();
+
+ verify(exportFileService).createDokumentTypes(representations, EingangHeaderTestFactory.FORM_ENGINE_NAME);
+ }
+
+ @Test
+ void shouldCreateAttachmentsDokumentTypes() {
+ callService();
+
+ verify(exportFileService).createDokumentTypes(attachments, EingangHeaderTestFactory.FORM_ENGINE_NAME);
+ }
+
+ @Test
+ void shouldCreatePostfachMailsExportData() {
+ callService();
+
+ verify(exportNachrichtService).createExportData(vorgang);
+ }
+
+ @Test
+ void shouldCreateAkteType() {
+ callService();
+
+ verify(exportVorgangService).createAkteType(vorgang);
+ }
+
+ @Test
+ void shouldSetKopf() {
+ callService();
+
+ verify(xdomeaNachrichtBuilder).withKopf(kopfType);
+ }
+
+ @Test
+ void shouldSetVorgang() {
+ callService();
+
+ verify(xdomeaNachrichtBuilder).withVorgang(vorgangType);
+ }
+
+ @Test
+ void shouldSetRepresentations() {
+ callService();
+
+ verify(xdomeaNachrichtBuilder).withRepresentations(representationsDokumentTypes);
+ }
+
+ @Test
+ void shouldSetAttachments() {
+ callService();
+
+ verify(xdomeaNachrichtBuilder).withAttachments(attachmentsDokumentTypes);
+ }
+
+ @Test
+ void shouldSetPostfachMails() {
+ callService();
+
+ verify(xdomeaNachrichtBuilder).withPostfachMails(postfachMailExportData.getDokumentTypes());
+ }
+
+ @Test
+ void shouldSetBescheids() {
+ callService();
+
+ verify(xdomeaNachrichtBuilder).withBescheids(bescheidExportData.getDokumentTypes());
+ }
+
+ @Test
+ void shouldSetAktenzeichen() {
+ callService();
+
+ verify(xdomeaNachrichtBuilder).withAktenzeichen(akteType);
+ }
+
+ @Test
+ void shouldSetHistorie() {
+ callService();
+
+ verify(xdomeaNachrichtBuilder).withHistorie(historienProtokollInformationTypes);
+ }
+
+ @Test
+ void shouldCreateAbgabe() {
+ callService();
+
+ verify(xdomeaNachrichtBuilder).build();
+ }
+
+ @Test
+ void shouldContainAbgabe() {
+ var exportData = callService();
+
+ assertThat(exportData.getAbgabe()).isEqualTo(abgabe);
+ }
+
+ @Test
+ void shouldContainExportFilename() {
+ var exportData = callService();
+
+ assertThat(exportData.getExportFilename()).isEqualTo(FILE_NAME);
+ }
+
+ @Test
+ void shouldContainExportFiles() {
+ var exportData = callService();
+
+ assertThat(exportData.getExportFiles())
+ .hasSize(6)
+ .containsAll(representations)
+ .containsAll(attachments)
+ .containsAll(kommentarsExportData.getAttachments())
+ .containsAll(postfachMailExportData.getAttachments())
+ .containsAll(bescheidExportData.getFiles());
+ }
+
+ void shouldExportKommentare() {
+ callService();
+
+ verify(exportKommentarService).createExportData(vorgang);
+ }
+
+ private ExportData callService() {
+ return service.collectExportData(VorgangHeaderTestFactory.ID, FILENAME_ID);
+ }
+ }
+
+ @DisplayName("Build xml Filename")
+ @Nested
+ class TestBuildXmlFilename {
+
+ @Test
+ void shouldMatchPattern() {
+ var filename = service.buildXmlFilename(UUID.randomUUID().toString());
+
+ assertThat(filename).matches(AlfaTestUtils.uuidRegexWithSuffix(ExportService.EXPORT_FILENAME_SUFFIX));
+ }
+ }
+
+ @DisplayName("Create xml content")
+ @Nested
+ class TestCreateXmlContent {
+
+ private static final String XML_STRING = "<xml>";
+
+ @BeforeEach
+ void init() {
+ when(xdomeaXmlMarshaller.marshal(any())).thenReturn(XML_STRING);
+ }
+
+ @Test
+ void shouldCallXmlMarshaller() {
+ callService();
+
+ verify(xdomeaXmlMarshaller).marshal(ExportDataTestFactory.ABGABE);
+ }
+
+ @Test
+ void shouldReturnMarshalledString() {
+ var result = callService();
+
+ assertThat(result).isEqualTo(XML_STRING);
+ }
+
+ private String callService() {
+ return service.createXmlContent(ExportDataTestFactory.ABGABE);
+ }
+ }
+
+ @Nested
+ class TestCreateZipFile {
+
+ private static final String XML_FILE_CONTENT = "<xml></xml>";
+ private static final String XML_STRING = "<xml>";
+ private final ExportData exportData = ExportDataTestFactory.create();
+
+ @Captor
+ private ArgumentCaptor<ZipOutputStream> zipOutputStreamArgumentCaptor;
+
+ @SneakyThrows
+ @BeforeEach
+ void setUp() {
+ when(service.createXmlContent(ExportDataTestFactory.ABGABE)).thenReturn(XML_FILE_CONTENT);
+ doNothing().when(service).putOzgFileIntoZip(any(OzgFile.class), any(ZipOutputStream.class));
+ }
+
+ @Test
+ void shouldCreateXmlStringContent() {
+ callService();
+
+ verify(service).createXmlContent(ExportDataTestFactory.ABGABE);
+ }
+
+ @Test
+ void shouldCreateZipEntry() throws IOException {
+ callService();
+
+ verify(service).putZipEntry(eq(ExportDataTestFactory.EXPORT_FILENAME), eq(XML_FILE_CONTENT),
+ any(ZipOutputStream.class));
+ }
+
+ @Test
+ void shouldCreateZipOutputStream() throws IOException {
+ callService();
+
+ verify(service).putZipEntry(eq(ExportDataTestFactory.EXPORT_FILENAME), eq(XML_FILE_CONTENT),
+ zipOutputStreamArgumentCaptor.capture());
+ assertThat(zipOutputStreamArgumentCaptor.getValue()).isInstanceOf(ZipOutputStream.class);
+ }
+
+ @Test
+ void shouldWriteBytes() {
+ var file = callService();
+
+ assertThat(file).isNotEmpty().content().hasSizeGreaterThan(100);
+ }
+
+ @SneakyThrows
+ @Test
+ void shouldWritePdfFiles() {
+ callService();
+
+ verify(service).putOzgFileIntoZip(eq(ExportDataTestFactory.OZG_FILE), any(ZipOutputStream.class));
+ }
+
+ @Test
+ void shouldThrowTechnicalException() throws IOException {
+ doThrow(IOException.class).when(service).putZipEntry(anyString(), eq(XML_STRING), any(ZipOutputStream.class));
+
+ assertThatThrownBy(this::callService).isInstanceOf(TechnicalException.class);
+ }
+
+ private File callService() {
+ return service.createZipFile(exportData);
+ }
+
+ }
+
+ @Nested
+ class TestPutZipEntry {
+
+ @Mock
+ private ZipOutputStream zipOutputStream;
+
+ @Captor
+ private ArgumentCaptor<ZipEntry> zipEntryArgumentCaptor;
+
+ @Captor
+ private ArgumentCaptor<byte[]> fileDataArgumentCaptor;
+
+ private final String FILE_NAME = "file.xml";
+ private final String FILE_DATA = "xml content";
+
+ @SneakyThrows
+ @Test
+ void shouldPutNextEntry() {
+ callService();
+
+ verify(zipOutputStream).putNextEntry(zipEntryArgumentCaptor.capture());
+ assertThat(zipEntryArgumentCaptor.getValue().getName()).isEqualTo(FILE_NAME);
+ }
+
+ @SneakyThrows
+ @Test
+ void shouldWriteDataBytes() {
+ callService();
+
+ verify(zipOutputStream).write(fileDataArgumentCaptor.capture());
+ assertThat(fileDataArgumentCaptor.getValue()).isEqualTo(FILE_DATA.getBytes(StandardCharsets.UTF_8));
+ }
+
+ @SneakyThrows
+ @Test
+ void shouldCloseEntry() {
+ callService();
+
+ verify(zipOutputStream).closeEntry();
+ }
+
+ @SneakyThrows
+ private void callService() {
+ service.putZipEntry(FILE_NAME, FILE_DATA, zipOutputStream);
+ }
+ }
+
+ @Nested
+ class TestPutOzgFileIntoZip {
+
+ private MockedStatic<ExportFilenameGenerator> exportFilenameGenerator;
+
+ @Mock
+ private ZipOutputStream zipOutputStream;
+
+ @Captor
+ private ArgumentCaptor<ZipEntry> zipEntryArgumentCaptor;
+
+ private final OzgFile ozgFile = OzgFileTestFactory.create();
+
+ @BeforeEach
+ void setUp() {
+ exportFilenameGenerator = mockStatic(ExportFilenameGenerator.class);
+ exportFilenameGenerator.when(() -> ExportFilenameGenerator.generateExportFilename(ozgFile)).thenReturn(OzgFileTestFactory.NAME);
+ }
+
+ @AfterEach
+ void cleanUp() {
+ exportFilenameGenerator.close();
+ }
+
+ @Test
+ void shouldGenerateExportFilename() {
+ callService();
+
+ exportFilenameGenerator.verify(() -> ExportFilenameGenerator.generateExportFilename(ozgFile));
+ }
+
+ @SneakyThrows
+ @Test
+ void shouldPutNextEntry() {
+ callService();
+
+ verify(zipOutputStream).putNextEntry(zipEntryArgumentCaptor.capture());
+ assertThat(zipEntryArgumentCaptor.getValue().getName()).isEqualTo(OzgFileTestFactory.NAME);
+ }
+
+ @Test
+ void shouldCallExportFileService() {
+ callService();
+
+ verify(exportFileService).writeOzgFile(OzgFileTestFactory.ID, zipOutputStream);
+ }
+
+ @SneakyThrows
+ @Test
+ void shouldCloseEntry() {
+ callService();
+
+ verify(zipOutputStream).closeEntry();
+ }
+
+ @SneakyThrows
+ private void callService() {
+ service.putOzgFileIntoZip(ozgFile, zipOutputStream);
+ }
+
+ }
+
+ @Nested
+ class TestGetFormEngineName {
+
+ @Test
+ void shouldReturnEmptyStringOnNullEingang() {
+ var vorgang = VorgangWithEingangTestFactory.createBuilder().eingang(null).build();
+
+ var formEngineName = service.getFormEngineName(vorgang);
+
+ assertThat(formEngineName).isEmpty();
+ }
+
+ @Test
+ void shouldReturnEmptyStringOnNullEingangHeader() {
+ var vorgang = VorgangWithEingangTestFactory.createBuilder().eingang(EingangTestFactory.createBuilder().header(null).build()).build();
+
+ var formEngineName = service.getFormEngineName(vorgang);
+
+ assertThat(formEngineName).isEmpty();
+ }
+
+ @Test
+ void shouldReturnFormEngineName() {
+ VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+
+ var formEngineName = service.getFormEngineName(vorgang);
+
+ assertThat(formEngineName).isEqualTo(EingangHeaderTestFactory.FORM_ENGINE_NAME);
+ }
+ }
+}
\ No newline at end of file
diff --git a/alfa-service/src/test/java/de/ozgcloud/alfa/export/ExportVorgangControllerTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportVorgangControllerTest.java
similarity index 55%
rename from alfa-service/src/test/java/de/ozgcloud/alfa/export/ExportVorgangControllerTest.java
rename to alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportVorgangControllerTest.java
index 57f0063280880e67b654368c8c68f081d7dd5a3f..e83d251ba893e0efd9df548cdbe29846ebd4240c 100644
--- a/alfa-service/src/test/java/de/ozgcloud/alfa/export/ExportVorgangControllerTest.java
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportVorgangControllerTest.java
@@ -1,15 +1,17 @@
package de.ozgcloud.alfa.export;
+import static org.assertj.core.api.AssertionsForClassTypes.*;
import static org.mockito.Mockito.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
-import java.io.OutputStream;
import java.util.UUID;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Spy;
@@ -19,6 +21,7 @@ import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.ResultActions;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+import de.ozgcloud.alfa.common.AlfaTestUtils;
import de.ozgcloud.alfa.vorgang.VorgangHeaderTestFactory;
class ExportVorgangControllerTest {
@@ -26,8 +29,9 @@ class ExportVorgangControllerTest {
@Spy
@InjectMocks
private ExportVorgangController controller;
+
@Mock
- private ExportRemoteService exportRemoteService;
+ private ExportService xDomeaService;
private MockMvc mockMvc;
@@ -37,42 +41,50 @@ class ExportVorgangControllerTest {
}
@Nested
- class TestExportVorgang {
-
- public static final String VORGANG_ID = VorgangHeaderTestFactory.ID;
- public static final String EXPORTED_VORGANG_FILENAME = UUID.randomUUID().toString();
+ class TestBuildZipFilename {
- @Mock
- private ExportedVorgangFile exportedVorgangFile;
+ @Test
+ void shouldMatchPattern() {
+ var filename = controller.buildZipFilename(UUID.randomUUID().toString());
- @BeforeEach
- void init() {
- when(exportedVorgangFile.getFileName()).thenReturn(EXPORTED_VORGANG_FILENAME);
- when(exportRemoteService.exportVorgang(VORGANG_ID)).thenReturn(exportedVorgangFile);
+ assertThat(filename).matches(AlfaTestUtils.uuidRegexWithSuffix("_Abgabe.Abgabe.0401.xdomea"));
}
+ }
- @Test
- void shouldExportVorgang() throws Exception {
- doRequest();
+ @Nested
+ class TestExportToXdomea {
- verify(exportRemoteService).exportVorgang(VORGANG_ID);
+ private static final String VORGANG_EXPORT_FILENAME = "00000000-0000-0000-0000-000000000000_Abgabe.Abgabe.0401.xml";
+
+ @Captor
+ private ArgumentCaptor<String> filenameIdArgumentCaptor;
+
+ @BeforeEach
+ void init() {
+ doReturn(VORGANG_EXPORT_FILENAME).when(controller).buildZipFilename(anyString());
}
@Test
void shouldHaveContentDispositonHeader() throws Exception {
- doRequest().andExpect(header().string(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=" + EXPORTED_VORGANG_FILENAME));
+ doRequest().andExpect(header().string(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=" + VORGANG_EXPORT_FILENAME));
}
@Test
- void shouldHaveContentTypeHeader() throws Exception {
- doRequest().andExpect(header().string(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_OCTET_STREAM.toString()));
+ void shouldCallXdomeaService() throws Exception {
+ doRequest();
+
+ verify(xDomeaService).writeExport(eq(VorgangHeaderTestFactory.ID), filenameIdArgumentCaptor.capture(), any());
+ assertThat(filenameIdArgumentCaptor.getValue()).matches(AlfaTestUtils.UUID_REGEX);
}
@Test
- void shouldWriteFileToOutputStream() throws Exception {
+ void shouldUseUUIDAsFilenameId() throws Exception {
doRequest();
- verify(exportedVorgangFile).writeToOutputStream(any(OutputStream.class));
+ verify(controller).buildZipFilename(filenameIdArgumentCaptor.capture());
+
+ assertThat(filenameIdArgumentCaptor.getValue()).matches(AlfaTestUtils.UUID_REGEX);
+
}
private ResultActions doRequest() throws Exception {
diff --git a/alfa-service/src/test/java/de/ozgcloud/alfa/export/ExportVorgangProcessorTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportVorgangProcessorTest.java
similarity index 100%
rename from alfa-service/src/test/java/de/ozgcloud/alfa/export/ExportVorgangProcessorTest.java
rename to alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/ExportVorgangProcessorTest.java
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/IdentifikationObjektTypeTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/IdentifikationObjektTypeTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..9946765cf3e8bb56674da6ed13f4d089b7f3c084
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/IdentifikationObjektTypeTestFactory.java
@@ -0,0 +1,16 @@
+package de.ozgcloud.alfa.export;
+
+import java.util.UUID;
+
+import de.xoev.xdomea.IdentifikationObjektType;
+
+public class IdentifikationObjektTypeTestFactory {
+
+ public static final String ID = UUID.randomUUID().toString();
+
+ public static IdentifikationObjektType create() {
+ var identifikationObjektType = new IdentifikationObjektType();
+ identifikationObjektType.setID(ID);
+ return identifikationObjektType;
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/NamespacePrefixMapperTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/NamespacePrefixMapperTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..1261762b14a1ae7278b4489016faef0187f53374
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/NamespacePrefixMapperTest.java
@@ -0,0 +1,72 @@
+package de.ozgcloud.alfa.export;
+
+import static org.assertj.core.api.Assertions.*;
+
+import org.apache.commons.lang3.StringUtils;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+class NamespacePrefixMapperTest {
+
+ private XdomeaNamespacePrefixMapper prefixMapper = new XdomeaNamespacePrefixMapper();
+
+ @DisplayName("Get preferred prefix")
+ @Nested
+ class TestGetPreferredPrefix {
+
+ @Test
+ void shouldReturnXdomeaPrefix() {
+ var prefix = prefixMapper.getPreferredPrefix(XdomeaNamespacePrefixMapper.XDOMEA_NAMESPACE_URI, StringUtils.EMPTY, false);
+
+ assertThat(prefix).isEqualTo(XdomeaNamespacePrefixMapper.XDOMEA_NAMESPACE_PREFIX);
+ }
+
+ @Test
+ void shouldReturnSuggestion() {
+ var prefix = prefixMapper.getPreferredPrefix("not existing", "suggestion", false);
+
+ assertThat(prefix).isEqualTo("suggestion");
+ }
+ }
+
+ @DisplayName("Get pre decrlared namespace uris")
+ @Nested
+ class TestGetPreDeclaredNamespaceUris {
+
+ @Test
+ void shouldHaveSize() {
+ var uris = prefixMapper.getPreDeclaredNamespaceUris();
+
+ assertThat(uris).hasSize(4);
+ }
+
+ @Test
+ void shouldContainsDinspec() {
+ var uris = prefixMapper.getPreDeclaredNamespaceUris();
+
+ assertThat(uris).contains(XdomeaNamespacePrefixMapper.XDOMEA_NAMESPACE_DINSPEC_URI);
+ }
+
+ @Test
+ void shouldContainsGml() {
+ var uris = prefixMapper.getPreDeclaredNamespaceUris();
+
+ assertThat(uris).contains(XdomeaNamespacePrefixMapper.XDOMEA_NAMESPACE_GML_URI);
+ }
+
+ @Test
+ void shouldContainsXoevCode() {
+ var uris = prefixMapper.getPreDeclaredNamespaceUris();
+
+ assertThat(uris).contains(XdomeaNamespacePrefixMapper.XDOMEA_NAMESPACE_XOEV_CODE_URI);
+ }
+
+ @Test
+ void shouldContainsXoevLx() {
+ var uris = prefixMapper.getPreDeclaredNamespaceUris();
+
+ assertThat(uris).contains(XdomeaNamespacePrefixMapper.XDOMEA_NAMESPACE_XOEV_LC_URI);
+ }
+ }
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/NkAbgabeTypeTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/NkAbgabeTypeTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..e93a73419cc57dd0da460c220fe2e5fcaa7d3fa9
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/NkAbgabeTypeTestFactory.java
@@ -0,0 +1,11 @@
+package de.ozgcloud.alfa.export;
+
+import de.xoev.xdomea.NkAbgabeType;
+
+public class NkAbgabeTypeTestFactory {
+
+ public static NkAbgabeType create() {
+ return new NkAbgabeType();
+ }
+
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/UUIDConverterTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/UUIDConverterTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2af0c16013bf75ec4f81c938aad8092afc884083
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/UUIDConverterTest.java
@@ -0,0 +1,29 @@
+package de.ozgcloud.alfa.export;
+
+import static org.assertj.core.api.Assertions.*;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import de.ozgcloud.alfa.common.AlfaTestUtils;
+import de.ozgcloud.alfa.common.UUIDConverter;
+
+class UUIDConverterTest {
+
+ @Nested
+ class TestFromObjectId {
+
+ @Test
+ void shouldReturnUUID() {
+ var result = UUIDConverter.fromObjectId("64a820d36285172ac02826d0");
+
+ assertThat(result).isEqualTo("64a820d3-6285-172a-c028-0000000026d0").matches(AlfaTestUtils.UUID_REGEX);
+ }
+
+ @Test
+ void shouldThrowIllegalArgumentException() {
+ assertThatThrownBy(() -> UUIDConverter.fromObjectId("abc")).isInstanceOf(IllegalArgumentException.class);
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/XdomeaNachrichtBuilderTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/XdomeaNachrichtBuilderTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..c524f4f7c82761a842f02be8f42dde2b2159af53
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/XdomeaNachrichtBuilderTest.java
@@ -0,0 +1,167 @@
+package de.ozgcloud.alfa.export;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.List;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.Spy;
+
+import de.ozgcloud.alfa.common.HistorienProtokollInformationTypeTestFactory;
+import de.ozgcloud.alfa.vorgang.VorgangTypeTestFactory;
+import de.xoev.xdomea.AbgabeAbgabe0401;
+import de.xoev.xdomea.AkteType;
+import de.xoev.xdomea.DokumentType;
+import de.xoev.xdomea.HistorienProtokollInformationType;
+import de.xoev.xdomea.NkAbgabeType;
+import de.xoev.xdomea.VorgangType;
+
+class XdomeaNachrichtBuilderTest {
+
+ private final VorgangType vorgangType = VorgangTypeTestFactory.create();
+ @Spy
+ private final XdomeaNachrichtBuilder builder = XdomeaNachrichtBuilder.builder().withVorgang(vorgangType);
+
+ @Nested
+ class TestBuild {
+ private final AbgabeAbgabe0401 expectedAbgabe = AbgabeAbgabe0401TestFactory.create();
+
+ @BeforeEach
+ void setUpMock() {
+ doReturn(expectedAbgabe).when(builder).createAbgabeType();
+ }
+
+ @Test
+ void shouldCallAddVorgangDokumente() {
+ builder.build();
+
+ verify(builder).addVorgangDokumente();
+ }
+
+ @Test
+ void shouldCallAddVorgangChangeHistory() {
+ builder.build();
+
+ verify(builder).addVorgangChangeHistory();
+ }
+
+ @Test
+ void shouldCallCreateAbgabeType() {
+ builder.build();
+
+ verify(builder).createAbgabeType();
+ }
+
+ @Test
+ void shouldReturnAbgabeType() {
+ var abgabeType = builder.build();
+
+ assertThat(abgabeType).isEqualTo(expectedAbgabe);
+ }
+ }
+
+ @Nested
+ class TestCreateAbgabeType {
+ private final NkAbgabeType kopfType = NkAbgabeTypeTestFactory.create();
+ private final AkteType akte = AkteTypeTestFactory.create();
+
+ @Test
+ void shouldHaveKopf() {
+ var abgabeType = builder.withKopf(kopfType).createAbgabeType();
+
+ assertThat(abgabeType.getKopf()).isEqualTo(kopfType);
+ }
+
+ @Test
+ void shoulAddTwoSchriftgutobjekt() {
+ var abgabeType = builder.withAktenzeichen(akte).createAbgabeType();
+
+ assertThat(abgabeType.getSchriftgutobjekt()).size().isEqualTo(2);
+ }
+
+ @Test
+ void shouldHaveVorgangSchriftgutObjekt() {
+ var abgabeType = builder.createAbgabeType();
+
+ assertThat(abgabeType.getSchriftgutobjekt().get(0).getVorgang()).isEqualTo(vorgangType);
+ }
+
+ @Test
+ void shouldHaveAkteSchriftgutObjekt() {
+ var abgabeType = builder.withAktenzeichen(akte).createAbgabeType();
+
+ assertThat(abgabeType.getSchriftgutobjekt().get(1).getAkte()).isEqualTo(akte);
+ }
+
+ }
+
+ @Nested
+ class TestAddVorgangDokumente {
+ private final List<DokumentType> representations = List.of(DokumentTypeTestFactory.create(), DokumentTypeTestFactory.create());
+ private final List<DokumentType> attachments = List.of(DokumentTypeTestFactory.create(), DokumentTypeTestFactory.create());
+ private final List<DokumentType> kommentare = List.of(DokumentTypeTestFactory.create(), DokumentTypeTestFactory.create());
+ private final List<DokumentType> postfachMails = List.of(DokumentTypeTestFactory.create(), DokumentTypeTestFactory.create());
+ private final List<DokumentType> bescheids = List.of(DokumentTypeTestFactory.create(), DokumentTypeTestFactory.create());
+
+ @Test
+ void shouldAddRepresentations() {
+ builder.withRepresentations(representations).addVorgangDokumente();
+
+ assertThat(vorgangType.getDokument()).isEqualTo(representations);
+ }
+
+ @Test
+ void shouldAddAttachments() {
+ builder.withAttachments(attachments).addVorgangDokumente();
+
+ assertThat(vorgangType.getDokument()).isEqualTo(attachments);
+ }
+
+ @Test
+ void shouldAddKommentare() {
+ builder.withKommentare(kommentare).addVorgangDokumente();
+
+ assertThat(vorgangType.getDokument()).isEqualTo(kommentare);
+ }
+
+ @Test
+ void shouldAddPostfachMails() {
+ builder.withPostfachMails(postfachMails).addVorgangDokumente();
+
+ assertThat(vorgangType.getDokument()).isEqualTo(postfachMails);
+ }
+
+ @Test
+ void shouldAddBescheids() {
+ builder.withBescheids(bescheids).addVorgangDokumente();
+
+ assertThat(vorgangType.getDokument()).isEqualTo(bescheids);
+ }
+
+ }
+
+ @Nested
+ class TestAddVorgangChangeHistory {
+
+ private final List<HistorienProtokollInformationType> historie = List.of(HistorienProtokollInformationTypeTestFactory.create(),
+ HistorienProtokollInformationTypeTestFactory.create());
+
+ @Test
+ void shouldAddHistorie() {
+ builder.withHistorie(historie).addVorgangChangeHistory();
+
+ assertThat(vorgangType.getHistorienProtokollInformation()).isEqualTo(historie);
+ }
+
+ @Test
+ void shouldNotAddHistorie() {
+ builder.addVorgangChangeHistory();
+
+ assertThat(vorgangType.getHistorienProtokollInformation()).isEmpty();
+ }
+ }
+
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/XdomeaPropertiesTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/XdomeaPropertiesTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..78d786011aeedec05d51b6407305c2fb3769a626
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/XdomeaPropertiesTestFactory.java
@@ -0,0 +1,23 @@
+package de.ozgcloud.alfa.export;
+
+import com.thedeanda.lorem.LoremIpsum;
+
+import de.ozgcloud.alfa.export.XdomeaProperties.XdomeaPropertiesBuilder;
+
+public class XdomeaPropertiesTestFactory {
+
+ public static final String BEHOERDENSCHLUESSEL = LoremIpsum.getInstance().getWords(1);
+ public static final String BEHOERDENSCHLUESSEL_URI = LoremIpsum.getInstance().getUrl();
+ public static final String BEHOERDENSCHLUESSEL_VERSION = LoremIpsum.getInstance().getWords(1);
+
+ public static XdomeaProperties create() {
+ return createBuilder().build();
+ }
+
+ public static XdomeaPropertiesBuilder createBuilder() {
+ return new XdomeaPropertiesBuilder()
+ .behoerdenschluessel(BEHOERDENSCHLUESSEL)
+ .behoerdenschluesselUri(BEHOERDENSCHLUESSEL_URI)
+ .behoerdenschluesselVersion(BEHOERDENSCHLUESSEL_VERSION);
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/XdomeaPropertiesValidatorITCase.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/XdomeaPropertiesValidatorITCase.java
new file mode 100644
index 0000000000000000000000000000000000000000..451d2c7c49059af03d5e26034ad45f7bc6929998
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/XdomeaPropertiesValidatorITCase.java
@@ -0,0 +1,17 @@
+package de.ozgcloud.alfa.export;
+
+import static org.assertj.core.api.Assertions.*;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.context.ApplicationContext;
+
+import de.ozgcloud.common.test.ITCase;
+
+@ITCase
+class XdomeaPropertiesValidatorITCase {
+
+ @Test
+ void shouldExistInApplicationContext(ApplicationContext context) {
+ assertThat(context.getBean("configurationPropertiesValidator")).isNotNull().isInstanceOf(XdomeaPropertiesValidator.class);
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/XdomeaPropertiesValidatorTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/XdomeaPropertiesValidatorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..cd6cf19672ab8118254ded34a4b2444d921f8f55
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/XdomeaPropertiesValidatorTest.java
@@ -0,0 +1,138 @@
+package de.ozgcloud.alfa.export;
+
+import static org.assertj.core.api.Assertions.*;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.NullAndEmptySource;
+import org.mockito.Spy;
+import org.springframework.validation.Errors;
+
+class XdomeaPropertiesValidatorTest {
+
+ @Spy
+ private XdomeaPropertiesValidator validator;
+
+ @Nested
+ class TestSupports {
+
+ @Test
+ void shouldSupportXdomeaProperties() {
+ var supports = validator.supports(XdomeaProperties.class);
+
+ assertThat(supports).isTrue();
+ }
+ }
+
+ @Nested
+ class TestValidate {
+
+ @Test
+ void shouldBeValidIfAllBehoerdenschluesselPropertiesAreSet() {
+ var properties = XdomeaPropertiesTestFactory.create();
+
+ var errors = validate(properties);
+
+ assertThat(errors.hasErrors()).isFalse();
+ }
+
+ @ParameterizedTest
+ @NullAndEmptySource
+ void shouldBeValidIfBehoerdenschluesselIsNotSet(String behoerdenschluessel) {
+ var properties = XdomeaPropertiesTestFactory.createBuilder().behoerdenschluessel(behoerdenschluessel).build();
+
+ var errors = validate(properties);
+
+ assertThat(errors.hasErrors()).isFalse();
+ }
+
+ @Nested
+ class OnUriNotSet {
+
+ private static final String PROPERTY_NAME = "behoerdenschluesselUri";
+ public static final String PROPERTY_PATH = "ozgcloud.xdomea." + PROPERTY_NAME;
+ public static final String ERROR_CODE = PROPERTY_PATH + ".empty";
+
+ @ParameterizedTest
+ @NullAndEmptySource
+ void shouldHaveFieldErrors(String uri) {
+ var properties = withBehoerdenschluesselUri(uri);
+
+ var errors = validate(properties);
+
+ assertThat(errors.hasFieldErrors(PROPERTY_NAME)).isTrue();
+ }
+
+ @ParameterizedTest
+ @NullAndEmptySource
+ void shouldHaveMeaningfulErrorMessage(String uri) {
+ var properties = withBehoerdenschluesselUri(uri);
+
+ var errors = validate(properties);
+
+ assertThat(errors.getFieldError(PROPERTY_NAME).getDefaultMessage()).contains(PROPERTY_NAME);
+ }
+
+ @ParameterizedTest
+ @NullAndEmptySource
+ void shouldHaveErrorCode(String uri) {
+ var properties = withBehoerdenschluesselUri(uri);
+
+ var errors = validate(properties);
+
+ assertThat(errors.getFieldError(PROPERTY_NAME).getCode()).isEqualTo(ERROR_CODE);
+ }
+
+ private XdomeaProperties withBehoerdenschluesselUri(String uri) {
+ return XdomeaPropertiesTestFactory.createBuilder().behoerdenschluesselUri(uri).build();
+ }
+ }
+
+ @Nested
+ class OnVersionNotSet {
+
+ public static final String PROPERTY_NAME = "behoerdenschluesselVersion";
+ public static final String PROPERTY_PATH = "ozgcloud.xdomea." + PROPERTY_NAME;
+ public static final String ERROR_CODE = PROPERTY_PATH + ".empty";
+
+ @ParameterizedTest
+ @NullAndEmptySource
+ void shouldHaveFieldErrors(String version) {
+ var properties = withBehoerdenschluesselVersion(version);
+
+ var errors = validate(properties);
+
+ assertThat(errors.hasFieldErrors(PROPERTY_NAME)).isTrue();
+ }
+
+ @ParameterizedTest
+ @NullAndEmptySource
+ void shouldHaveMeaningfulErrorMessage(String version) {
+ var properties = withBehoerdenschluesselVersion(version);
+
+ var errors = validate(properties);
+
+ assertThat(errors.getFieldError(PROPERTY_NAME).getDefaultMessage()).contains(PROPERTY_NAME);
+ }
+
+ @ParameterizedTest
+ @NullAndEmptySource
+ void shouldHaveErrorCode(String version) {
+ var properties = withBehoerdenschluesselVersion(version);
+
+ var errors = validate(properties);
+
+ assertThat(errors.getFieldError(PROPERTY_NAME).getCode()).isEqualTo(ERROR_CODE);
+ }
+
+ private XdomeaProperties withBehoerdenschluesselVersion(String version) {
+ return XdomeaPropertiesTestFactory.createBuilder().behoerdenschluesselVersion(version).build();
+ }
+ }
+
+ private Errors validate(XdomeaProperties properties) {
+ return validator.validateObject(properties);
+ }
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/XmlMarshallerTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/XmlMarshallerTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..47e3c97c8f8bb27670b5bcde0b25a82700cb1148
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/export/XmlMarshallerTest.java
@@ -0,0 +1,47 @@
+package de.ozgcloud.alfa.export;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import java.io.StringWriter;
+
+import javax.xml.transform.stream.StreamResult;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Spy;
+import org.springframework.oxm.jaxb.Jaxb2Marshaller;
+
+import de.xoev.xdomea.AbgabeAbgabe0401;
+
+class XmlMarshallerTest {
+
+ @Spy
+ @InjectMocks
+ private XdomeaXmlMarshaller xdomeaXmlMarshaller;
+
+ @Mock
+ private Jaxb2Marshaller marshaller;
+
+ @Nested
+ class TestMarshal {
+
+ private final AbgabeAbgabe0401 abgabe = AbgabeAbgabe0401TestFactory.create();
+
+ @Captor
+ private ArgumentCaptor<StreamResult> streamResultArgumentCaptor;
+
+ @Test
+ void shouldMarshal() {
+ xdomeaXmlMarshaller.marshal(abgabe);
+
+ verify(marshaller).marshal(eq(abgabe), streamResultArgumentCaptor.capture());
+ assertThat(streamResultArgumentCaptor.getValue().getWriter()).isInstanceOf(StringWriter.class);
+ }
+ }
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/file/DokumentTypeBuilderITCase.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/file/DokumentTypeBuilderITCase.java
new file mode 100644
index 0000000000000000000000000000000000000000..60c0a2996f22512a3a9b740b65ecd22dc4c16d9d
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/file/DokumentTypeBuilderITCase.java
@@ -0,0 +1,189 @@
+package de.ozgcloud.alfa.file;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.Random;
+
+import org.apache.commons.lang3.StringUtils;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.MockedStatic;
+
+import de.ozgcloud.alfa.common.UUIDConverter;
+import de.ozgcloud.alfa.common.VersionTypeBuilder;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.xoev.xdomea.AllgemeineMetadatenType;
+import de.xoev.xdomea.DateiformatCodeType;
+import de.xoev.xdomea.FormatType;
+import de.xoev.xdomea.IdentifikationObjektType;
+import de.xoev.xdomea.PrimaerdokumentType;
+import de.xoev.xdomea.VersionType;
+
+class DokumentTypeBuilderITCase {
+
+ private static final Long DOKUMENT_ORDINAL_NUMBER = new Random().nextLong();
+ private static final String FORM_ENGINE_NAME = "DUMMY_NAME";
+ private final OzgFile ozgFile = OzgFileTestFactory.createBuilder().contentType("application/pdf").build();
+
+ private final DokumentTypeBuilder builder = DokumentTypeBuilder.builder()
+ .withOzgFile(ozgFile)
+ .withFormEngineName(FORM_ENGINE_NAME)
+ .withOrdinalNumber(DOKUMENT_ORDINAL_NUMBER);
+
+ private MockedStatic<UUIDConverter> uuidConverter;
+
+ @BeforeEach
+ void init() {
+ uuidConverter = mockStatic(UUIDConverter.class);
+ }
+
+ @AfterEach
+ void cleanup() {
+ uuidConverter.close();
+ }
+
+ @Nested
+ class TestBuild {
+
+ private final String FILE_UUID = "64a820d3-6285-172a-c028-0000000026d0";
+
+ @BeforeEach
+ void init() {
+ uuidConverter.when(() -> UUIDConverter.fromObjectId(OzgFileTestFactory.ID.toString())).thenReturn(FILE_UUID);
+ }
+
+ @Test
+ void shouldHaveIdentifikation() {
+ var identifikationObjekt = new IdentifikationObjektType();
+ identifikationObjekt.setID(FILE_UUID);
+ identifikationObjekt.setNummerImUebergeordnetenContainer(DOKUMENT_ORDINAL_NUMBER);
+ var dokument = builder.build();
+
+ assertThat(dokument.getIdentifikation()).usingRecursiveComparison().isEqualTo(identifikationObjekt);
+ }
+
+ @Nested
+ class TestAllgemeineMetadaten {
+ @Test
+ void shouldHaveBetreff() {
+ var allgemeineMetadaten = createAllgemeineMetadaten();
+
+ assertThat(allgemeineMetadaten.getBetreff()).isEqualTo(OzgFileTestFactory.NAME);
+ }
+
+ @Test
+ void shouldHaveEmptyKennzeichen() {
+ var allgemeineMetadaten = createAllgemeineMetadaten();
+
+ assertThat(allgemeineMetadaten.getKennzeichen()).isEmpty();
+ }
+
+ @Test
+ void shouldHaveEmptyBemerkung() {
+ var allgemeineMetadaten = createAllgemeineMetadaten();
+
+ assertThat(allgemeineMetadaten.getBemerkung()).isEmpty();
+ }
+
+ @Test
+ void shouldHaveMedium() {
+ var allgemeineMetadaten = createAllgemeineMetadaten();
+
+ assertThat(allgemeineMetadaten.getMedium().getCode()).isEqualTo(DokumentTypeBuilder.ALLGEMEINE_METADATEN_MEDIUM_CODE);
+ }
+
+ private AllgemeineMetadatenType createAllgemeineMetadaten() {
+ return builder.build().getAllgemeineMetadaten();
+ }
+ }
+
+ @Nested
+ class TestVersion {
+
+ @Test
+ void shouldHaveNummer() {
+ var versionType = createVersion();
+
+ assertThat(versionType.getNummer()).isEqualTo(DokumentTypeBuilder.VERSION_NUMMER);
+ }
+
+ private VersionType createVersion() {
+ return builder.build().getVersion().getFirst();
+ }
+
+ @Nested
+ class TestFormat {
+ @Test
+ void shouldHaveName() {
+ var expectedDateiformatCode = createDateiformatCode("018");
+
+ var formatType = createFormatType();
+
+ assertThat(formatType.getName()).usingRecursiveComparison().isEqualTo(expectedDateiformatCode);
+ }
+
+ private DateiformatCodeType createDateiformatCode(String codeValue) {
+ var dateiFormatCode = new DateiformatCodeType();
+ dateiFormatCode.setCode(codeValue);
+ dateiFormatCode.setListURI(VersionTypeBuilder.DATEI_FORMAT_LIST_URI);
+ dateiFormatCode.setListVersionID(VersionTypeBuilder.LIST_VERSION_ID);
+ return dateiFormatCode;
+ }
+
+ @Test
+ void shouldHaveSonstinerNameEmptyString() {
+ var formatType = createFormatType();
+
+ assertThat(formatType.getSonstigerName()).isEqualTo(StringUtils.EMPTY);
+ }
+
+ @Test
+ void shouldHaveVersionEmptyString() {
+ var formatType = createFormatType();
+
+ assertThat(formatType.getVersion()).isEqualTo(StringUtils.EMPTY);
+ }
+
+ private FormatType createFormatType() {
+ return createVersion().getFormat().getFirst();
+ }
+
+ @Nested
+ class TestPrimaerDokument {
+
+ @Test
+ void shouldHaveDateiname() {
+ var primaerdokument = createPrimaerdokumentType();
+
+ assertThat(primaerdokument.getDateiname()).isEqualTo(FILE_UUID + "_" + ozgFile.getName());
+ }
+
+ @Test
+ void shouldHaveDateinameOriginal() {
+ var primaerdokument = createPrimaerdokumentType();
+
+ assertThat(primaerdokument.getDateinameOriginal()).isEqualTo(ozgFile.getName());
+ }
+
+ @Test
+ void shouldHaveErsteller() {
+ var primaerdokument = createPrimaerdokumentType();
+
+ assertThat(primaerdokument.getErsteller()).isEqualTo(FORM_ENGINE_NAME);
+ }
+
+ private PrimaerdokumentType createPrimaerdokumentType() {
+ return createFormatType().getPrimaerdokument();
+ }
+ }
+
+ }
+
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/file/DokumentTypeBuilderTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/file/DokumentTypeBuilderTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..5278cd01777012fa5c4ff682918eee1506eb96bd
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/file/DokumentTypeBuilderTest.java
@@ -0,0 +1,259 @@
+package de.ozgcloud.alfa.file;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.Random;
+
+import org.apache.commons.lang3.StringUtils;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.Spy;
+
+import de.ozgcloud.alfa.common.IdentifikationObjektTypeBuilder;
+import de.ozgcloud.alfa.common.UUIDConverter;
+import de.ozgcloud.alfa.common.VersionTypeBuilder;
+import de.ozgcloud.alfa.common.VersionTypeTestFactory;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.ozgcloud.alfa.export.AllgemeineMetadatenTypeTestFactory;
+import de.ozgcloud.alfa.export.IdentifikationObjektTypeTestFactory;
+import de.xoev.xdomea.AllgemeineMetadatenType;
+import de.xoev.xdomea.IdentifikationObjektType;
+import de.xoev.xdomea.VersionType;
+
+class DokumentTypeBuilderTest {
+
+ private static final Long DOKUMENT_ORDINAL_NUMBER = new Random().nextLong();
+ private static final String FORM_ENGINE_NAME = "DUMMY_NAME";
+ private final OzgFile ozgFile = OzgFileTestFactory.create();
+
+ @Spy
+ private final DokumentTypeBuilder builder = DokumentTypeBuilder.builder()
+ .withOzgFile(ozgFile)
+ .withFormEngineName(FORM_ENGINE_NAME)
+ .withOrdinalNumber(DOKUMENT_ORDINAL_NUMBER);
+
+ private MockedStatic<UUIDConverter> uuidConverter;
+
+ @BeforeEach
+ void init() {
+ uuidConverter = mockStatic(UUIDConverter.class);
+ }
+
+ @AfterEach
+ void cleanup() {
+ uuidConverter.close();
+ }
+
+ @Nested
+ class TestBuild {
+
+ private final IdentifikationObjektType identifikationObjekt = IdentifikationObjektTypeTestFactory.create();
+ private final AllgemeineMetadatenType allgemeineMetadaten = AllgemeineMetadatenTypeTestFactory.create();
+ private final VersionType versionType = VersionTypeTestFactory.create();
+
+ @BeforeEach
+ void setUp() {
+ doReturn(identifikationObjekt).when(builder).createIdentifikation();
+ doReturn(versionType).when(builder).createVersionType();
+ doReturn(allgemeineMetadaten).when(builder).createAllgemeineMetadaten();
+ }
+
+ @Test
+ void shouldCreateIdentifikation() {
+ builder.build();
+
+ verify(builder).createIdentifikation();
+ }
+
+ @Test
+ void shouldHaveIdentifikation() {
+ var dokument = builder.build();
+
+ assertThat(dokument.getIdentifikation()).isEqualTo(identifikationObjekt);
+ }
+
+ @Test
+ void shouldCreateAllgemeineMetadaten() {
+ builder.build();
+
+ verify(builder).createAllgemeineMetadaten();
+ }
+
+ @Test
+ void shouldHaveAllgemeineMetadaten() {
+ var dokument = builder.build();
+
+ assertThat(dokument.getAllgemeineMetadaten()).isEqualTo(allgemeineMetadaten);
+ }
+
+ @Test
+ void shouldCreateVersion() {
+ builder.build();
+
+ verify(builder).createVersionType();
+ }
+
+ @Test
+ void shouldHaveVersion() {
+ var dokumentType = builder.build();
+
+ assertThat(dokumentType.getVersion()).containsExactly(versionType);
+ }
+
+ }
+
+ @Nested
+ class TestCreateIdentifikation {
+
+ private MockedStatic<IdentifikationObjektTypeBuilder> identifikationObjektTypeBuilderMockedStatic;
+ @Mock
+ private IdentifikationObjektTypeBuilder identifikationObjektTypeBuilder;
+ private final IdentifikationObjektType identifikationObjektType = IdentifikationObjektTypeTestFactory.create();
+
+ @BeforeEach
+ void setUp() {
+ identifikationObjektTypeBuilderMockedStatic = mockStatic(IdentifikationObjektTypeBuilder.class);
+ identifikationObjektTypeBuilderMockedStatic.when(IdentifikationObjektTypeBuilder::builder).thenReturn(identifikationObjektTypeBuilder);
+ when(identifikationObjektTypeBuilder.withObjectID(OzgFileTestFactory.ID.toString())).thenReturn(identifikationObjektTypeBuilder);
+ when(identifikationObjektTypeBuilder.withOrdinalNumber(DOKUMENT_ORDINAL_NUMBER))
+ .thenReturn(identifikationObjektTypeBuilder);
+ when(identifikationObjektTypeBuilder.build()).thenReturn(identifikationObjektType);
+ }
+
+ @AfterEach
+ void tearDown() {
+ identifikationObjektTypeBuilderMockedStatic.close();
+ }
+
+ @Test
+ void shouldSetObjectId() {
+ builder.createIdentifikation();
+
+ verify(identifikationObjektTypeBuilder).withObjectID(ozgFile.getId().toString());
+ }
+
+ @Test
+ void shouldSetNummerImUebergeordnetenContainer() {
+ builder.createIdentifikation();
+
+ verify(identifikationObjektTypeBuilder).withOrdinalNumber(DOKUMENT_ORDINAL_NUMBER);
+ }
+
+ @Test
+ void shouldBuildIdentifikationObjectType() {
+ builder.createIdentifikation();
+
+ verify(identifikationObjektTypeBuilder).build();
+ }
+
+ @Test
+ void shouldReturnBuiltIdentifikation() {
+ var resultIdentifikation = builder.createIdentifikation();
+
+ assertThat(resultIdentifikation).isEqualTo(identifikationObjektType);
+ }
+ }
+
+ @Nested
+ class TestCreateAllgemeineMetadaten {
+
+ @Test
+ void shouldHaveBetreff() {
+ var allgemeineMetadaten = builder.createAllgemeineMetadaten();
+
+ assertThat(allgemeineMetadaten.getBetreff()).isEqualTo(OzgFileTestFactory.NAME);
+ }
+
+ @Test
+ void shouldHaveEmptyKennzeichen() {
+ var allgemeineMetadaten = builder.createAllgemeineMetadaten();
+
+ assertThat(allgemeineMetadaten.getKennzeichen()).isEmpty();
+ }
+
+ @Test
+ void shouldHaveEmptyBemerkung() {
+ var allgemeineMetadaten = builder.createAllgemeineMetadaten();
+
+ assertThat(allgemeineMetadaten.getBemerkung()).isEmpty();
+ }
+
+ @Test
+ void shouldHaveMedium() {
+ var allgemeineMetadaten = builder.createAllgemeineMetadaten();
+
+ assertThat(allgemeineMetadaten.getMedium().getCode()).isEqualTo(DokumentTypeBuilder.ALLGEMEINE_METADATEN_MEDIUM_CODE);
+ }
+
+ }
+
+ @Nested
+ class CreateVersionType {
+
+ private MockedStatic<VersionTypeBuilder> versionTypeBuilderMockedStatic;
+ @Mock
+ private VersionTypeBuilder versionTypeBuilder;
+ private final VersionType version = VersionTypeTestFactory.create();
+
+ @BeforeEach
+ void setUp() {
+ versionTypeBuilderMockedStatic = mockStatic(VersionTypeBuilder.class);
+ versionTypeBuilderMockedStatic.when(VersionTypeBuilder::builder).thenReturn(versionTypeBuilder);
+ when(versionTypeBuilder.withErsteller(FORM_ENGINE_NAME)).thenReturn(versionTypeBuilder);
+ when(versionTypeBuilder.withOzgFile(ozgFile)).thenReturn(versionTypeBuilder);
+ when(versionTypeBuilder.withSonstigerName(StringUtils.EMPTY)).thenReturn(versionTypeBuilder);
+ when(versionTypeBuilder.build()).thenReturn(version);
+ }
+
+ @AfterEach
+ void tearDown() {
+ versionTypeBuilderMockedStatic.close();
+ }
+
+ @Test
+ void shouldSetOzgFile() {
+ callCreateVersionType();
+
+ verify(versionTypeBuilder).withOzgFile(ozgFile);
+ }
+
+ @Test
+ void shouldSetErsteller() {
+ callCreateVersionType();
+
+ verify(versionTypeBuilder).withErsteller(FORM_ENGINE_NAME);
+ }
+
+ @Test
+ void shouldSetSonstigerName() {
+ callCreateVersionType();
+
+ verify(versionTypeBuilder).withSonstigerName(StringUtils.EMPTY);
+ }
+
+ @Test
+ void shouldBuildVersionType() {
+ callCreateVersionType();
+
+ verify(versionTypeBuilder).build();
+ }
+
+ @Test
+ void shouldReturnBuiltVersion() {
+ var resultVersionType = callCreateVersionType();
+
+ assertThat(resultVersionType).isEqualTo(version);
+ }
+
+ private VersionType callCreateVersionType() {
+ return builder.createVersionType();
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/file/ExportFileServiceTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/file/ExportFileServiceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..73d519947c0903948271c05fd95c06ebcc29f3cf
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/file/ExportFileServiceTest.java
@@ -0,0 +1,184 @@
+package de.ozgcloud.alfa.file;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.io.OutputStream;
+import java.util.List;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+
+import de.ozgcloud.alfa.common.binaryfile.BinaryFileService;
+import de.ozgcloud.alfa.common.binaryfile.FileId;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileService;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.ozgcloud.alfa.export.DokumentTypeTestFactory;
+import de.ozgcloud.alfa.vorgang.EingangHeaderTestFactory;
+import de.ozgcloud.alfa.vorgang.VorgangHeaderTestFactory;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingangTestFactory;
+import de.xoev.xdomea.DokumentType;
+
+class ExportFileServiceTest {
+
+ @InjectMocks
+ private ExportFileService service;
+
+ @Mock
+ private OzgFileService ozgFileService;
+
+ @Mock
+ private BinaryFileService binaryFileService;
+
+ private final OzgFile ozgFile = OzgFileTestFactory.create();
+
+ private final VorgangWithEingang vorgangWithEingang = VorgangWithEingangTestFactory.create();
+
+ @DisplayName("get representations")
+ @Nested
+ class TestGetRepresentations {
+
+ @BeforeEach
+ void mock() {
+ when(ozgFileService.getRepresentations(VorgangHeaderTestFactory.ID)).thenReturn(Stream.of(ozgFile));
+ }
+
+ @DisplayName("should call get representations")
+ @Test
+ void shouldShouldCallGetRepresentations() {
+ getRepresentations();
+
+ verify(ozgFileService).getRepresentations(VorgangHeaderTestFactory.ID);
+ }
+
+ @DisplayName("should return representations")
+ @Test
+ void shouldReturnRepresentations() {
+ var representations = getRepresentations();
+
+ assertThat(representations).containsExactly(ozgFile);
+ }
+
+ private List<OzgFile> getRepresentations() {
+ return service.getRepresentations(vorgangWithEingang).toList();
+ }
+ }
+
+ @DisplayName("get attachments")
+ @Nested
+ class TestGetAttachments {
+ @BeforeEach
+ void mock() {
+ when(ozgFileService.getAttachments(VorgangHeaderTestFactory.ID)).thenReturn(Stream.of(ozgFile));
+ }
+
+ @DisplayName("should call get attachments")
+ @Test
+ void shouldShouldCallGetRepresentations() {
+ getAttachments();
+
+ verify(ozgFileService).getAttachments(VorgangHeaderTestFactory.ID);
+ }
+
+ @DisplayName("should return")
+ @Test
+ void shouldReturn() {
+ var representations = getAttachments();
+
+ assertThat(representations).containsExactly(ozgFile);
+ }
+
+ private List<OzgFile> getAttachments() {
+ return service.getAttachments(vorgangWithEingang).toList();
+ }
+ }
+
+ @Nested
+ class TestWriteOzgFile {
+
+ private final FileId fileId = OzgFileTestFactory.ID;
+
+ @Mock
+ private OutputStream outputStream;
+
+ @Test
+ void shouldCallBinaryFileService() {
+ service.writeOzgFile(fileId, outputStream);
+
+ verify(binaryFileService).writeFileContent(fileId, outputStream);
+ }
+ }
+
+ @Nested
+ class TestCreateDokumentType {
+
+ private MockedStatic<DokumentTypeBuilder> dokumentTypeBuilderMockedStatic;
+
+ @Mock
+ private DokumentTypeBuilder dokumentTypeBuilder;
+
+ private final OzgFile ozgFile = OzgFileTestFactory.create();
+ private final DokumentType dokumentType = DokumentTypeTestFactory.create();
+
+ @BeforeEach
+ void setUp() {
+ dokumentTypeBuilderMockedStatic = mockStatic(DokumentTypeBuilder.class);
+ dokumentTypeBuilderMockedStatic.when(DokumentTypeBuilder::builder).thenReturn(dokumentTypeBuilder);
+
+ when(dokumentTypeBuilder.withOzgFile(ozgFile)).thenReturn(dokumentTypeBuilder);
+ when(dokumentTypeBuilder.withOrdinalNumber(1L)).thenReturn(dokumentTypeBuilder);
+ when(dokumentTypeBuilder.withFormEngineName(EingangHeaderTestFactory.FORM_ENGINE_NAME)).thenReturn(dokumentTypeBuilder);
+ when(dokumentTypeBuilder.build()).thenReturn(dokumentType);
+ }
+
+ @AfterEach
+ void tearDown() {
+ dokumentTypeBuilderMockedStatic.close();
+ }
+
+ @Test
+ void shouldBuild() {
+ service.createDokumentTypes(List.of(ozgFile), EingangHeaderTestFactory.FORM_ENGINE_NAME).toList();
+
+ verify(dokumentTypeBuilder).build();
+ }
+
+ @Test
+ void shouldSetOzgFile() {
+ service.createDokumentTypes(List.of(ozgFile), EingangHeaderTestFactory.FORM_ENGINE_NAME).toList();
+
+ verify(dokumentTypeBuilder).withOzgFile(ozgFile);
+ }
+
+ @Test
+ void shouldSetOrdinalNumber() {
+ service.createDokumentTypes(List.of(ozgFile), EingangHeaderTestFactory.FORM_ENGINE_NAME).toList();
+
+ verify(dokumentTypeBuilder).withOrdinalNumber(1L);
+ }
+
+ @Test
+ void shouldSetFormEngineName() {
+ service.createDokumentTypes(List.of(ozgFile), EingangHeaderTestFactory.FORM_ENGINE_NAME).toList();
+
+ verify(dokumentTypeBuilder).withFormEngineName(EingangHeaderTestFactory.FORM_ENGINE_NAME);
+ }
+
+ @Test
+ void shouldReturnDokumentTypes() {
+ var dokumentTypes = service.createDokumentTypes(List.of(ozgFile), EingangHeaderTestFactory.FORM_ENGINE_NAME);
+
+ assertThat(dokumentTypes).containsExactly(dokumentType);
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/historie/ExportHistorieServiceTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/historie/ExportHistorieServiceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..bb06b69d792ba8e9d7178d1e8a4204aeebd5c039
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/historie/ExportHistorieServiceTest.java
@@ -0,0 +1,292 @@
+package de.ozgcloud.alfa.historie;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.EnumSource;
+import org.junit.jupiter.params.provider.EnumSource.Mode;
+import org.junit.jupiter.params.provider.NullAndEmptySource;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Spy;
+
+import com.thedeanda.lorem.LoremIpsum;
+
+import de.ozgcloud.alfa.common.DateConverter;
+import de.ozgcloud.alfa.common.HistorienProtokollInformationTypeTestFactory;
+import de.ozgcloud.alfa.common.command.CommandOrder;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingangTestFactory;
+import de.xoev.xdomea.HistorienProtokollInformationType;
+
+class ExportHistorieServiceTest {
+
+ @Spy
+ @InjectMocks
+ private ExportHistorieService service;
+
+ @Mock
+ private VorgangChangeHistoryService vorgangChangeHistoryService;
+
+ @Nested
+ class TestCreateHistorienProtokollInformationTypes {
+
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+ private final VorgangChangeHistory history = VorgangChangeHistoryTestFactory.create();
+ private final HistorienProtokollInformationType statusChangeHistorienProtokollInformationType = HistorienProtokollInformationTypeTestFactory
+ .create();
+ private final HistorienProtokollInformationType aktenzeichenChangeHistorienProtokollInformationType = HistorienProtokollInformationTypeTestFactory
+ .create();
+ private final HistorienProtokollInformationType assignUserChangeHistorienProtokollInformationType = HistorienProtokollInformationTypeTestFactory
+ .create();
+
+ @BeforeEach
+ void setUp() {
+ when(vorgangChangeHistoryService.createVorgangChangeHistory(vorgang)).thenReturn(history);
+ doReturn(statusChangeHistorienProtokollInformationType).when(service)
+ .createHistorienProtokollInformationType(VorgangChangeHistoryTestFactory.STATUS_CHANGE_HISTORY.get(0));
+ doReturn(aktenzeichenChangeHistorienProtokollInformationType).when(service)
+ .createHistorienProtokollInformationType(VorgangChangeHistoryTestFactory.AKTENZEICHEN_CHANGE_HISTORY.get(0));
+ doReturn(assignUserChangeHistorienProtokollInformationType).when(service)
+ .createHistorienProtokollInformationType(VorgangChangeHistoryTestFactory.ASSIGNED_USER_CHANGE_HISTORY.get(0));
+ }
+
+ @Test
+ void shouldGetVorgangChangeHistory() {
+ service.createHistorienProtokollInformationTypes(vorgang).toList();
+
+ verify(vorgangChangeHistoryService).createVorgangChangeHistory(vorgang);
+ }
+
+ @Test
+ void shouldCreateStatusChangeHistory() {
+ service.createHistorienProtokollInformationTypes(vorgang).toList();
+
+ verify(service).createHistorienProtokollInformationType(VorgangChangeHistoryTestFactory.STATUS_CHANGE_HISTORY.get(0));
+ }
+
+ @Test
+ void shouldReturnStatusChangeHistorienProtokollInformationType() {
+ var historienProtokollInformationTypes = service.createHistorienProtokollInformationTypes(vorgang);
+
+ assertThat(historienProtokollInformationTypes).contains(statusChangeHistorienProtokollInformationType);
+ }
+
+ @Test
+ void shouldCreateAktenzeichenChangeHistory() {
+ service.createHistorienProtokollInformationTypes(vorgang).toList();
+
+ verify(service).createHistorienProtokollInformationType(VorgangChangeHistoryTestFactory.AKTENZEICHEN_CHANGE_HISTORY.get(0));
+ }
+
+ @Test
+ void shouldReturnAktenzeichenHistorienProtokollInformationType() {
+ var historienProtokollInformationTypes = service.createHistorienProtokollInformationTypes(vorgang);
+
+ assertThat(historienProtokollInformationTypes).contains(aktenzeichenChangeHistorienProtokollInformationType);
+ }
+
+ @Test
+ void shouldCreateAssignUserChangeHistory() {
+ service.createHistorienProtokollInformationTypes(vorgang).toList();
+
+ verify(service).createHistorienProtokollInformationType(VorgangChangeHistoryTestFactory.ASSIGNED_USER_CHANGE_HISTORY.get(0));
+ }
+
+ @Test
+ void shouldReturnAssignUserHistorienProtokollInformationType() {
+ var historienProtokollInformationTypes = service.createHistorienProtokollInformationTypes(vorgang);
+
+ assertThat(historienProtokollInformationTypes).contains(assignUserChangeHistorienProtokollInformationType);
+ }
+ }
+
+ @Nested
+ class TestCreateHistorienProtokollInformationType {
+
+ private static final String CREATED_VALUE_BEFORE_CHANGE = VorgangChangeTestFactory.VALUE_BEFORE_CHANGE
+ + VorgangChangeTestFactory.ORGANISATIONSEINHEITEN_ID;
+ private static final String CREATED_VALUE_AFTER_CHANGE = VorgangChangeTestFactory.VALUE_AFTER_CHANGE
+ + VorgangChangeTestFactory.ORGANISATIONSEINHEITEN_ID;
+ private final VorgangChange vorgangChange = VorgangChangeTestFactory.create();
+
+ @BeforeEach
+ void setUp() {
+ doReturn(VorgangChangeTestFactory.CREATED_BY_NAME).when(service).createAkteur(vorgangChange);
+ doReturn(CREATED_VALUE_BEFORE_CHANGE).when(service).createValueBeforeChange(vorgangChange);
+ doReturn(CREATED_VALUE_AFTER_CHANGE).when(service).createValueAfterChange(vorgangChange);
+ }
+
+ @Test
+ void shouldCreateValueBeforeChange() {
+ service.createHistorienProtokollInformationType(vorgangChange);
+
+ verify(service).createValueBeforeChange(vorgangChange);
+ }
+
+ @Test
+ void shouldHaveAlterWert() {
+ var created = service.createHistorienProtokollInformationType(vorgangChange);
+
+ assertThat(created.getMetadatumAlterWert()).isEqualTo(CREATED_VALUE_BEFORE_CHANGE);
+ }
+
+ @Test
+ void shouldCreateValueAfterChange() {
+ service.createHistorienProtokollInformationType(vorgangChange);
+
+ verify(service).createValueAfterChange(vorgangChange);
+ }
+
+ @Test
+ void shouldHaveNeuerWert() {
+ var created = service.createHistorienProtokollInformationType(vorgangChange);
+
+ assertThat(created.getMetadatumNeuerWert()).isEqualTo(CREATED_VALUE_AFTER_CHANGE);
+ }
+
+ @Test
+ void shouldHaveAkteur() {
+ var created = service.createHistorienProtokollInformationType(vorgangChange);
+
+ assertThat(created.getAkteur()).isEqualTo(VorgangChangeTestFactory.CREATED_BY_NAME);
+ }
+
+ @Test
+ void shouldHaveDatumUhrzeit() {
+ var created = service.createHistorienProtokollInformationType(vorgangChange);
+
+ assertThat(created.getDatumUhrzeit()).isEqualTo(DateConverter.toXmlGregorianCalendar(VorgangChangeTestFactory.FINISHED_AT));
+ }
+
+ @Test
+ void shouldHaveAktion() {
+ var created = service.createHistorienProtokollInformationType(vorgangChange);
+
+ assertThat(created.getAktion()).isEqualTo(VorgangChangeTestFactory.ORDER);
+ }
+
+ @Test
+ void shouldCreateAkteur() {
+ service.createHistorienProtokollInformationType(vorgangChange);
+
+ verify(service).createAkteur(vorgangChange);
+ }
+ }
+
+ @Nested
+ class TestCreateAkteur {
+
+ private static final String VALUE_FOR_AKTEUR = LoremIpsum.getInstance().getWords(2);
+
+ @Test
+ void shouldGetValueForAkteur() {
+ service.createAkteur(VorgangChangeTestFactory.create());
+
+ verify(service).appendOrganisationseinheitenID(VorgangChangeTestFactory.CREATED_BY_NAME,
+ VorgangChangeTestFactory.ORGANISATIONSEINHEITEN_ID);
+ }
+
+ @Test
+ void shouldReturnValueForAkteur() {
+ doReturn(VALUE_FOR_AKTEUR).when(service)
+ .appendOrganisationseinheitenID(VorgangChangeTestFactory.CREATED_BY_NAME, VorgangChangeTestFactory.ORGANISATIONSEINHEITEN_ID);
+
+ var akteur = service.createAkteur(VorgangChangeTestFactory.create());
+
+ assertThat(akteur).isEqualTo(VALUE_FOR_AKTEUR);
+ }
+ }
+
+ @Nested
+ class TestCreateValueBeforeChange {
+
+ private static final String ASSIGNED_USER = LoremIpsum.getInstance().getWords(2);
+
+ @ParameterizedTest
+ @EnumSource(mode = Mode.EXCLUDE, names = "ASSIGN_USER")
+ void shouldReturnValueForOrder(CommandOrder order) {
+ var value = service.createValueBeforeChange(VorgangChangeTestFactory.createBuilder().order(order.name()).build());
+
+ assertThat(value).isEqualTo(VorgangChangeTestFactory.VALUE_BEFORE_CHANGE);
+ }
+
+ @Test
+ void shouldGetValueForAssignUserOrder() {
+ service.createValueBeforeChange(VorgangChangeTestFactory.createBuilder().order(CommandOrder.ASSIGN_USER.name()).build());
+
+ verify(service).appendOrganisationseinheitenID(VorgangChangeTestFactory.VALUE_BEFORE_CHANGE,
+ VorgangChangeTestFactory.ORGANISATIONSEINHEITEN_ID);
+ }
+
+ @Test
+ void shouldReturnValueForAssignUserOrder() {
+ doReturn(ASSIGNED_USER).when(service)
+ .appendOrganisationseinheitenID(VorgangChangeTestFactory.VALUE_BEFORE_CHANGE, VorgangChangeTestFactory.ORGANISATIONSEINHEITEN_ID);
+
+ var value = service
+ .createValueBeforeChange(VorgangChangeTestFactory.createBuilder().order(CommandOrder.ASSIGN_USER.name()).build());
+
+ assertThat(value).isEqualTo(ASSIGNED_USER);
+ }
+ }
+
+ @Nested
+ class TestCreateValueAfterChange {
+
+ private static final String ASSIGNED_USER = LoremIpsum.getInstance().getWords(2);
+
+ @ParameterizedTest
+ @EnumSource(mode = Mode.EXCLUDE, names = "ASSIGN_USER")
+ void shouldReturnValueForOrder(CommandOrder order) {
+ var value = service.createValueAfterChange(VorgangChangeTestFactory.createBuilder().order(order.name()).build());
+
+ assertThat(value).isEqualTo(VorgangChangeTestFactory.VALUE_AFTER_CHANGE);
+ }
+
+ @Test
+ void shouldGetValueForAssignUserOrder() {
+ service.createValueAfterChange(VorgangChangeTestFactory.createBuilder().order(CommandOrder.ASSIGN_USER.name()).build());
+
+ verify(service).appendOrganisationseinheitenID(VorgangChangeTestFactory.VALUE_AFTER_CHANGE,
+ VorgangChangeTestFactory.ORGANISATIONSEINHEITEN_ID);
+ }
+
+ @Test
+ void shouldReturnValueForAssignUserOrder() {
+ doReturn(ASSIGNED_USER).when(service)
+ .appendOrganisationseinheitenID(VorgangChangeTestFactory.VALUE_AFTER_CHANGE, VorgangChangeTestFactory.ORGANISATIONSEINHEITEN_ID);
+
+ var value = service.createValueAfterChange(VorgangChangeTestFactory.createBuilder().order(CommandOrder.ASSIGN_USER.name()).build());
+
+ assertThat(value).isEqualTo(ASSIGNED_USER);
+ }
+ }
+
+ @Nested
+ class TestAppendOrganisationseinheitenID {
+
+ private static final String TEXT = LoremIpsum.getInstance().getWords(2);
+
+ @ParameterizedTest
+ @NullAndEmptySource
+ void shouldReturnEmpty(String assignedUser) {
+ var value = service.appendOrganisationseinheitenID(assignedUser, VorgangChangeTestFactory.ORGANISATIONSEINHEITEN_ID);
+
+ assertThat(value).isEmpty();
+ }
+
+ @Test
+ void shouldAppendOrganisationseinheitenID() {
+ var value = service.appendOrganisationseinheitenID(TEXT, VorgangChangeTestFactory.ORGANISATIONSEINHEITEN_ID);
+
+ assertThat(value).isEqualTo(
+ String.format("%s; %s", TEXT, VorgangChangeTestFactory.ORGANISATIONSEINHEITEN_ID));
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/kommentar/DokumentTypeBuilderITCase.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/kommentar/DokumentTypeBuilderITCase.java
new file mode 100644
index 0000000000000000000000000000000000000000..366b478272feb2591773b77c42d6c7d6a08088c9
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/kommentar/DokumentTypeBuilderITCase.java
@@ -0,0 +1,187 @@
+package de.ozgcloud.alfa.kommentar;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+import org.apache.commons.lang3.StringUtils;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.mockito.MockedStatic;
+
+import de.ozgcloud.alfa.common.UUIDConverter;
+import de.ozgcloud.alfa.common.VersionTypeBuilder;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.xoev.xdomea.AnlageDokumentType;
+import de.xoev.xdomea.DateiformatCodeType;
+import de.xoev.xdomea.FormatType;
+import de.xoev.xdomea.IdentifikationObjektType;
+import de.xoev.xdomea.VersionType;
+
+class DokumentTypeBuilderITCase {
+
+ private static final String VERSION_NUMMER = "1";
+ private static final String TYP = "Notiz";
+
+ private static final int IDX_ANLAGE_PDF = 0;
+ private static final int IDX_ANLAGE_JPEG = 1;
+ private static final int IDX_ANLAGE_JPG = 2;
+
+ private final Kommentar kommentar = KommentarTestFactory.create();
+ private final OzgFile attachment1 = OzgFileTestFactory.createBuilder().contentType("application/pdf").build();
+ private final OzgFile attachment2 = OzgFileTestFactory.createBuilder().contentType("image/jpeg").name("Testfile.jpeg").build();
+ private final OzgFile attachment3 = OzgFileTestFactory.createBuilder().contentType("image/jpeg").name("Testfile.jpg").build();
+ private final List<OzgFile> attachments = List.of(attachment1, attachment2, attachment3);
+ private final DokumentTypeBuilder builder = DokumentTypeBuilder.builder().withKommentar(kommentar).withKommentarAttachments(attachments);
+
+ @Nested
+ class TestBuild {
+ private MockedStatic<UUIDConverter> uuidConverterMockedStatic;
+ private final static String KOMMENTAR_UUID = "correct kommentar ID";
+ private final static String ATTACHMENT1_UUID = "correct attachment ID";
+
+ @BeforeEach
+ void setUp() {
+ uuidConverterMockedStatic = mockStatic(UUIDConverter.class);
+ uuidConverterMockedStatic.when(() -> UUIDConverter.fromObjectId(KommentarTestFactory.ID))
+ .thenReturn(KOMMENTAR_UUID);
+ uuidConverterMockedStatic.when(() -> UUIDConverter.fromObjectId(attachment1.getId().toString()))
+ .thenReturn(ATTACHMENT1_UUID);
+ }
+
+ @AfterEach
+ void tearDown() {
+ uuidConverterMockedStatic.close();
+ }
+
+ @Test
+ void shouldHaveTyp() {
+ var dokumentType = builder.build();
+
+ assertThat(dokumentType.getTyp()).isEqualTo(TYP);
+ }
+
+ @Test
+ void shouldHaveIdentifikation() {
+ var expectedIdentifikation = new IdentifikationObjektType();
+ expectedIdentifikation.setID(KOMMENTAR_UUID);
+
+ var dokumentType = builder.build();
+
+ assertThat(dokumentType.getIdentifikation()).usingRecursiveComparison().isEqualTo(expectedIdentifikation);
+ }
+
+ @Nested
+ class TestAnlage {
+ @Test
+ void shouldHaveIdentifikation() {
+ var expectedIdentifikation = new IdentifikationObjektType();
+ expectedIdentifikation.setID(ATTACHMENT1_UUID);
+
+ var anlageType = getAnlage(IDX_ANLAGE_PDF);
+
+ assertThat(anlageType.getIdentifikation()).usingRecursiveComparison().isEqualTo(expectedIdentifikation);
+ }
+
+ @Nested
+ class TestVersion {
+ @Test
+ void shouldHaveNummer() {
+ var version = getVersion(IDX_ANLAGE_PDF);
+
+ assertThat(version.getNummer()).isEqualTo(VERSION_NUMMER);
+ }
+
+ private VersionType getVersion(int anlageIndex) {
+ var anlage = getAnlage(anlageIndex);
+ assertThat(anlage.getVersion()).hasSize(1);
+ return getAnlage(anlageIndex).getVersion().getFirst();
+ }
+
+ @Nested
+ class TestFormat {
+ @Test
+ void shouldHaveNameForPdf() {
+ var expectedDateiFormat = createDateiformatCode("018");
+
+ var format = getFormat(IDX_ANLAGE_PDF);
+
+ assertThat(format.getName()).usingRecursiveComparison().isEqualTo(expectedDateiFormat);
+ }
+
+ @ParameterizedTest
+ @MethodSource("shouldHaveNameForJpegDataProvider")
+ void shouldHaveNameForJpeg(int anlageIdx, String expectedCode) {
+ var expectedDateiFormat = createDateiformatCode(expectedCode);
+
+ var format = getFormat(anlageIdx);
+
+ assertThat(format.getName()).usingRecursiveComparison().isEqualTo(expectedDateiFormat);
+ }
+
+ private static Stream<Arguments> shouldHaveNameForJpegDataProvider() {
+ return Stream.of(
+ Arguments.of(IDX_ANLAGE_JPEG, "010"),
+ Arguments.of(IDX_ANLAGE_JPG, "011"));
+ }
+
+ private DateiformatCodeType createDateiformatCode(String codeValue) {
+ var dateiFormatCode = new DateiformatCodeType();
+ dateiFormatCode.setCode(codeValue);
+ dateiFormatCode.setListURI(VersionTypeBuilder.DATEI_FORMAT_LIST_URI);
+ dateiFormatCode.setListVersionID(VersionTypeBuilder.LIST_VERSION_ID);
+ return dateiFormatCode;
+ }
+
+ @Test
+ void shouldHaveVersion() {
+ var format = getFormat(IDX_ANLAGE_PDF);
+
+ assertThat(format.getVersion()).isEqualTo(StringUtils.EMPTY);
+
+ }
+
+ private FormatType getFormat(int anlageIndex) {
+ var version = getVersion(anlageIndex);
+ assertThat(version.getFormat()).hasSize(1);
+ return getVersion(anlageIndex).getFormat().getFirst();
+ }
+
+ @Nested
+ class TestPrimaerDokument {
+ @Test
+ void shouldHaveDateiname() {
+ var primaerdokument = getFormat(IDX_ANLAGE_PDF).getPrimaerdokument();
+
+ assertThat(primaerdokument.getDateiname())
+ .isEqualTo(ATTACHMENT1_UUID + "_" + attachment1.getName());
+
+ }
+
+ @Test
+ void shouldHaveDateinameOriginal() {
+ var primaerdokument = getFormat(IDX_ANLAGE_PDF).getPrimaerdokument();
+
+ assertThat(primaerdokument.getDateinameOriginal())
+ .isEqualTo(attachment1.getName());
+
+ }
+ }
+ }
+
+ }
+
+ private AnlageDokumentType getAnlage(int index) {
+ return builder.build().getAnlage().get(index);
+ }
+ }
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/kommentar/DokumentTypeBuilderTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/kommentar/DokumentTypeBuilderTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..e09747b371014cfb5b9b776f8fed4a533649421e
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/kommentar/DokumentTypeBuilderTest.java
@@ -0,0 +1,278 @@
+package de.ozgcloud.alfa.kommentar;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.List;
+
+import javax.xml.datatype.XMLGregorianCalendar;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.Spy;
+
+import com.thedeanda.lorem.LoremIpsum;
+
+import de.ozgcloud.alfa.common.AnlageDokumentTypeBuilder;
+import de.ozgcloud.alfa.common.AnlageDokumentTypeTestFactory;
+import de.ozgcloud.alfa.common.DateConverter;
+import de.ozgcloud.alfa.common.HistorienProtokollInformationTypeTestFactory;
+import de.ozgcloud.alfa.common.IdentifikationObjektTypeBuilder;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.ozgcloud.alfa.common.user.UserProfileTestFactory;
+import de.ozgcloud.alfa.export.IdentifikationObjektTypeTestFactory;
+import de.ozgcloud.alfa.vorgang.ZustaendigeStelleTestFactory;
+import de.xoev.xdomea.AnlageDokumentType;
+import de.xoev.xdomea.DokumentType;
+import de.xoev.xdomea.HistorienProtokollInformationType;
+import de.xoev.xdomea.IdentifikationObjektType;
+
+class DokumentTypeBuilderTest {
+
+ @Spy
+ private DokumentTypeBuilder builder = DokumentTypeBuilder.builder().withKommentar(KommentarTestFactory.create());
+
+ @Nested
+ class TestBuild {
+
+ private MockedStatic<IdentifikationObjektTypeBuilder> identifikationObjektTypeBuilderMockedStatic;
+ @Mock
+ private IdentifikationObjektTypeBuilder identifikationObjektTypeBuilder;
+ private final IdentifikationObjektType identifikationObjektType = IdentifikationObjektTypeTestFactory.create();
+
+ private final OzgFile ozgFile = OzgFileTestFactory.create();
+ private final AnlageDokumentType anlageDokumentType = AnlageDokumentTypeTestFactory.create();
+
+ private final HistorienProtokollInformationType historienProtokollInformationType = HistorienProtokollInformationTypeTestFactory.create();
+
+ @BeforeEach
+ void setUp() {
+ identifikationObjektTypeBuilderMockedStatic = mockStatic(IdentifikationObjektTypeBuilder.class);
+ identifikationObjektTypeBuilderMockedStatic.when(IdentifikationObjektTypeBuilder::builder).thenReturn(identifikationObjektTypeBuilder);
+ when(identifikationObjektTypeBuilder.withObjectID(KommentarTestFactory.ID)).thenReturn(identifikationObjektTypeBuilder);
+ when(identifikationObjektTypeBuilder.build()).thenReturn(identifikationObjektType);
+ doReturn(historienProtokollInformationType).when(builder).createHistorie();
+ }
+
+ @AfterEach
+ void tearDown() {
+ identifikationObjektTypeBuilderMockedStatic.close();
+ }
+
+ @Test
+ void shouldSetObjectId() {
+ builder.build();
+
+ verify(identifikationObjektTypeBuilder).withObjectID(KommentarTestFactory.ID);
+ }
+
+ @Test
+ void shouldBuildIdentifikationObjectType() {
+ builder.build();
+
+ verify(identifikationObjektTypeBuilder).build();
+ }
+
+ @Nested
+ class WithoutKommentareAttachments {
+
+ @Test
+ void shouldHaveIdentifikation() {
+ var dokumentType = builder.build();
+
+ assertThat(dokumentType.getIdentifikation()).isEqualTo(identifikationObjektType);
+ }
+
+ @Test
+ void shouldHaveTypNotiz() {
+ var dokumentType = builder.build();
+
+ assertThat(dokumentType.getTyp()).isEqualTo(DokumentTypeBuilder.TYP);
+ }
+ }
+
+ @Nested
+ class WithKommentareAttachments {
+
+ @BeforeEach
+ void setUp() {
+ doReturn(anlageDokumentType).when(builder).createAnlage(ozgFile);
+ }
+
+ @Test
+ void shouldCreateAnlagenForKommentarAttachments() {
+ builder.withKommentarAttachments(List.of(ozgFile)).build();
+
+ verify(builder).createAnlage(ozgFile);
+ }
+
+ @Test
+ void shouldHaveAnlagen() {
+ var dokumentType = builder.withKommentarAttachments(List.of(ozgFile)).build();
+
+ assertThat(dokumentType.getAnlage()).contains(anlageDokumentType);
+ }
+ }
+
+ @Test
+ void shouldHaveHistorienProtokoll() {
+ DokumentType dokumentType = builder.build();
+
+ assertThat(dokumentType.getHistorienProtokollInformation().get(0)).isEqualTo(historienProtokollInformationType);
+ }
+
+ @Test
+ void shouldHaveOneHistorienProtokoll() {
+ DokumentType dokumentType = builder.build();
+
+ assertThat(dokumentType.getHistorienProtokollInformation()).size().isEqualTo(1);
+ }
+
+ @Test
+ void shouldCreateHistorienProtokoll() {
+ builder.build();
+
+ verify(builder).createHistorie();
+ }
+
+ }
+
+ @Nested
+ class TestCreateAnlage {
+
+ private final OzgFile ozgFile = OzgFileTestFactory.create();
+
+ private MockedStatic<AnlageDokumentTypeBuilder> anlageDokumentTypeBuilderMockedStatic;
+ @Mock
+ private AnlageDokumentTypeBuilder anlageDokumentTypeBuilder;
+ private AnlageDokumentType expectedAnlage = AnlageDokumentTypeTestFactory.create();
+
+ @BeforeEach
+ void setUp() {
+ anlageDokumentTypeBuilderMockedStatic = mockStatic(AnlageDokumentTypeBuilder.class);
+ anlageDokumentTypeBuilderMockedStatic.when(AnlageDokumentTypeBuilder::builder).thenReturn(anlageDokumentTypeBuilder);
+ when(anlageDokumentTypeBuilder.withOzgFile(ozgFile)).thenReturn(anlageDokumentTypeBuilder);
+ when(anlageDokumentTypeBuilder.build()).thenReturn(expectedAnlage);
+ }
+
+ @AfterEach
+ void tearDown() {
+ anlageDokumentTypeBuilderMockedStatic.close();
+ }
+
+ @Test
+ void shouldSetOzgFile() {
+ callCreateAnlage();
+
+ verify(anlageDokumentTypeBuilder).withOzgFile(ozgFile);
+ }
+
+ @Test
+ void shouldBuildAnlageDokumentType() {
+ callCreateAnlage();
+
+ verify(anlageDokumentTypeBuilder).build();
+ }
+
+ @Test
+ void shouldReturnBuiltAnlage() {
+ var resultAnlage = callCreateAnlage();
+
+ assertThat(resultAnlage).isEqualTo(expectedAnlage);
+ }
+
+ private AnlageDokumentType callCreateAnlage() {
+ return builder.createAnlage(ozgFile);
+ }
+ }
+
+ @Nested
+ class TestWithOrganisationseinheitenID {
+ @Test
+ void shouldReturnBuilder() {
+ var result = builder.withOrganisationseinheitenID(ZustaendigeStelleTestFactory.ORGANISATIONSEINHEITEN_ID);
+
+ assertThat(result).isNotNull();
+ }
+ }
+
+ @Nested
+ class TestWithAuthorFullName {
+ @Test
+ void shouldReturnBuilder() {
+ var result = builder.withAuthorFullName(UserProfileTestFactory.FULLNAME);
+
+ assertThat(result).isNotNull();
+ }
+ }
+
+ @Nested
+ class TestCreateHistorie {
+
+ Kommentar kommentar = KommentarTestFactory.create();
+
+ @BeforeEach
+ void setupBuilder() {
+ builder.withKommentar(kommentar);
+ }
+
+ @Test
+ void shouldHaveMetadatumName() {
+ var historie = builder.createHistorie();
+
+ assertThat(historie.getMetadatumName()).isEqualTo(KommentarTestFactory.TEXT);
+ }
+
+ @Test
+ void shouldHaveAkteur() {
+ String expectedAkteurName = LoremIpsum.getInstance().getWords(5);
+ doReturn(expectedAkteurName).when(builder).createAkteur();
+
+ var historie = builder.createHistorie();
+
+ assertThat(historie.getAkteur()).isEqualTo(expectedAkteurName);
+ }
+
+ @Test
+ void shouldHaveDatumUhrzeit() {
+ var historie = builder.createHistorie();
+
+ assertThat(historie.getDatumUhrzeit()).isEqualTo(createExpectedDatumUhrzeit());
+ }
+
+ @Test
+ void shouldHaveAktion() {
+ var historie = builder.createHistorie();
+
+ assertThat(historie).hasFieldOrPropertyWithValue("aktion", DokumentTypeBuilder.AKTION);
+ }
+
+ private XMLGregorianCalendar createExpectedDatumUhrzeit() {
+ return DateConverter.toXmlGregorianCalendar(kommentar.getCreatedAt());
+ }
+ }
+
+ @Nested
+ class TestCreateAkteur {
+ @Test
+ void shouldCreateName() {
+ builder.withAuthorFullName(UserProfileTestFactory.FULLNAME);
+ builder.withOrganisationseinheitenID(ZustaendigeStelleTestFactory.ORGANISATIONSEINHEITEN_ID);
+
+ String akteur = builder.createAkteur();
+
+ assertThat(akteur).isEqualTo(createExpectedAkteurName());
+ }
+
+ private String createExpectedAkteurName() {
+ return UserProfileTestFactory.FULLNAME + "; " + ZustaendigeStelleTestFactory.ORGANISATIONSEINHEITEN_ID;
+ }
+
+ }
+
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/kommentar/ExportKommentarServiceTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/kommentar/ExportKommentarServiceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..66d5b18b2bb00cf80d1747fc2fa4804fba28dd48
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/kommentar/ExportKommentarServiceTest.java
@@ -0,0 +1,259 @@
+package de.ozgcloud.alfa.kommentar;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.Spy;
+
+import de.ozgcloud.alfa.common.binaryfile.BinaryFileService;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.user.UserId;
+import de.ozgcloud.alfa.common.user.UserProfileTestFactory;
+import de.ozgcloud.alfa.common.user.UserService;
+import de.ozgcloud.alfa.export.DokumentTypeTestFactory;
+import de.ozgcloud.alfa.kommentar.KommentarsExportData.KommentarsExportDataBuilder;
+import de.ozgcloud.alfa.vorgang.VorgangHeaderTestFactory;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingangTestFactory;
+import de.ozgcloud.alfa.vorgang.ZustaendigeStelleTestFactory;
+import de.xoev.xdomea.DokumentType;
+
+class ExportKommentarServiceTest {
+
+ @Spy
+ @InjectMocks
+ private ExportKommentarService service;
+
+ @Mock
+ private KommentarService kommentarService;
+ @Mock
+ private BinaryFileService binaryFileService;
+
+ @Mock
+ private UserService userService;
+
+ private final Kommentar kommentar = KommentarTestFactory.create();
+
+ @Nested
+ class TestCreateExportData {
+
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+ private final KommentarsExportData exportData = KommentarsExportDataTestFactory.create();
+
+ private final ExportKommentarService.KommentarExportData kommentarExportData = new ExportKommentarService.KommentarExportData(
+ ZustaendigeStelleTestFactory.ORGANISATIONSEINHEITEN_ID, kommentar);
+
+ private MockedStatic<KommentarsExportData> kommentarsExportDataMockedStatic;
+ @Mock
+ private KommentarsExportDataBuilder exportDataBuilder;
+
+ @BeforeEach
+ void setUp() {
+ kommentarsExportDataMockedStatic = mockStatic(KommentarsExportData.class);
+ kommentarsExportDataMockedStatic.when(KommentarsExportData::builder).thenReturn(exportDataBuilder);
+ when(service.getKommentare(vorgang)).thenReturn(Stream.of(kommentar));
+ when(service.createKommentarExportData(vorgang, kommentar)).thenReturn(kommentarExportData);
+ doNothing().when(service).addKommentarExportData(kommentarExportData, exportDataBuilder);
+ when(exportDataBuilder.build()).thenReturn(exportData);
+ }
+
+ @AfterEach
+ void tearDown() {
+ kommentarsExportDataMockedStatic.close();
+ }
+
+ @Test
+ void shouldAddKommentarExportData() {
+ callService();
+
+ verify(service).addKommentarExportData(eq(kommentarExportData), eq(exportDataBuilder));
+ }
+
+ @Test
+ void shouldBuildExportData() {
+ callService();
+
+ verify(exportDataBuilder).build();
+ }
+
+ @Test
+ void shouldReturnBuiltExportData() {
+ var result = callService();
+
+ assertThat(result).isEqualTo(exportData);
+ }
+
+ private KommentarsExportData callService() {
+ return service.createExportData(vorgang);
+ }
+ }
+
+ @Nested
+ class TestAddKommentarExportData {
+
+ private final String authorFullName = UserProfileTestFactory.FULLNAME;
+ private final List<OzgFile> attachments = List.of(KommentarsExportDataTestFactory.OZG_FILE);
+ private final DokumentType dokumentType = DokumentTypeTestFactory.create();
+ private final String organisationsEinheitenID = ZustaendigeStelleTestFactory.ORGANISATIONSEINHEITEN_ID;
+ private final ExportKommentarService.KommentarExportData kommentarExportData = new ExportKommentarService.KommentarExportData(
+ organisationsEinheitenID,
+ kommentar
+ );
+ private MockedStatic<DokumentTypeBuilder> dokumentTypeBuilderMockedStatic;
+ @Mock
+ private DokumentTypeBuilder dokumentTypeBuilder;
+ @Mock
+ private KommentarsExportDataBuilder exportDataBuilder;
+
+ @BeforeEach
+ void setUp() {
+ doReturn(attachments).when(service).getAttachments(kommentar);
+ doReturn(authorFullName).when(service).getAuthorFullName(kommentar);
+
+ dokumentTypeBuilderMockedStatic = mockStatic(DokumentTypeBuilder.class);
+ dokumentTypeBuilderMockedStatic.when(() -> DokumentTypeBuilder.builder()).thenReturn(dokumentTypeBuilder);
+
+ doReturn(dokumentTypeBuilder).when(dokumentTypeBuilder).withKommentarAttachments(attachments);
+ doReturn(dokumentTypeBuilder).when(dokumentTypeBuilder).withKommentar(kommentar);
+ doReturn(dokumentTypeBuilder).when(dokumentTypeBuilder)
+ .withOrganisationseinheitenID(ZustaendigeStelleTestFactory.ORGANISATIONSEINHEITEN_ID);
+ doReturn(dokumentTypeBuilder).when(dokumentTypeBuilder).withAuthorFullName(authorFullName);
+ doReturn(dokumentType).when(dokumentTypeBuilder).build();
+ }
+
+ @AfterEach
+ void tearDown() {
+ dokumentTypeBuilderMockedStatic.close();
+ }
+
+ @Test
+ void shouldSetDokumentType() {
+ callService();
+
+ verify(exportDataBuilder).dokumentType(dokumentType);
+ }
+
+ @Test
+ void shouldSetAttachments() {
+ callService();
+
+ verify(exportDataBuilder).attachments(attachments);
+ }
+
+ @Test
+ void shouldSetOzgFile() {
+ callService();
+
+ verify(dokumentTypeBuilder).withKommentarAttachments(attachments);
+ }
+
+ @Test
+ void shouldSetKommentar() {
+ callService();
+
+ verify(dokumentTypeBuilder).withKommentar(kommentar);
+ }
+
+ @Test
+ void shouldSetOrganisationseinheitID() {
+ callService();
+
+ verify(dokumentTypeBuilder).withOrganisationseinheitenID(organisationsEinheitenID);
+ }
+
+ @Test
+ void shouldReturnAuthorFullName() {
+ callService();
+
+ verify(dokumentTypeBuilder).withAuthorFullName(authorFullName);
+ }
+
+ @Test
+ void shouldBuildDokumentType() {
+ callService();
+
+ verify(dokumentTypeBuilder).build();
+ }
+
+ private void callService() {
+ service.addKommentarExportData(kommentarExportData, exportDataBuilder);
+ }
+ }
+
+ @Nested
+ class TestGetAttachments {
+
+ @Test
+ void shouldGetFiles() {
+ service.getAttachments(kommentar);
+
+ verify(binaryFileService).getFiles(KommentarTestFactory.ATTACHMENTS);
+ }
+
+ @Test
+ void shouldReturnAttachments() {
+ List<OzgFile> attachments = List.of(KommentarsExportDataTestFactory.OZG_FILE);
+ when(binaryFileService.getFiles(KommentarTestFactory.ATTACHMENTS)).thenReturn(attachments.stream());
+
+ var result = service.getAttachments(kommentar);
+
+ assertThat(result).isEqualTo(attachments);
+ }
+ }
+
+ @Nested
+ class TestGetAuthorFullName {
+
+ @BeforeEach
+ void init() {
+ when(userService.getById(UserProfileTestFactory.ID)).thenReturn(UserProfileTestFactory.create());
+ }
+
+ @Test
+ void shouldGetUser() {
+ service.getAuthorFullName(KommentarTestFactory.create());
+
+ verify(userService).getById(eq(UserId.from(KommentarTestFactory.CREATED_BY)));
+ }
+
+ @Test
+ void shouldReturnAuthorsFullName() {
+ var authorFullName = service.getAuthorFullName(KommentarTestFactory.create());
+
+ assertThat(authorFullName).isEqualTo(UserProfileTestFactory.FULLNAME);
+ }
+ }
+
+ @Nested
+ class TestGetKommentare {
+
+ private VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+
+ @Test
+ void shouldFindKommentareByVorgang() {
+ service.getKommentare(vorgang);
+
+ verify(kommentarService).findByVorgangId(VorgangHeaderTestFactory.ID);
+ }
+
+ @Test
+ void shouldReturnKommentare() {
+ when(kommentarService.findByVorgangId(VorgangHeaderTestFactory.ID)).thenReturn(Stream.of(kommentar));
+
+ var result = service.getKommentare(vorgang);
+
+ assertThat(result).containsExactly(kommentar);
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/kommentar/KommentarsExportDataTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/kommentar/KommentarsExportDataTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..a27b9da5f377ac5adf07be8cf939536b2edafb03
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/kommentar/KommentarsExportDataTestFactory.java
@@ -0,0 +1,23 @@
+package de.ozgcloud.alfa.kommentar;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.ozgcloud.alfa.export.DokumentTypeTestFactory;
+import de.ozgcloud.alfa.kommentar.KommentarsExportData.KommentarsExportDataBuilder;
+import de.xoev.xdomea.DokumentType;
+
+public class KommentarsExportDataTestFactory {
+
+ public static final DokumentType DOKUMENT_TYPE = DokumentTypeTestFactory.create();
+ public static final OzgFile OZG_FILE = OzgFileTestFactory.createWithUniqueId();
+
+ public static KommentarsExportData create() {
+ return createBuilder().build();
+ }
+
+ public static KommentarsExportDataBuilder createBuilder() {
+ return KommentarsExportData.builder()
+ .dokumentType(DOKUMENT_TYPE)
+ .attachment(OZG_FILE);
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/postfach/DokumentTypeBuilderTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/postfach/DokumentTypeBuilderTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..92f88ef542e125d0c0054564bfca590d0b0d5b32
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/postfach/DokumentTypeBuilderTest.java
@@ -0,0 +1,297 @@
+package de.ozgcloud.alfa.postfach;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.time.ZonedDateTime;
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.Spy;
+
+import de.ozgcloud.alfa.common.AnlageDokumentTypeBuilder;
+import de.ozgcloud.alfa.common.AnlageDokumentTypeTestFactory;
+import de.ozgcloud.alfa.common.DateConverter;
+import de.ozgcloud.alfa.common.HistorienProtokollInformationTypeTestFactory;
+import de.ozgcloud.alfa.common.IdentifikationObjektTypeBuilder;
+import de.ozgcloud.alfa.common.binaryfile.BinaryFileTestFactory;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.ozgcloud.alfa.common.user.UserProfile;
+import de.ozgcloud.alfa.common.user.UserProfileTestFactory;
+import de.ozgcloud.alfa.export.IdentifikationObjektTypeTestFactory;
+import de.ozgcloud.alfa.postfach.PostfachMail.Direction;
+import de.ozgcloud.alfa.vorgang.ZustaendigeStelleTestFactory;
+import de.xoev.xdomea.AnlageDokumentType;
+import de.xoev.xdomea.HistorienProtokollInformationType;
+import de.xoev.xdomea.IdentifikationObjektType;
+
+public class DokumentTypeBuilderTest {
+
+ private final PostfachMail postfachMail = PostfachMailTestFactory.create();
+ private final OzgFile ozgFile = OzgFileTestFactory.createBuilder().id(BinaryFileTestFactory.FILE_ID).build();
+
+ @Spy
+ @InjectMocks
+ private final DokumentTypeBuilder builder = DokumentTypeBuilder.builder()
+ .withPostfachMail(postfachMail)
+ .withOzgFiles(List.of(ozgFile))
+ .withOrganisationseinheitenId(ZustaendigeStelleTestFactory.ORGANISATIONSEINHEITEN_ID);
+
+ @Nested
+ class TestBuild {
+ private static final String TYP = "Nachricht";
+
+ private MockedStatic<IdentifikationObjektTypeBuilder> identifikationObjektTypeBuilderMockedStatic;
+ @Mock
+ private IdentifikationObjektTypeBuilder identifikationObjektTypeBuilder;
+ private final IdentifikationObjektType identifikationObjektType = IdentifikationObjektTypeTestFactory.create();
+
+ private final AnlageDokumentType anlageDokument = AnlageDokumentTypeTestFactory.create();
+ private final HistorienProtokollInformationType historienProtokollInformation = HistorienProtokollInformationTypeTestFactory.create();
+
+ @BeforeEach
+ void setUp() {
+ identifikationObjektTypeBuilderMockedStatic = mockStatic(IdentifikationObjektTypeBuilder.class);
+ identifikationObjektTypeBuilderMockedStatic.when(IdentifikationObjektTypeBuilder::builder).thenReturn(identifikationObjektTypeBuilder);
+ when(identifikationObjektTypeBuilder.withObjectID(PostfachMailTestFactory.ID)).thenReturn(identifikationObjektTypeBuilder);
+ when(identifikationObjektTypeBuilder.build()).thenReturn(identifikationObjektType);
+
+ doReturn(historienProtokollInformation).when(builder).createHistorienProtokollInformation();
+ }
+
+ @AfterEach
+ void tearDown() {
+ identifikationObjektTypeBuilderMockedStatic.close();
+ }
+
+ @Nested
+ class TestWithOneAnlage {
+ @BeforeEach
+ void mockCreateAnlage() {
+ doReturn(anlageDokument).when(builder).createAnlage(ozgFile);
+ }
+
+ @Test
+ void shouldSetObjectId() {
+ builder.build();
+
+ verify(identifikationObjektTypeBuilder).withObjectID(postfachMail.getId());
+ }
+
+ @Test
+ void shouldBuildIdentifikationObjectType() {
+ builder.build();
+
+ verify(identifikationObjektTypeBuilder).build();
+ }
+
+ @Test
+ void shouldHaveIdentifikation() {
+ var dokument = builder.build();
+
+ assertThat(dokument.getIdentifikation()).isEqualTo(identifikationObjektType);
+ }
+
+ @Test
+ void shouldHaveTyp() {
+ var dokument = builder.build();
+
+ assertThat(dokument.getTyp()).isEqualTo(TYP);
+ }
+
+ @Test
+ void shouldHaveHistorienProtokollInformation() {
+ var dokument = builder.build();
+
+ assertThat(dokument.getHistorienProtokollInformation()).containsExactly(historienProtokollInformation);
+ }
+
+ @Test
+ void shouldCallCreateAnlage() {
+ builder.build();
+
+ verify(builder).createAnlage(ozgFile);
+ }
+
+ @Test
+ void shouldHaveOneAnlage() {
+ var dokument = builder.build();
+
+ assertThat(dokument.getAnlage()).containsExactly(anlageDokument);
+ }
+ }
+
+ @Nested
+ class TestWithoutAnlage {
+ @Test
+ void shouldHaveNoAnlage() {
+ var dokument = builder.withOzgFiles(Collections.emptyList()).build();
+
+ assertThat(dokument.getAnlage()).isEmpty();
+ }
+ }
+ }
+
+ @Nested
+ class TestCreateHistorienProtokollInformation {
+ private static final String AKTEUR = "correct aktuer";
+ private static final String NACHRICHT_EMPFANGEN = "Nachricht empfangen";
+ private static final String NACHRICHT_GESENDET = "Nachricht gesendet";
+
+ @BeforeEach
+ void setUpMock() {
+ doReturn(AKTEUR).when(builder).getAkteur();
+ doReturn(PostfachMailTestFactory.CREATED_AT).when(builder).getSentTime();
+ }
+
+ @Test
+ void shouldHaveMetadatumName() {
+ var resultHistorie = callCreateHistorienProtokollInformation();
+
+ assertThat(resultHistorie.getMetadatumName()).isEqualTo(PostfachMailTestFactory.MAIL_BODY);
+ }
+
+ @Test
+ void shouldHaveAkteur() {
+ var resultHistorie = callCreateHistorienProtokollInformation();
+
+ assertThat(resultHistorie.getAkteur()).isEqualTo(AKTEUR);
+ }
+
+ @Test
+ void shouldCallGetSentTime() {
+ callCreateHistorienProtokollInformation();
+
+ verify(builder).getSentTime();
+ }
+
+ @Test
+ void shouldHaveDatumUhrzeit() {
+ var resultHistorie = callCreateHistorienProtokollInformation();
+
+ assertThat(resultHistorie.getDatumUhrzeit()).isEqualTo(DateConverter.toXmlGregorianCalendar(PostfachMailTestFactory.CREATED_AT));
+ }
+
+ @Test
+ void shouldReturnAktionWithGesendet() {
+ builder.withPostfachMail(PostfachMailTestFactory.createBuilder().direction(Direction.OUT).build());
+
+ var resultHistorie = callCreateHistorienProtokollInformation();
+
+ assertThat(resultHistorie.getAktion()).isEqualTo(NACHRICHT_GESENDET);
+ }
+
+ @Test
+ void shouldReturnAktionWithEmpfangen() {
+ builder.withPostfachMail(PostfachMailTestFactory.createBuilder().direction(Direction.IN).build());
+
+ var resultHistorie = callCreateHistorienProtokollInformation();
+
+ assertThat(resultHistorie.getAktion()).isEqualTo(NACHRICHT_EMPFANGEN);
+ }
+
+ private HistorienProtokollInformationType callCreateHistorienProtokollInformation() {
+ return builder.createHistorienProtokollInformation();
+ }
+ }
+
+ @Nested
+ class TestGetAkteur {
+ private final UserProfile userProfile = UserProfileTestFactory.create();
+
+ @Test
+ void shouldReturnNameAndOrgaIdOfBearbeiter() {
+ builder.withUserProfile(userProfile);
+
+ var akteur = builder.getAkteur();
+
+ assertThat(akteur).isEqualTo(UserProfileTestFactory.FULLNAME + "; " + ZustaendigeStelleTestFactory.ORGANISATIONSEINHEITEN_ID);
+ }
+
+ @Test
+ void shouldReturnAntragsteller() {
+ builder.withUserProfile(null);
+
+ var akteur = builder.getAkteur();
+
+ assertThat(akteur).isEqualTo("Antragsteller");
+ }
+ }
+
+ @Nested
+ class TestCreateAnlage {
+ private MockedStatic<AnlageDokumentTypeBuilder> anlageDokumentTypeBuilderMockedStatic;
+ @Mock
+ private AnlageDokumentTypeBuilder anlageDokumentTypeBuilder;
+ private AnlageDokumentType expectedAnlage = AnlageDokumentTypeTestFactory.create();
+
+ @BeforeEach
+ void setUp() {
+ anlageDokumentTypeBuilderMockedStatic = mockStatic(AnlageDokumentTypeBuilder.class);
+ anlageDokumentTypeBuilderMockedStatic.when(AnlageDokumentTypeBuilder::builder).thenReturn(anlageDokumentTypeBuilder);
+ when(anlageDokumentTypeBuilder.withOzgFile(ozgFile)).thenReturn(anlageDokumentTypeBuilder);
+ when(anlageDokumentTypeBuilder.build()).thenReturn(expectedAnlage);
+ }
+
+ @AfterEach
+ void tearDown() {
+ anlageDokumentTypeBuilderMockedStatic.close();
+ }
+
+ @Test
+ void shouldSetOzgFile() {
+ callCreateAnlage();
+
+ verify(anlageDokumentTypeBuilder).withOzgFile(ozgFile);
+ }
+
+ @Test
+ void shouldBuildAnlageDokumentType() {
+ callCreateAnlage();
+
+ verify(anlageDokumentTypeBuilder).build();
+ }
+
+ @Test
+ void shouldReturnBuiltAnlage() {
+ var resultAnlage = callCreateAnlage();
+
+ assertThat(resultAnlage).isEqualTo(expectedAnlage);
+ }
+
+ private AnlageDokumentType callCreateAnlage() {
+ return builder.createAnlage(ozgFile);
+ }
+ }
+
+ @Nested
+ class TestGetSentTime {
+ private final ZonedDateTime testTime = ZonedDateTime.now().withNano(0);
+
+ @Test
+ void shouldReturnCreatedAtForIncoming() {
+ builder.withPostfachMail(PostfachMailTestFactory.createBuilder().direction(Direction.IN).createdAt(testTime).build());
+
+ var resultTime = builder.getSentTime();
+
+ assertThat(resultTime).isEqualTo(testTime);
+ }
+
+ @Test
+ void shouldReturnSentAtForOutgoing() {
+ builder.withPostfachMail(PostfachMailTestFactory.createBuilder().direction(Direction.OUT).sentAt(testTime).build());
+
+ var resultTime = builder.getSentTime();
+
+ assertThat(resultTime).isEqualTo(testTime);
+ }
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/postfach/ExportNachrichtServiceTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/postfach/ExportNachrichtServiceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..b72bbbf4aa5d1b736b8b55751111154e64564023
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/postfach/ExportNachrichtServiceTest.java
@@ -0,0 +1,342 @@
+package de.ozgcloud.alfa.postfach;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentMatcher;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.Spy;
+
+import de.ozgcloud.alfa.common.binaryfile.BinaryFileService;
+import de.ozgcloud.alfa.common.binaryfile.BinaryFileTestFactory;
+import de.ozgcloud.alfa.common.binaryfile.FileId;
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.ozgcloud.alfa.common.user.UserProfile;
+import de.ozgcloud.alfa.common.user.UserProfileTestFactory;
+import de.ozgcloud.alfa.common.user.UserService;
+import de.ozgcloud.alfa.export.DokumentTypeTestFactory;
+import de.ozgcloud.alfa.postfach.PostfachMailExportData.PostfachMailExportDataBuilder;
+import de.ozgcloud.alfa.vorgang.VorgangHeaderTestFactory;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingang;
+import de.ozgcloud.alfa.vorgang.VorgangWithEingangTestFactory;
+import de.xoev.xdomea.DokumentType;
+
+class ExportNachrichtServiceTest {
+
+ @Spy
+ @InjectMocks
+ private ExportNachrichtService service;
+
+ @Mock
+ private PostfachMailService postfachMailService;
+
+ @Mock
+ private UserService userService;
+
+ @Mock
+ private BinaryFileService binaryFileService;
+
+ @Nested
+ class TestCreateExportData {
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+ private final PostfachMail postfachMail = PostfachMailTestFactory.create();
+ private final List<OzgFile> attachments = List.of(OzgFileTestFactory.create());
+ private final PostfachMailExportData exportData = PostfachMailExportDataTestFactory.create();
+
+ private final ArgumentMatcher<PostfachMailExportInput> exportInputMatcher = input -> input.postfachMail().equals(postfachMail)
+ && input.organisationseinheitenId().equals(PostfachMailExportInputTestFactory.ORGANISATIONSEINHEITEN_ID)
+ && input.attachments().equals(attachments);
+
+ private MockedStatic<PostfachMailExportData> postfachMailExportDataMockedStatic;
+ @Mock
+ private PostfachMailExportDataBuilder exportDataBuilder;
+
+ @BeforeEach
+ void setUpMock() {
+ postfachMailExportDataMockedStatic = mockStatic(PostfachMailExportData.class);
+ postfachMailExportDataMockedStatic.when(PostfachMailExportData::builder).thenReturn(exportDataBuilder);
+ doReturn(Stream.of(postfachMail)).when(service).getPostfachMails(VorgangHeaderTestFactory.ID);
+ doReturn(attachments).when(service).getAttachments(postfachMail);
+ doNothing().when(service).addPostfachMailExportData(argThat(exportInputMatcher), eq(exportDataBuilder));
+ when(exportDataBuilder.build()).thenReturn(exportData);
+ }
+
+ @AfterEach
+ void tearDown() {
+ postfachMailExportDataMockedStatic.close();
+ }
+
+ @Test
+ void shouldgetPostfachMails() {
+ callService();
+
+ verify(service).getPostfachMails(vorgang.getId());
+ }
+
+ @Test
+ void shouldCallGetAttachents() {
+ callService();
+
+ verify(service).getAttachments(postfachMail);
+ }
+
+ @Test
+ void shouldAddInputToBuilder() {
+ callService();
+
+ verify(service).addPostfachMailExportData(argThat(exportInputMatcher), eq(exportDataBuilder));
+ }
+
+ @Test
+ void shouldBuildExportData() {
+ callService();
+
+ verify(exportDataBuilder).build();
+ }
+
+ @Test
+ void shouldReturnBuiltExportData() {
+ var result = callService();
+
+ assertThat(result).isEqualTo(exportData);
+ }
+
+ private PostfachMailExportData callService() {
+ return service.createExportData(vorgang);
+ }
+ }
+
+ @Nested
+ class TestAddPostfachMailExportData {
+ private final List<OzgFile> attachments = PostfachMailExportInputTestFactory.ATTACHMENTS;
+ private final DokumentType dokumentType = DokumentTypeTestFactory.create();
+ private final PostfachMailExportInput exportInput = PostfachMailExportInputTestFactory.create();
+
+ @Mock
+ private PostfachMailExportDataBuilder exportDataBuilder;
+
+ @BeforeEach
+ void setUpMocks() {
+ doReturn(dokumentType).when(service).buildDokumentType(exportInput);
+ }
+
+ @Test
+ void shouldAddAttachmentsToBuilder() {
+ callService();
+
+ verify(exportDataBuilder).attachments(attachments);
+ }
+
+ @Test
+ void shouldBuildDokumentType() {
+ callService();
+
+ verify(service).buildDokumentType(exportInput);
+ }
+
+ @Test
+ void shouldAddDokumentTypeToBuilder() {
+ callService();
+
+ verify(exportDataBuilder).dokumentType(dokumentType);
+ }
+
+ private void callService() {
+ service.addPostfachMailExportData(exportInput, exportDataBuilder);
+ }
+ }
+
+ @Nested
+ class TestGetPostfachMails {
+ private final PostfachMail postfachMail = PostfachMailTestFactory.create();
+
+ @Test
+ void shouldCallPostfachMailServiceGetAll() {
+ service.getPostfachMails(VorgangHeaderTestFactory.ID);
+
+ verify(postfachMailService).getAll(VorgangHeaderTestFactory.ID);
+ }
+
+ @Test
+ void shouldReturnPostfachMails() {
+ when(postfachMailService.getAll(VorgangHeaderTestFactory.ID)).thenReturn(Stream.of(postfachMail));
+
+ var postfachMails = service.getPostfachMails(VorgangHeaderTestFactory.ID);
+
+ assertThat(postfachMails).containsExactly(postfachMail);
+ }
+ }
+
+ @Nested
+ class TestBuildDokumentType {
+ private final PostfachMailExportInput exportInput = PostfachMailExportInputTestFactory.create();
+ private final PostfachMail postfachMail = PostfachMailExportInputTestFactory.POSTFACH_MAIL;
+ private final List<OzgFile> attachments = PostfachMailExportInputTestFactory.ATTACHMENTS;
+ private final UserProfile userProfile = UserProfileTestFactory.create();
+
+ private MockedStatic<DokumentTypeBuilder> dokumentTypeBuilderMockedStatic;
+ @Mock
+ private DokumentTypeBuilder dokumentTypeBuilder;
+
+ @BeforeEach
+ void setUp() {
+ dokumentTypeBuilderMockedStatic = mockStatic(DokumentTypeBuilder.class);
+ dokumentTypeBuilderMockedStatic.when(DokumentTypeBuilder::builder).thenReturn(dokumentTypeBuilder);
+
+ when(dokumentTypeBuilder.withPostfachMail(postfachMail)).thenReturn(dokumentTypeBuilder);
+ when(dokumentTypeBuilder.withOzgFiles(attachments)).thenReturn(dokumentTypeBuilder);
+ when(dokumentTypeBuilder.withUserProfile(userProfile)).thenReturn(dokumentTypeBuilder);
+ when(dokumentTypeBuilder.withOrganisationseinheitenId(PostfachMailExportInputTestFactory.ORGANISATIONSEINHEITEN_ID))
+ .thenReturn(dokumentTypeBuilder);
+ doReturn(Optional.of(userProfile)).when(service).getUserProfile(postfachMail);
+ }
+
+ @AfterEach
+ void tearDown() {
+ dokumentTypeBuilderMockedStatic.close();
+ }
+
+ @Test
+ void shouldCallBuilder() {
+ callService();
+
+ dokumentTypeBuilderMockedStatic.verify(() -> DokumentTypeBuilder.builder());
+ }
+
+ @Test
+ void shouldCallGetUserProfile() {
+ callService();
+
+ verify(service).getUserProfile(postfachMail);
+ }
+
+ @Test
+ void shouldBuildWithPostfachMail() {
+ callService();
+
+ verify(dokumentTypeBuilder).withPostfachMail(postfachMail);
+ }
+
+ @Test
+ void shouldBuildWithOzgFiles() {
+ callService();
+
+ verify(dokumentTypeBuilder).withOzgFiles(attachments);
+ }
+
+ @Test
+ void shouldBuildWithUserProfile() {
+ callService();
+
+ verify(dokumentTypeBuilder).withUserProfile(userProfile);
+ }
+
+ @Test
+ void shouldBuildWithOrganisationseinheitenId() {
+ callService();
+
+ verify(dokumentTypeBuilder).withOrganisationseinheitenId(PostfachMailExportInputTestFactory.ORGANISATIONSEINHEITEN_ID);
+ }
+
+ @Test
+ void shouldBuild() {
+ callService();
+
+ verify(dokumentTypeBuilder).build();
+ }
+
+ @Test
+ void shouldReturnBuiltDokumentType() {
+ var expectedDokumentType = DokumentTypeTestFactory.create();
+ when(dokumentTypeBuilder.build()).thenReturn(expectedDokumentType);
+
+ var resultDokumentType = callService();
+
+ assertThat(resultDokumentType).isEqualTo(expectedDokumentType);
+ }
+
+ private DokumentType callService() {
+ return service.buildDokumentType(exportInput);
+ }
+ }
+
+ @Nested
+ class TestGetAttachments {
+ private final PostfachMail postfachMail = PostfachMailTestFactory.create();
+ private final List<FileId> fileIds = List.of(BinaryFileTestFactory.FILE_ID);
+
+ @Test
+ void shouldCallBinaryFileServiceGetFile() {
+ service.getAttachments(postfachMail);
+
+ verify(binaryFileService).getFiles(fileIds);
+ }
+
+ @Test
+ void shouldReturnGottenOzgFiles() {
+ var expectedOzgFile = OzgFileTestFactory.create();
+ when(binaryFileService.getFiles(fileIds)).thenReturn(Stream.of(expectedOzgFile));
+
+ var resultOzgFiles = service.getAttachments(postfachMail);
+
+ assertThat(resultOzgFiles).containsExactly(expectedOzgFile);
+ }
+ }
+
+ @Nested
+ class TestGetUserProfile {
+ @Nested
+ class TestWithNullUserId {
+ @Test
+ void shouldReturnEmptyOptional() {
+ var postfachMail = PostfachMailTestFactory.createBuilder().createdBy(null).build();
+
+ var userProfile = callService(postfachMail);
+
+ assertThat(userProfile).isEmpty();
+ }
+ }
+
+ @Nested
+ class TestWithValidUserId {
+ private PostfachMail postfachMail = PostfachMailTestFactory.create();
+ private UserProfile expectedUserProfile = UserProfileTestFactory.create();
+
+ @BeforeEach
+ void mockUserService() {
+ when(userService.getById(postfachMail.getCreatedBy())).thenReturn(expectedUserProfile);
+ }
+
+ @Test
+ void shouldCallUserServiceGetbyId() {
+ callService(postfachMail);
+
+ verify(userService).getById(PostfachMailTestFactory.CREATED_BY);
+ }
+
+ @Test
+ void shouldReturnOptionalOfUserProfile() {
+ var userProfile = callService(postfachMail);
+
+ assertThat(userProfile).contains(expectedUserProfile);
+ }
+
+ }
+
+ private Optional<UserProfile> callService(PostfachMail postfachMail) {
+ return service.getUserProfile(postfachMail);
+ }
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/postfach/PostfachMailExportDataTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/postfach/PostfachMailExportDataTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..8e121779722428e9a71a6022d62304e0f841b49f
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/postfach/PostfachMailExportDataTestFactory.java
@@ -0,0 +1,23 @@
+package de.ozgcloud.alfa.postfach;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.ozgcloud.alfa.export.DokumentTypeTestFactory;
+import de.ozgcloud.alfa.postfach.PostfachMailExportData.PostfachMailExportDataBuilder;
+import de.xoev.xdomea.DokumentType;
+
+public class PostfachMailExportDataTestFactory {
+
+ public static final DokumentType DOKUMENT_TYPE = DokumentTypeTestFactory.create();
+ public static final OzgFile OZG_FILE = OzgFileTestFactory.createWithUniqueId();
+
+ public static PostfachMailExportData create() {
+ return createBuilder().build();
+ }
+
+ public static PostfachMailExportDataBuilder createBuilder() {
+ return PostfachMailExportData.builder()
+ .dokumentType(DOKUMENT_TYPE)
+ .attachment(OZG_FILE);
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/postfach/PostfachMailExportInputTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/postfach/PostfachMailExportInputTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..7a712bb7fc5552f3816bd86ecaf5c902421dc157
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/postfach/PostfachMailExportInputTestFactory.java
@@ -0,0 +1,19 @@
+package de.ozgcloud.alfa.postfach;
+
+import java.util.List;
+
+import de.ozgcloud.alfa.common.file.OzgFile;
+import de.ozgcloud.alfa.common.file.OzgFileTestFactory;
+import de.ozgcloud.alfa.vorgang.ZustaendigeStelleTestFactory;
+
+public class PostfachMailExportInputTestFactory {
+
+ public final static PostfachMail POSTFACH_MAIL = PostfachMailTestFactory.create();
+ public final static String ORGANISATIONSEINHEITEN_ID = ZustaendigeStelleTestFactory.ORGANISATIONSEINHEITEN_ID;
+ public final static List<OzgFile> ATTACHMENTS = List.of(OzgFileTestFactory.create());
+
+ public static PostfachMailExportInput create() {
+ return new PostfachMailExportInput(POSTFACH_MAIL, ORGANISATIONSEINHEITEN_ID, ATTACHMENTS);
+ }
+
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/AntragsdatenItemTypeTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/AntragsdatenItemTypeTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..78beaf2e220c513cd516506ea459a848fa4964f3
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/AntragsdatenItemTypeTestFactory.java
@@ -0,0 +1,47 @@
+package de.ozgcloud.alfa.vorgang;
+
+import java.util.List;
+
+import de.xoev.xdomea.AntragsdatenGroupType;
+import de.xoev.xdomea.AntragsdatenItemType;
+import de.xoev.xdomea.AntragsdatenMultiValueFieldType;
+import de.xoev.xdomea.AntragsdatenSingleValueFieldType;
+import de.xoev.xdomea.DatatypeType;
+
+public class AntragsdatenItemTypeTestFactory {
+
+ public static final String KEY_STRING = "string";
+ public static final String KEY_MAP = "map";
+ public static final String KEY_COLLECTION = "collection";
+ public static final String VALUE_STRING = "value1";
+ public static final Integer VALUE_INTEGER = 1;
+
+ public static AntragsdatenSingleValueFieldType createSingleValueField() {
+ var antragsdatenItemType = new AntragsdatenSingleValueFieldType();
+ antragsdatenItemType.setType(DatatypeType.STRING);
+ antragsdatenItemType.setName(KEY_STRING);
+ antragsdatenItemType.setValue(VALUE_STRING);
+ return antragsdatenItemType;
+ }
+
+ public static AntragsdatenMultiValueFieldType createMultiValueField() {
+ var antragsdatenItemType = new AntragsdatenMultiValueFieldType();
+ antragsdatenItemType.setType(DatatypeType.INTEGER);
+ antragsdatenItemType.setName(KEY_COLLECTION);
+ antragsdatenItemType.getValue().add(VALUE_INTEGER);
+ return antragsdatenItemType;
+ }
+
+ public static AntragsdatenGroupType createGroup() {
+ var antragsdatenGroupType = new AntragsdatenGroupType();
+ antragsdatenGroupType.setName(KEY_MAP);
+
+ antragsdatenGroupType.getItem().addAll(createAntragsdatenItemTypes());
+
+ return antragsdatenGroupType;
+ }
+
+ public static List<AntragsdatenItemType> createAntragsdatenItemTypes() {
+ return List.of(createMultiValueField(), createSingleValueField());
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/AnwendungsspezifischeErweiterungTypeCreatorTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/AnwendungsspezifischeErweiterungTypeCreatorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..ce274988405747bdcb4c47960c7b96699db5896d
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/AnwendungsspezifischeErweiterungTypeCreatorTest.java
@@ -0,0 +1,69 @@
+package de.ozgcloud.alfa.vorgang;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Spy;
+
+import de.xoev.xdomea.AnwendungsspezifischeErweiterungType;
+import de.xoev.xdomea.FeldgruppeType;
+
+class AnwendungsspezifischeErweiterungTypeCreatorTest {
+
+ @Spy
+ @InjectMocks
+ private AnwendungsspezifischeErweiterungTypeCreator creator;
+
+ @Mock
+ private FeldGruppeTypeCreator feldGruppeTypeCreator;
+
+ @Nested
+ class TestCreate {
+
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+ private final FeldgruppeType feldgruppeType = new FeldgruppeType();
+
+ @BeforeEach
+ void init() {
+ when(feldGruppeTypeCreator.create(vorgang)).thenReturn(feldgruppeType);
+ }
+
+ @Test
+ void shouldHaveKennung() {
+ var anwendungsspezifischeErweiterung = create();
+
+ assertThat(anwendungsspezifischeErweiterung.getKennung()).isEqualTo(AnwendungsspezifischeErweiterungTypeCreator.KENNUNG);
+ }
+
+ @Test
+ void shouldHaveName() {
+ var anwendungsspezifischeErweiterung = create();
+
+ assertThat(anwendungsspezifischeErweiterung.getName()).isEqualTo(AnwendungsspezifischeErweiterungTypeCreator.NAME);
+ }
+
+ @Test
+ void shouldCallFeldgrupperMapper() {
+ create();
+
+ verify(feldGruppeTypeCreator).create(vorgang);
+ }
+
+ @Test
+ void shouldHaveFeldGruppe() {
+ var anwendungsspezifischeErweiterung = create();
+
+ assertThat(anwendungsspezifischeErweiterung.getFeldgruppe()).hasSize(1).first().isEqualTo(feldgruppeType);
+ }
+
+ private AnwendungsspezifischeErweiterungType create() {
+ return creator.create(vorgang);
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/AnwendungsspezifischeErweiterungTypeTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/AnwendungsspezifischeErweiterungTypeTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..c23de6fe41c1d9ff17d9395478793d9830de4280
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/AnwendungsspezifischeErweiterungTypeTestFactory.java
@@ -0,0 +1,10 @@
+package de.ozgcloud.alfa.vorgang;
+
+import de.xoev.xdomea.AnwendungsspezifischeErweiterungType;
+
+public class AnwendungsspezifischeErweiterungTypeTestFactory {
+
+ public static AnwendungsspezifischeErweiterungType create() {
+ return new AnwendungsspezifischeErweiterungType();
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/AnwendungsspezifischeErweiterungXMLTypeCreatorTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/AnwendungsspezifischeErweiterungXMLTypeCreatorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..554dd1f7d98990b064a334d55217db0b40837f73
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/AnwendungsspezifischeErweiterungXMLTypeCreatorTest.java
@@ -0,0 +1,53 @@
+package de.ozgcloud.alfa.vorgang;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Spy;
+
+import de.xoev.xdomea.Antragsdaten;
+import de.xoev.xdomea.AnwendungsspezifischeErweiterungXMLType;
+
+public class AnwendungsspezifischeErweiterungXMLTypeCreatorTest {
+
+ @Spy
+ @InjectMocks
+ private AnwendungsspezifischeErweiterungXMLTypeCreator creator;
+ @Mock
+ private FormDataMapper formDataMapper;
+
+ @Nested
+ class TestCreate {
+
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+ private final Antragsdaten Antragsdaten = new Antragsdaten();
+
+ @BeforeEach
+ void init() {
+ when(formDataMapper.toAntragsdaten(any())).thenReturn(Antragsdaten);
+ }
+
+ @Test
+ void shouldCallFormDataMapper() {
+ create();
+
+ verify(formDataMapper).toAntragsdaten(vorgang);
+ }
+
+ @Test
+ void shouldHaveAntragsdaten() {
+ var anwendungsspezifischeErweiterung = create();
+
+ assertThat(anwendungsspezifischeErweiterung.getAny()).hasSize(1).first().isEqualTo(Antragsdaten);
+ }
+
+ private AnwendungsspezifischeErweiterungXMLType create() {
+ return creator.create(vorgang);
+ }
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/DatatypeMapperTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/DatatypeMapperTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..2fc79e9adf1c6d41b455c8baf7679b1c53435b9b
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/DatatypeMapperTest.java
@@ -0,0 +1,89 @@
+package de.ozgcloud.alfa.vorgang;
+
+import static org.assertj.core.api.Assertions.*;
+
+import java.time.LocalDate;
+import java.time.ZonedDateTime;
+import java.util.List;
+
+import org.apache.commons.lang3.StringUtils;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.NullSource;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.mockito.InjectMocks;
+
+import de.xoev.xdomea.DatatypeType;
+
+class DatatypeMapperTest {
+
+ @InjectMocks
+ private DatatypeMapper datatypeMapper;
+
+ @DisplayName("should return DatatypeType STRING when")
+ @ParameterizedTest(name = "\"{0}\"")
+ @NullSource
+ @ValueSource(strings = { StringUtils.EMPTY, "a" })
+ void shouldReturnString(String arg) {
+ var datatype = datatypeMapper.from(arg);
+
+ assertThat(datatype).isEqualTo(DatatypeType.STRING);
+ }
+
+ @Test
+ void shouldReturnStringAsDefault() {
+ var datatype = datatypeMapper.from(new Object());
+
+ assertThat(datatype).isEqualTo(DatatypeType.STRING);
+ }
+
+ @Test
+ void shouldReturnDate() {
+ var datatype = datatypeMapper.from(LocalDate.now());
+
+ assertThat(datatype).isEqualTo(DatatypeType.DATE);
+ }
+
+ @Test
+ void shouldReturnDatetime() {
+ var datatype = datatypeMapper.from(ZonedDateTime.now());
+
+ assertThat(datatype).isEqualTo(DatatypeType.DATETIME);
+ }
+
+ @Test
+ void shouldReturnInteger() {
+ var datatype = datatypeMapper.from(1);
+
+ assertThat(datatype).isEqualTo(DatatypeType.INTEGER);
+ }
+
+ @Test
+ void shouldReturnFloat() {
+ var datatype = datatypeMapper.from(1.0f);
+
+ assertThat(datatype).isEqualTo(DatatypeType.FLOAT);
+ }
+
+ @Test
+ void shouldReturnBoolean() {
+ var datatype = datatypeMapper.from(true);
+
+ assertThat(datatype).isEqualTo(DatatypeType.BOOLEAN);
+ }
+
+ @Test
+ void shouldReturnTypeOfElementsInCollection() {
+ var datatype = datatypeMapper.from(List.of(1, 2));
+
+ assertThat(datatype).isEqualTo(DatatypeType.INTEGER);
+ }
+
+ @Test
+ void shouldReturnDefaultIfCollectionIsEmpty() {
+ var datatype = datatypeMapper.from(new Object[] {});
+
+ assertThat(datatype).isEqualTo(DatatypeType.STRING);
+ }
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/ExportFelderTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/ExportFelderTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..ae5c14a26f56bde7b114c41bcf87b62bcf56ae1d
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/ExportFelderTest.java
@@ -0,0 +1,51 @@
+package de.ozgcloud.alfa.vorgang;
+
+import static org.assertj.core.api.Assertions.*;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import de.xoev.xdomea.FeldType;
+
+class ExportFelderTest {
+
+ @Nested
+ class TestCreateFeld {
+
+ private static final FeldType FELD = ExportFelder.LEIKA_ID.createFeld();
+
+ @Test
+ void shouldHaveName() {
+ assertThat(FELD.getName()).isEqualTo(ExportFelder.LEIKA_ID.getName());
+ }
+
+ @Test
+ void shouldHaveBeschreibung() {
+ assertThat(FELD.getBeschreibung()).isEqualTo(ExportFelder.LEIKA_ID.getBeschreibung());
+ }
+
+ @Test
+ void shouldHaveDatentyp() {
+ assertThat(FELD.getDatentyp().getCode()).isEqualTo(ExportFelder.LEIKA_ID.getDatentypCode());
+ }
+
+ @Test
+ void shouldNotHaveWert() {
+ assertThat(FELD.getWert()).isNull();
+ }
+
+ @Nested
+ class MitWert {
+
+ private static final String FELD_WERT = "123";
+
+ @Test
+ void shouldHaveWert() {
+ var feld = ExportFelder.LEIKA_ID.createFeld(FELD_WERT);
+
+ assertThat(feld.getWert()).isEqualTo(FELD_WERT);
+ }
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/ExportVorgangServiceITCase.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/ExportVorgangServiceITCase.java
new file mode 100644
index 0000000000000000000000000000000000000000..8116403db510a3af998bb644a0f56f2e5e810f7b
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/ExportVorgangServiceITCase.java
@@ -0,0 +1,100 @@
+package de.ozgcloud.alfa.vorgang;
+
+import static de.ozgcloud.alfa.vorgang.AntragsdatenItemTypeTestFactory.*;
+import static org.assertj.core.api.Assertions.*;
+
+import java.util.List;
+import java.util.Map;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import de.ozgcloud.common.test.ITCase;
+import de.xoev.xdomea.Antragsdaten;
+import de.xoev.xdomea.AntragsdatenGroupType;
+import de.xoev.xdomea.AntragsdatenItemType;
+import de.xoev.xdomea.AntragsdatenSingleValueFieldType;
+
+@ITCase
+class ExportVorgangServiceITCase {
+
+ @Autowired
+ private ExportVorgangService exportVorgangService;
+
+ @Nested
+ class TestMapVorgang {
+
+ @Nested
+ class TestMapAntragsdaten {
+
+ private static final Map<String, Object> FORM_DATA = Map.of(
+ KEY_STRING, VALUE_STRING
+
+ );
+
+ private static final Map<String, Object> OTHER_DATA = Map.of(
+ KEY_MAP, Map.of(KEY_COLLECTION, List.of(VALUE_INTEGER))
+ );
+
+ @Test
+ void shouldContainSingleAntragsdatenElement() {
+ var vorgangType = exportVorgangService.createVorgangType(VorgangWithEingangTestFactory.create());
+
+ assertThat(vorgangType.getAnwendungsspezifischeErweiterungXML().getAny()).hasSize(1).first().isInstanceOf(Antragsdaten.class);
+ }
+
+ @Test
+ void shouldMapSingleField() {
+ var antragsdaten = mapToAntragsdaten();
+
+ assertThat(antragsdaten.getItem()).hasSize(2);
+ assertContainsSingleValueField(antragsdaten.getItem());
+ }
+
+ private void assertContainsSingleValueField(List<AntragsdatenItemType> items) {
+ var singleValueField = items.stream().filter(item -> item instanceof AntragsdatenSingleValueFieldType).findFirst();
+ assertThat(singleValueField).isPresent().get().usingRecursiveComparison().isEqualTo(createSingleValueField());
+ }
+
+ @Test
+ void shouldMapGroup() {
+ var antragsdaten = mapToAntragsdaten();
+
+ assertThat(antragsdaten.getItem()).hasSize(2);
+ assertContainsGroup(antragsdaten.getItem());
+ }
+
+ private void assertContainsGroup(List<AntragsdatenItemType> items) {
+ var group = items.stream().filter(item -> item instanceof AntragsdatenGroupType).findFirst();
+ assertThat(group).isPresent().get().extracting(AntragsdatenItemType::getName).isEqualTo(KEY_MAP);
+ }
+
+ @Test
+ void shouldMapItemsInGroup() {
+ var antragsdaten = mapToAntragsdaten();
+
+ assertThat(antragsdaten.getItem()).hasSize(2);
+ assertContainsItemsInGroup(antragsdaten.getItem());
+ }
+
+ private void assertContainsItemsInGroup(List<AntragsdatenItemType> items) {
+ var groupItem = items.stream().filter(item -> item instanceof AntragsdatenGroupType)
+ .map(item -> ((AntragsdatenGroupType) item))
+ .map(AntragsdatenGroupType::getItem)
+ .flatMap(List::stream).findFirst();
+ assertThat(groupItem).isPresent().get().usingRecursiveComparison().isEqualTo(createMultiValueField());
+
+ }
+
+ private Antragsdaten mapToAntragsdaten() {
+ var eingang = EingangTestFactory.createBuilder().formData(FORM_DATA)
+ .antragsteller(AntragstellerTestFactory.createBuilder().otherData(OTHER_DATA).build())
+ .build();
+ var vorgangWithEingang = VorgangWithEingangTestFactory.createBuilder().eingang(eingang).build();
+ var vorgangType = exportVorgangService.createVorgangType(vorgangWithEingang);
+ return (Antragsdaten) vorgangType.getAnwendungsspezifischeErweiterungXML().getAny().get(0);
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/ExportVorgangServiceTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/ExportVorgangServiceTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..4bf5f5eaf384761f16046c10c23662a344ecabf8
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/ExportVorgangServiceTest.java
@@ -0,0 +1,115 @@
+package de.ozgcloud.alfa.vorgang;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Spy;
+
+import de.ozgcloud.alfa.export.AllgemeineMetadatenTypeTestFactory;
+import de.ozgcloud.alfa.export.IdentifikationObjektTypeTestFactory;
+
+public class ExportVorgangServiceTest {
+
+ private final static String VORGANG_ID = "DUMMY_ID";
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+
+ @Spy
+ @InjectMocks
+ private ExportVorgangService exportVorgangService;
+
+ @Mock
+ private VorgangService vorgangService;
+
+ @Nested
+ class TestGetVorgang {
+
+ @BeforeEach
+ void init() {
+ when(vorgangService.findVorgangWithEingang(VORGANG_ID)).thenReturn(vorgang);
+ }
+
+ @Test
+ void shouldCallVorgangService() {
+ exportVorgangService.getVorgang(VORGANG_ID);
+
+ verify(vorgangService).findVorgangWithEingang(VORGANG_ID);
+ }
+
+ @Test
+ void shouldReturnVorgangWithEingang() {
+ assertThat(exportVorgangService.getVorgang(VORGANG_ID)).isEqualTo(vorgang);
+ }
+ }
+
+ @Nested
+ class TestCreateAkteType {
+
+ @Test
+ void shouldCallCreateIdentifikationObjektType() {
+ exportVorgangService.createAkteType(vorgang);
+
+ verify(exportVorgangService).createIdentifikationObjektType();
+ }
+
+ @Test
+ void shouldSetIdentifikationObjektType() {
+ var identifikationObjektType = IdentifikationObjektTypeTestFactory.create();
+ doReturn(identifikationObjektType).when(exportVorgangService).createIdentifikationObjektType();
+
+ var akteType = exportVorgangService.createAkteType(vorgang);
+
+ assertThat(akteType.getIdentifikation()).isEqualTo(identifikationObjektType);
+ }
+
+ @Test
+ void shouldCallCreateAllgemeineMetadatenType() {
+ exportVorgangService.createAkteType(vorgang);
+
+ verify(exportVorgangService).createAllgemeineMetadatenType(vorgang);
+ }
+
+ @Test
+ void shouldSetAllgemeineMetadatenType() {
+ var allgemeineMetadatenType = AllgemeineMetadatenTypeTestFactory.create();
+ doReturn(allgemeineMetadatenType).when(exportVorgangService).createAllgemeineMetadatenType(vorgang);
+
+ var akteType = exportVorgangService.createAkteType(vorgang);
+
+ assertThat(akteType.getAllgemeineMetadaten()).isEqualTo(allgemeineMetadatenType);
+ }
+ }
+
+ @Nested
+ class TestCreateIdentifikationObjektType {
+
+ @Test
+ void shouldSetID() {
+ var identifikationObjektType = exportVorgangService.createIdentifikationObjektType();
+
+ assertThat(identifikationObjektType.getID()).isNotBlank();
+ }
+ }
+
+ @Nested
+ class TestCreateAllgemeineMetadatenType {
+
+ @Test
+ void shouldSetKennzeichen() {
+ var allgemeineMetadatenType = exportVorgangService.createAllgemeineMetadatenType(vorgang);
+
+ assertThat(allgemeineMetadatenType.getKennzeichen()).isEqualTo(VorgangHeaderTestFactory.AKTENZEICHEN);
+ }
+
+ @Test
+ void shouldSetEmptyKennzeichen() {
+ var akteType = exportVorgangService.createAkteType(VorgangWithEingangTestFactory.createBuilder().aktenzeichen(null).build());
+
+ assertThat(akteType.getAllgemeineMetadaten().getKennzeichen()).isEmpty();
+ }
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/FeldGruppeTypeCreatorTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/FeldGruppeTypeCreatorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..a78cd333af20803b76a8324e731eba5d760b4e8c
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/FeldGruppeTypeCreatorTest.java
@@ -0,0 +1,526 @@
+package de.ozgcloud.alfa.vorgang;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.Spy;
+
+import de.ozgcloud.alfa.common.DatentypCode;
+import de.xoev.xdomea.DatentypCodeType;
+import de.xoev.xdomea.FeldType;
+
+class FeldGruppeTypeCreatorTest {
+
+ @Spy
+ private FeldGruppeTypeCreator creator;
+
+ @Nested
+ class TestCreate {
+
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+
+ @Test
+ void shouldHaveName() {
+ var created = creator.create(vorgang);
+
+ assertThat(created.getName()).isEqualTo("FeldgruppeOZGCloudBasis");
+ }
+
+ @Test
+ void shouldHaveBeschreibung() {
+ var created = creator.create(vorgang);
+
+ assertThat(created.getBeschreibung()).isEqualTo("Feldgruppe für OZGCloud Basis");
+ }
+
+ @Test
+ void shouldCreateFeldType() {
+ creator.create(vorgang);
+
+ verify(creator).createFeldType(vorgang);
+ }
+ }
+
+ @Nested
+ class TestCreateFeldType {
+
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+
+ @DisplayName("LeikaId")
+ @Nested
+ class TestLeikaId {
+
+ @Test
+ void shouldHaveName() {
+ var created = create();
+
+ assertThat(created).extracting(FeldType::getName).isEqualTo("LeikaID");
+ }
+
+ @Test
+ void shouldHaveBeschreibung() {
+ var created = create();
+
+ assertThat(created).extracting(FeldType::getBeschreibung).isEqualTo("ID einer Leistung aus dem OZG-Leistungskatalog");
+ }
+
+ @Test
+ void shouldHaveWert() {
+ var created = create();
+
+ assertThat(created).extracting(FeldType::getWert).isNull();
+ }
+
+ @DisplayName("DatentypCode")
+ @Nested
+ class TestDatentypCode {
+
+ @Test
+ void shouldHaveCode() {
+ var created = create();
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getCode)
+ .isEqualTo(DatentypCode.STRING.getCode());
+ }
+
+ @Test
+ void shouldHaveListURI() {
+ var created = create();
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListURI)
+ .isEqualTo("urn:xoev-de:xdomea:codeliste:datentyp");
+ }
+
+ @Test
+ void shouldHaveListVersionID() {
+ var created = create();
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListVersionID).isEqualTo("1.1");
+ }
+
+ }
+
+ private FeldType create() {
+ return creator.createFeldType(vorgang).stream()
+ .filter(feldType -> feldType.getName().equals(ExportFelder.LEIKA_ID.getName()))
+ .toList().get(0);
+ }
+ }
+
+ @DisplayName("Datum Antragseingang")
+ @Nested
+ class TestDatumAntragseingang {
+
+ @Test
+ void shouldHaveName() {
+ var created = create();
+
+ assertThat(created).extracting(FeldType::getName).isEqualTo("DatumAntragseingang");
+ }
+
+ @Test
+ void shouldHaveBeschreibung() {
+ var created = create();
+
+ assertThat(created).extracting(FeldType::getBeschreibung).isEqualTo("Das Datum des Antragseingangs");
+ }
+
+ @Test
+ void shouldHaveWert() {
+ var created = create();
+
+ assertThat(created).extracting(FeldType::getWert).isEqualTo(VorgangHeaderTestFactory.CREATED_AT_STR);
+ }
+
+ @DisplayName("DatentypCode")
+ @Nested
+ class TestDatentypCode {
+
+ @Test
+ void shouldHaveCode() {
+ var created = create();
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getCode)
+ .isEqualTo(DatentypCode.DATE.getCode());
+ }
+
+ @Test
+ void shouldHaveListURI() {
+ var created = create();
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListURI)
+ .isEqualTo("urn:xoev-de:xdomea:codeliste:datentyp");
+ }
+
+ @Test
+ void shouldHaveListVersionID() {
+ var created = create();
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListVersionID).isEqualTo("1.1");
+ }
+
+ }
+
+ private FeldType create() {
+ return creator.createFeldType(vorgang).stream()
+ .filter(feldType -> feldType.getName().equals(ExportFelder.DATUM_ANTRAGSEINGANG.getName()))
+ .toList().get(0);
+ }
+ }
+
+ @DisplayName("Name")
+ @Nested
+ class TestName {
+
+ @Test
+ void shouldHaveName() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getName).isEqualTo("Name");
+ }
+
+ @Test
+ void shouldNotHaveBeschreibung() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getBeschreibung).isNull();
+ }
+
+ @Test
+ void shouldHaveWert() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getWert).isEqualTo(AntragstellerTestFactory.NACHNAME);
+ }
+
+ @Test
+ void shouldBeEmptyStringForNullEingang() {
+ var created = create(VorgangWithEingangTestFactory.createBuilder().eingang(null).build());
+
+ assertThat(created.getWert()).isEmpty();
+ }
+
+ @Test
+ void shouldBeEmptyStringForNullAntragsteller() {
+ var created = create(
+ VorgangWithEingangTestFactory.createBuilder().eingang(EingangTestFactory.createBuilder().antragsteller(null).build())
+ .build());
+
+ assertThat(created.getWert()).isEmpty();
+ }
+
+ @Test
+ void shouldBeEmptyStringForNullNachname() {
+ var created = create(
+ VorgangWithEingangTestFactory.createBuilder().eingang(
+ EingangTestFactory.createBuilder().antragsteller(AntragstellerTestFactory.createBuilder().nachname(null).build())
+ .build())
+ .build());
+
+ assertThat(created.getWert()).isEmpty();
+ }
+
+ @DisplayName("DatentypCode")
+ @Nested
+ class TestDatentypCode {
+
+ @Test
+ void shouldHaveCode() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getCode)
+ .isEqualTo(DatentypCode.STRING.getCode());
+ }
+
+ @Test
+ void shouldHaveListURI() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListURI)
+ .isEqualTo("urn:xoev-de:xdomea:codeliste:datentyp");
+ }
+
+ @Test
+ void shouldHaveListVersionID() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListVersionID).isEqualTo("1.1");
+ }
+
+ }
+
+ private FeldType create(VorgangWithEingang vorgang) {
+ return creator.createFeldType(vorgang).stream()
+ .filter(feldType -> feldType.getName().equals(ExportFelder.NAME.getName()))
+ .toList().get(0);
+ }
+ }
+
+ @DisplayName("Vorname")
+ @Nested
+ class TestVorname {
+
+ @Test
+ void shouldHaveName() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getName).isEqualTo("Vorname");
+ }
+
+ @Test
+ void shouldHaveNotHaveBeschreibung() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getBeschreibung).isNull();
+ }
+
+ @Test
+ void shouldHaveWert() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getWert).isEqualTo(AntragstellerTestFactory.VORNAME);
+ }
+
+ @Test
+ void shouldBeEmptyStringForNullEingang() {
+ var created = create(VorgangWithEingangTestFactory.createBuilder().eingang(null).build());
+
+ assertThat(created.getWert()).isEmpty();
+ }
+
+ @Test
+ void shouldBeEmptyStringForNullAntragsteller() {
+ var created = create(
+ VorgangWithEingangTestFactory.createBuilder().eingang(EingangTestFactory.createBuilder().antragsteller(null).build())
+ .build());
+
+ assertThat(created.getWert()).isEmpty();
+ }
+
+ @Test
+ void shouldBeEmptyStringForNullVorname() {
+ var created = create(
+ VorgangWithEingangTestFactory.createBuilder().eingang(
+ EingangTestFactory.createBuilder().antragsteller(AntragstellerTestFactory.createBuilder().vorname(null).build())
+ .build())
+ .build());
+
+ assertThat(created.getWert()).isEmpty();
+ }
+
+ @DisplayName("DatentypCode")
+ @Nested
+ class TestDatentypCode {
+
+ @Test
+ void shouldHaveCode() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getCode)
+ .isEqualTo(DatentypCode.STRING.getCode());
+ }
+
+ @Test
+ void shouldHaveListURI() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListURI)
+ .isEqualTo("urn:xoev-de:xdomea:codeliste:datentyp");
+ }
+
+ @Test
+ void shouldHaveListVersionID() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListVersionID).isEqualTo("1.1");
+ }
+
+ }
+
+ private FeldType create(VorgangWithEingang vorgang) {
+ return creator.createFeldType(vorgang).stream()
+ .filter(feldType -> feldType.getName().equals(ExportFelder.VORNAME.getName()))
+ .toList().get(0);
+ }
+ }
+
+ @DisplayName("Geburtsdatum")
+ @Nested
+ class TestGeburtsdatum {
+
+ @Test
+ void shouldHaveName() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getName).isEqualTo("Geburtsdatum");
+ }
+
+ @Test
+ void shouldHaveNotHaveBeschreibung() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getBeschreibung).isNull();
+ }
+
+ @Test
+ void shouldHaveWert() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getWert).isEqualTo(AntragstellerTestFactory.GEBURTSDATUM_STR);
+ }
+
+ @Test
+ void shouldBeEmptyStringForNullEingang() {
+ var created = create(VorgangWithEingangTestFactory.createBuilder().eingang(null).build());
+
+ assertThat(created.getWert()).isEmpty();
+ }
+
+ @Test
+ void shouldBeEmptyStringForNullAntragsteller() {
+ var created = create(
+ VorgangWithEingangTestFactory.createBuilder().eingang(EingangTestFactory.createBuilder().antragsteller(null).build())
+ .build());
+
+ assertThat(created.getWert()).isEmpty();
+ }
+
+ @Test
+ void shouldBeEmptyStringForNullGeburtsdatum() {
+ var created = create(
+ VorgangWithEingangTestFactory.createBuilder().eingang(
+ EingangTestFactory.createBuilder().antragsteller(AntragstellerTestFactory.createBuilder().geburtsdatum(null).build())
+ .build())
+ .build());
+
+ assertThat(created.getWert()).isEmpty();
+ }
+
+ @DisplayName("DatentypCode")
+ @Nested
+ class TestDatentypCode {
+
+ @Test
+ void shouldHaveCode() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getCode)
+ .isEqualTo(DatentypCode.DATE.getCode());
+ }
+
+ @Test
+ void shouldHaveListURI() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListURI)
+ .isEqualTo("urn:xoev-de:xdomea:codeliste:datentyp");
+ }
+
+ @Test
+ void shouldHaveListVersionID() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListVersionID).isEqualTo("1.1");
+ }
+
+ }
+
+ private FeldType create(VorgangWithEingang vorgang) {
+ return creator.createFeldType(vorgang).stream()
+ .filter(feldType -> feldType.getName().equals(ExportFelder.GEBURTSDATUM.getName()))
+ .toList().get(0);
+ }
+ }
+
+ @DisplayName("Plz")
+ @Nested
+ class TestPlz {
+
+ @Test
+ void shouldHaveName() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getName).isEqualTo("PLZAntragsteller");
+ }
+
+ @Test
+ void shouldHaveNotHaveBeschreibung() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getBeschreibung).isNull();
+ }
+
+ @Test
+ void shouldHaveWert() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getWert).isEqualTo(AntragstellerTestFactory.PLZ);
+ }
+
+ @Test
+ void shouldBeEmptyStringForNullEingang() {
+ var created = create(VorgangWithEingangTestFactory.createBuilder().eingang(null).build());
+
+ assertThat(created.getWert()).isEmpty();
+ }
+
+ @Test
+ void shouldBeEmptyStringForNullAntragsteller() {
+ var created = create(
+ VorgangWithEingangTestFactory.createBuilder().eingang(EingangTestFactory.createBuilder().antragsteller(null).build())
+ .build());
+
+ assertThat(created.getWert()).isEmpty();
+ }
+
+ @Test
+ void shouldBeEmptyStringForNullPlz() {
+ var created = create(
+ VorgangWithEingangTestFactory.createBuilder().eingang(
+ EingangTestFactory.createBuilder().antragsteller(AntragstellerTestFactory.createBuilder().plz(null).build())
+ .build())
+ .build());
+
+ assertThat(created.getWert()).isEmpty();
+ }
+
+ @DisplayName("DatentypCode")
+ @Nested
+ class TestDatentypCode {
+
+ @Test
+ void shouldHaveCode() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getCode)
+ .isEqualTo(DatentypCode.STRING.getCode());
+ }
+
+ @Test
+ void shouldHaveListURI() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListURI)
+ .isEqualTo("urn:xoev-de:xdomea:codeliste:datentyp");
+ }
+
+ @Test
+ void shouldHaveListVersionID() {
+ var created = create(vorgang);
+
+ assertThat(created).extracting(FeldType::getDatentyp).extracting(DatentypCodeType::getListVersionID).isEqualTo("1.1");
+ }
+
+ }
+
+ private FeldType create(VorgangWithEingang vorgang) {
+ return creator.createFeldType(vorgang).stream()
+ .filter(feldType -> feldType.getName().equals(ExportFelder.PLZ.getName()))
+ .toList().get(0);
+ }
+ }
+ }
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/FormDataMapperTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/FormDataMapperTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..637eabe623a23b20161a6acf1cd103839c1bb3f1
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/FormDataMapperTest.java
@@ -0,0 +1,468 @@
+package de.ozgcloud.alfa.vorgang;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.time.ZonedDateTime;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.NullAndEmptySource;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.Spy;
+
+import de.ozgcloud.alfa.common.DateConverter;
+import de.xoev.xdomea.AntragsdatenFieldType;
+import de.xoev.xdomea.AntragsdatenGroupType;
+import de.xoev.xdomea.AntragsdatenItemType;
+import de.xoev.xdomea.AntragsdatenMultiValueFieldType;
+import de.xoev.xdomea.AntragsdatenSingleValueFieldType;
+import de.xoev.xdomea.DatatypeType;
+
+class FormDataMapperTest {
+
+ @Spy
+ @InjectMocks
+ private FormDataMapper formDataMapper;
+
+ @Mock
+ private DatatypeMapper datatypeMapper;
+
+ @Nested
+ class TestToAntragsdaten {
+
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+ private final List<AntragsdatenFieldType> formDataItems = List.of(AntragsdatenItemTypeTestFactory.createSingleValueField(),
+ AntragsdatenItemTypeTestFactory.createSingleValueField());
+ private final List<AntragsdatenFieldType> otherDataItems = List.of(AntragsdatenItemTypeTestFactory.createMultiValueField());
+
+ @Test
+ void shouldMapFormData() {
+ mockMapDataMethodsToReturnNotEmptyResults();
+
+ formDataMapper.toAntragsdaten(vorgang);
+
+ verify(formDataMapper).mapFormData(vorgang);
+ }
+
+ @Test
+ void shouldMapOtherData() {
+ mockMapDataMethodsToReturnNotEmptyResults();
+
+ formDataMapper.toAntragsdaten(vorgang);
+
+ verify(formDataMapper).mapOtherData(vorgang);
+ }
+
+ @Test
+ void shouldSetItemToEmptyListIfNoDataWasMapped() {
+ mockMapDataMethodsToReturnEmptyResults();
+
+ var antragsdaten = formDataMapper.toAntragsdaten(vorgang);
+
+ assertThat(antragsdaten.getItem()).isEmpty();
+ }
+
+ @Test
+ void shouldAddMappedFormDataToAntragsdaten() {
+ mockMapDataMethodsToReturnNotEmptyResults();
+
+ var antragsdaten = formDataMapper.toAntragsdaten(vorgang);
+
+ assertThat(antragsdaten.getItem()).containsAll(formDataItems);
+ }
+
+ @Test
+ void shouldAddMappedOtherDataToAntragsdaten() {
+ mockMapDataMethodsToReturnNotEmptyResults();
+
+ var antragsdaten = formDataMapper.toAntragsdaten(vorgang);
+
+ assertThat(antragsdaten.getItem()).containsAll(otherDataItems);
+ }
+
+ private void mockMapDataMethodsToReturnNotEmptyResults() {
+ doReturn(formDataItems).when(formDataMapper).mapFormData(vorgang);
+ doReturn(otherDataItems).when(formDataMapper).mapOtherData(vorgang);
+ }
+
+ private void mockMapDataMethodsToReturnEmptyResults() {
+ doReturn(List.of()).when(formDataMapper).mapFormData(vorgang);
+ doReturn(List.of()).when(formDataMapper).mapOtherData(vorgang);
+ }
+ }
+
+ @Nested
+ class TestMapFormData {
+
+ private VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+ private final List<AntragsdatenFieldType> mapDataResult = List.of(AntragsdatenItemTypeTestFactory.createSingleValueField(),
+ AntragsdatenItemTypeTestFactory.createSingleValueField());
+
+ @Test
+ void shouldReturnEmptyOnNullEingang() {
+ vorgang = VorgangWithEingangTestFactory.createBuilder().eingang(null).build();
+
+ var antragsdatenItemTypes = formDataMapper.mapFormData(vorgang);
+
+ assertThat(antragsdatenItemTypes).isEmpty();
+ }
+
+ @ParameterizedTest
+ @NullAndEmptySource
+ void shouldReturnEmptyOnMissingFormData(Map<String, Object> formData) {
+ vorgang = VorgangWithEingangTestFactory.createBuilder()
+ .eingang(EingangTestFactory.createBuilder().formData(formData).build())
+ .build();
+
+ var antragsdatenItemTypes = formDataMapper.mapFormData(vorgang);
+
+ assertThat(antragsdatenItemTypes).isEmpty();
+ }
+
+ @Test
+ void shouldMapData() {
+ doReturn(List.of()).when(formDataMapper).mapData(EingangTestFactory.AS_MAP);
+
+ formDataMapper.mapFormData(vorgang);
+
+ verify(formDataMapper).mapData(EingangTestFactory.AS_MAP);
+ }
+
+ @Test
+ void shouldReturnMappedData() {
+ doReturn(mapDataResult).when(formDataMapper).mapData(vorgang.getEingang().getFormData());
+
+ var antragsdatenItemTypes = formDataMapper.mapFormData(vorgang);
+
+ assertThat(antragsdatenItemTypes).containsExactlyElementsOf(mapDataResult);
+ }
+ }
+
+ @Nested
+ class TestMapOtherData {
+
+ private VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+ private final List<AntragsdatenFieldType> mapDataResult = List.of(AntragsdatenItemTypeTestFactory.createSingleValueField(),
+ AntragsdatenItemTypeTestFactory.createSingleValueField());
+
+ @Test
+ void shouldReturnEmptyOnNullEingang() {
+ vorgang = VorgangWithEingangTestFactory.createBuilder().eingang(null).build();
+
+ var antragsdatenItemTypes = formDataMapper.mapOtherData(vorgang);
+
+ assertThat(antragsdatenItemTypes).isEmpty();
+ }
+
+ @Test
+ void shouldReturnEmptyOnNullAntragsteller() {
+ vorgang = VorgangWithEingangTestFactory.createBuilder()
+ .eingang(EingangTestFactory.createBuilder().antragsteller(null).build())
+ .build();
+
+ var antragsdatenItemTypes = formDataMapper.mapOtherData(vorgang);
+
+ assertThat(antragsdatenItemTypes).isEmpty();
+ }
+
+ @ParameterizedTest
+ @NullAndEmptySource
+ void shouldReturnEmptyOnMissingOtherData(Map<String, Object> otherData) {
+ vorgang = VorgangWithEingangTestFactory.createBuilder()
+ .eingang(EingangTestFactory.createBuilder()
+ .antragsteller(AntragstellerTestFactory.createBuilder()
+ .otherData(otherData)
+ .build())
+ .build())
+ .build();
+
+ var antragsdatenItemTypes = formDataMapper.mapOtherData(vorgang);
+
+ assertThat(antragsdatenItemTypes).isEmpty();
+ }
+
+ @Test
+ void shouldMapData() {
+ doReturn(List.of()).when(formDataMapper).mapData(AntragstellerTestFactory.OTHER_DATA);
+
+ formDataMapper.mapOtherData(vorgang);
+
+ verify(formDataMapper).mapData(AntragstellerTestFactory.OTHER_DATA);
+ }
+
+ @Test
+ void shouldReturnMappedData() {
+ doReturn(mapDataResult).when(formDataMapper).mapData(AntragstellerTestFactory.OTHER_DATA);
+
+ var antragsdatenItemTypes = formDataMapper.mapOtherData(vorgang);
+
+ assertThat(antragsdatenItemTypes).containsExactlyElementsOf(mapDataResult);
+ }
+ }
+
+ @Nested
+ class TestMapData {
+
+ private final Map<String, Object> originalData = Map.of("orig-key1", "orig-value1", "orig-key2", "orig-value2");
+ private final Map<String, Object> extractedData = Map.of("ext-key1", "ext-value1", "ext-key2", "ext-value2");
+ private final List<AntragsdatenFieldType> mapDataResult = List.of(AntragsdatenItemTypeTestFactory.createSingleValueField(),
+ AntragsdatenItemTypeTestFactory.createSingleValueField());
+ private MockedStatic<WrappedValueExtractor> wrappedValueExtractor;
+
+ @BeforeEach
+ void init() {
+ wrappedValueExtractor = mockStatic(WrappedValueExtractor.class);
+ wrappedValueExtractor.when(() -> WrappedValueExtractor.extractWrappedValues(originalData)).thenReturn(extractedData);
+ doReturn(mapDataResult).when(formDataMapper).buildItems(extractedData);
+ }
+
+ @AfterEach
+ void cleanup() {
+ wrappedValueExtractor.close();
+ }
+
+ @Test
+ void shouldCallWrappedValueExtractor() {
+ formDataMapper.mapData(originalData);
+
+ wrappedValueExtractor.verify(() -> WrappedValueExtractor.extractWrappedValues(originalData));
+ }
+
+ @Test
+ void shouldCallBuildItemsWithExtractedData() {
+ formDataMapper.mapData(originalData);
+
+ verify(formDataMapper).buildItems(extractedData);
+ }
+
+ @Test
+ void shouldReturnBuildItemsResult() {
+ var mappedData = formDataMapper.mapData(originalData);
+
+ assertThat(mappedData).isEqualTo(mapDataResult);
+ }
+ }
+
+ @Nested
+ class TestBuildItems {
+
+ private static final String FORMDATA_KEY = "key1";
+ private static final String SINGLE_VALUE = "value";
+ private static final List<Object> COLLECTION_OF_VALUES = List.of("value");
+ private static final Map<String, Object> FORMDATA_SUBMAP = Map.of("key2", "value");
+
+ @Mock
+ private AntragsdatenItemType expectedAntragsdatenItem;
+
+ @Test
+ void shouldReturnEmptyList() {
+ var items = formDataMapper.buildItems(Collections.emptyMap());
+
+ assertThat(items).isEmpty();
+ }
+
+ @Test
+ void shoulAddSubmap() {
+ doReturn(expectedAntragsdatenItem).when(formDataMapper).buildAntragsdatenGroup(FORMDATA_KEY, FORMDATA_SUBMAP);
+
+ var items = formDataMapper.buildItems(Map.of(FORMDATA_KEY, FORMDATA_SUBMAP));
+
+ assertThat(items).hasSize(1).first().isEqualTo(expectedAntragsdatenItem);
+ }
+
+ @Test
+ void shouldAddCollection() {
+ doReturn(expectedAntragsdatenItem).when(formDataMapper).buildMultiValueField(FORMDATA_KEY, COLLECTION_OF_VALUES);
+
+ var items = formDataMapper.buildItems(Map.of(FORMDATA_KEY, COLLECTION_OF_VALUES));
+
+ assertThat(items).hasSize(1).first().isEqualTo(expectedAntragsdatenItem);
+ }
+
+ @Test
+ void shouldAddSingleValue() {
+ doReturn(expectedAntragsdatenItem).when(formDataMapper).buildSingleValueField(FORMDATA_KEY, SINGLE_VALUE);
+
+ var items = formDataMapper.buildItems(Map.of(FORMDATA_KEY, SINGLE_VALUE));
+
+ assertThat(items).hasSize(1).first().isEqualTo(expectedAntragsdatenItem);
+ }
+ }
+
+ @Nested
+ class TestBuildAntragsdatenGroup {
+
+ private static final String NAME = "name";
+ private static final String FORMDATA_SUBMAP_VALUE = "value";
+ private static final Map<String, Object> FORMDATA_SUBMAP = Map.of("key", FORMDATA_SUBMAP_VALUE);
+ private final List<AntragsdatenItemType> items = AntragsdatenItemTypeTestFactory.createAntragsdatenItemTypes();
+
+ @Test
+ void shouldSetName() {
+ mockFormatValue();
+
+ var antragsdatenGroup = formDataMapper.buildAntragsdatenGroup(NAME, FORMDATA_SUBMAP);
+
+ assertThat(antragsdatenGroup.getName()).isEqualTo(NAME);
+ }
+
+ @Test
+ void shouldSetItems() {
+ doReturn(items).when(formDataMapper).buildItems(FORMDATA_SUBMAP);
+
+ var antragsdatenGroup = (AntragsdatenGroupType) formDataMapper.buildAntragsdatenGroup(NAME, FORMDATA_SUBMAP);
+
+ assertThat(antragsdatenGroup.getItem()).containsExactlyElementsOf(items);
+ }
+
+ @Test
+ void shouldCallBuildItems() {
+ mockFormatValue();
+
+ formDataMapper.buildAntragsdatenGroup(NAME, FORMDATA_SUBMAP);
+
+ verify(formDataMapper).buildItems(FORMDATA_SUBMAP);
+ }
+
+ private void mockFormatValue() {
+ when(datatypeMapper.from(FORMDATA_SUBMAP_VALUE)).thenReturn(DatatypeType.STRING);
+ doReturn(new Object()).when(formDataMapper).formatValue(DatatypeType.STRING, FORMDATA_SUBMAP_VALUE);
+ }
+ }
+
+ @Nested
+ class TestBuildMultiValueField {
+
+ private static final String NAME = "name";
+ private static final List<String> FORMDATA_COLLECTION = List.of("value1");
+
+ @Test
+ void shouldSetName() {
+ when(datatypeMapper.from(FORMDATA_COLLECTION)).thenReturn(DatatypeType.STRING);
+
+ var antragsdatenMultiValueFieldType = formDataMapper.buildMultiValueField(NAME, FORMDATA_COLLECTION);
+
+ assertThat(antragsdatenMultiValueFieldType.getName()).isEqualTo(NAME);
+ }
+
+ @Test
+ void shouldSetType() {
+ when(datatypeMapper.from(FORMDATA_COLLECTION)).thenReturn(DatatypeType.STRING);
+
+ var antragsdatenMultiValueFieldType = (AntragsdatenFieldType) formDataMapper.buildMultiValueField(NAME, FORMDATA_COLLECTION);
+
+ assertThat(antragsdatenMultiValueFieldType.getType()).isEqualTo(DatatypeType.STRING);
+ }
+
+ @Test
+ void shouldSetValue() {
+ var formData = List.of(1, 2);
+ when(datatypeMapper.from(formData)).thenReturn(DatatypeType.INTEGER);
+
+ var antragsdatenMultiValueFieldType = (AntragsdatenMultiValueFieldType) formDataMapper.buildMultiValueField(NAME, formData);
+
+ assertThat(antragsdatenMultiValueFieldType.getValue()).containsExactlyElementsOf(formData);
+ }
+
+ @Test
+ void shouldCallFormatValue() {
+ when(datatypeMapper.from(FORMDATA_COLLECTION)).thenReturn(DatatypeType.STRING);
+
+ formDataMapper.buildMultiValueField(NAME, FORMDATA_COLLECTION);
+
+ verify(formDataMapper).formatValue(DatatypeType.STRING, FORMDATA_COLLECTION.get(0));
+ }
+ }
+
+ @Nested
+ class TestBuildSingleValueField {
+
+ private static final String NAME = "name";
+ private static final String FORMDATA_VALUE = "value";
+
+ @Test
+ void shouldSetName() {
+ mockFormatValue();
+ var antragsdatenSingleValueFieldType = formDataMapper.buildSingleValueField(NAME, FORMDATA_VALUE);
+
+ assertThat(antragsdatenSingleValueFieldType.getName()).isEqualTo(NAME);
+ }
+
+ @Test
+ void shouldSetType() {
+ when(datatypeMapper.from(FORMDATA_VALUE)).thenReturn(DatatypeType.STRING);
+
+ var antragsdatenSingleValueFieldType = (AntragsdatenFieldType) formDataMapper.buildSingleValueField(NAME, FORMDATA_VALUE);
+
+ assertThat(antragsdatenSingleValueFieldType.getType()).isEqualTo(DatatypeType.STRING);
+ }
+
+ @Test
+ void shouldSetValue() {
+ mockFormatValue();
+
+ var antragsdatenSingleValueFieldType = (AntragsdatenSingleValueFieldType) formDataMapper.buildSingleValueField(NAME, FORMDATA_VALUE);
+
+ assertThat(antragsdatenSingleValueFieldType.getValue()).isEqualTo(FORMDATA_VALUE);
+ }
+
+ @Test
+ void shouldNotSetIfValueIsNull() {
+ formDataMapper.buildSingleValueField(NAME, null);
+
+ verify(formDataMapper, never()).formatValue(DatatypeType.STRING, null);
+ }
+
+ @Test
+ void shouldCallFormatValue() {
+ when(datatypeMapper.from(FORMDATA_VALUE)).thenReturn(DatatypeType.STRING);
+
+ formDataMapper.buildSingleValueField(NAME, FORMDATA_VALUE);
+
+ verify(formDataMapper).formatValue(DatatypeType.STRING, FORMDATA_VALUE);
+ }
+
+ private void mockFormatValue() {
+ when(datatypeMapper.from(FORMDATA_VALUE)).thenReturn(DatatypeType.STRING);
+ doReturn(FORMDATA_VALUE).when(formDataMapper).formatValue(DatatypeType.STRING, FORMDATA_VALUE);
+ }
+ }
+
+ @Nested
+ class TestFormatValue {
+
+ @Test
+ void shouldFormatStringType() {
+ var value = formDataMapper.formatValue(DatatypeType.STRING, 1);
+
+ assertThat(value).isEqualTo("1");
+ }
+
+ @Test
+ void shouldFormatDateTimeType() {
+ try (var dateConverter = mockStatic(DateConverter.class)) {
+ var dateTime = ZonedDateTime.now();
+
+ formDataMapper.formatValue(DatatypeType.DATETIME, dateTime);
+
+ dateConverter.verify(() -> DateConverter.toXmlGregorianCalendar(dateTime));
+ }
+ }
+
+ @Test
+ void shouldFormatNull() {
+ var value = formDataMapper.formatValue(DatatypeType.STRING, null);
+
+ assertThat(value).isEqualTo("null");
+ }
+ }
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/GeburtTypeTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/GeburtTypeTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..1eff8f3fd7bca104f131c92d107fdebe1ed16b12
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/GeburtTypeTestFactory.java
@@ -0,0 +1,10 @@
+package de.ozgcloud.alfa.vorgang;
+
+import de.xoev.xdomea.GeburtType;
+
+public class GeburtTypeTestFactory {
+
+ public static GeburtType create() {
+ return new GeburtType();
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/KontaktTypeCreatorTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/KontaktTypeCreatorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..400b0b1458aeb14c39ca8afec7fb35beb461f763
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/KontaktTypeCreatorTest.java
@@ -0,0 +1,346 @@
+package de.ozgcloud.alfa.vorgang;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.Optional;
+
+import javax.xml.datatype.XMLGregorianCalendar;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.NullAndEmptySource;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.Spy;
+
+import de.ozgcloud.alfa.common.DateConverter;
+import de.xoev.xdomea.GeburtType;
+import de.xoev.xdomea.KontaktType;
+import de.xoev.xdomea.NameNatuerlichePersonType;
+import jakarta.annotation.Nullable;
+
+class KontaktTypeCreatorTest {
+
+ @Spy
+ @InjectMocks
+ private KontaktTypeCreator creator;
+
+ @Mock
+ private NameNatuerlichePersonTypeCreator nameNatuerlichePersonTypeCreator;
+
+ @Nested
+ class TestCreate {
+
+ @Nested
+ class TestWithAntragsteller {
+
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+ private final KontaktType kontaktType = KontaktTypeTestFactory.create();
+
+ @BeforeEach
+ void setUp() {
+ doReturn(Optional.of(vorgang.getEingang().getAntragsteller())).when(creator).getAntragstellerIfHasRequiredData(vorgang);
+ doReturn(kontaktType).when(creator).toKontaktType(vorgang.getEingang().getAntragsteller());
+ }
+
+ @Test
+ void shouldGetAntragsteller() {
+ callCreator(vorgang);
+
+ verify(creator).getAntragstellerIfHasRequiredData(vorgang);
+ }
+
+ @Test
+ void shouldMapToKontaktType() {
+ callCreator(vorgang);
+
+ verify(creator).toKontaktType(vorgang.getEingang().getAntragsteller());
+ }
+
+ @Test
+ void shouldReturnKontakt() {
+ var kontakt = callCreator(vorgang);
+
+ assertThat(kontakt).get().isEqualTo(kontaktType);
+ }
+ }
+
+ @Nested
+ class TestWithoutAntragsteller {
+
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.createBuilder()
+ .eingang(EingangTestFactory.createBuilder().antragsteller(null).build())
+ .build();
+
+ @BeforeEach
+ void setUp() {
+ doReturn(Optional.empty()).when(creator).getAntragstellerIfHasRequiredData(vorgang);
+ }
+
+ @Test
+ void shouldBeEmpty() {
+ var kontakt = callCreator(vorgang);
+
+ assertThat(kontakt).isEmpty();
+ }
+ }
+
+ private Optional<KontaktType> callCreator(VorgangWithEingang vorgang) {
+ return creator.create(vorgang);
+ }
+ }
+
+ @Nested
+ class TestGeburtsdatumToISO {
+
+ @Mock
+ private XMLGregorianCalendar geburtsdatum;
+
+ private MockedStatic<DateConverter> dateConverter;
+
+ private final Antragsteller antragsteller = AntragstellerTestFactory.create();
+
+ void setUpDateConverter() {
+ dateConverter = mockStatic(DateConverter.class);
+ dateConverter.when(() -> DateConverter.convertGermanFormatToISO(AntragstellerTestFactory.GEBURTSDATUM_STR))
+ .thenReturn(Optional.of(geburtsdatum));
+ }
+
+ @BeforeEach
+ void setUp() {
+ setUpDateConverter();
+ }
+
+ @AfterEach
+ void cleanUp() {
+ dateConverter.close();
+ }
+
+ @Test
+ void shouldCallDateConverter() {
+ callGeburtsdatumToISO(antragsteller);
+
+ dateConverter.verify(() -> DateConverter.convertGermanFormatToISO(antragsteller.getGeburtsdatum()));
+ }
+
+ @Test
+ void shouldReturnGeburtsdatumIso() {
+ var result = callGeburtsdatumToISO(antragsteller);
+
+ assertThat(result).isEqualTo(Optional.of(geburtsdatum));
+ }
+
+ private Optional<XMLGregorianCalendar> callGeburtsdatumToISO(Antragsteller antragsteller) {
+ return creator.geburtsdatumToISO(antragsteller);
+ }
+
+ }
+
+ @Nested
+ class TestToKontaktType {
+
+ @Nested
+ class WhenHavingGeburtsdatum {
+
+ @Mock
+ private XMLGregorianCalendar geburtsdatum;
+
+ private MockedStatic<KontaktTypeCreator> mockStatic;
+
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+ private final Antragsteller antragsteller = vorgang.getEingang().getAntragsteller();
+ private final NameNatuerlichePersonType nameNatuerlichePerson = NameNatuerlichePersonTypeTestFactory.create();
+ private final GeburtType geburtType = GeburtTypeTestFactory.create();
+
+ @BeforeEach
+ void setUp() {
+ when(nameNatuerlichePersonTypeCreator.create(vorgang.getEingang().getAntragsteller())).thenReturn(nameNatuerlichePerson);
+
+ mockStatic = mockStatic(KontaktTypeCreator.class);
+ mockStatic.when(() -> KontaktTypeCreator.geburtsdatumToISO(antragsteller)).thenReturn(Optional.of(geburtsdatum));
+
+ doReturn(geburtType).when(creator).createGeburtType(geburtsdatum);
+ }
+
+ @AfterEach
+ void tearDown() {
+ mockStatic.close();
+ }
+
+ @Test
+ void shouldCreateNameNatuerlichePerson() {
+ callCreator(vorgang);
+
+ verify(nameNatuerlichePersonTypeCreator).create(vorgang.getEingang().getAntragsteller());
+ }
+
+ @Test
+ void shouldHaveNameNatuerlichePerson() {
+ var kontakt = callCreator(vorgang);
+
+ assertThat(kontakt.getName()).isEqualTo(nameNatuerlichePerson);
+ }
+
+ @Test
+ void shouldCallDateConverter() {
+ callCreator(vorgang);
+
+ verify(creator).createGeburtType(geburtsdatum);
+ }
+
+ @Test
+ void shouldCreateGeburtType() {
+ callCreator(vorgang);
+
+ verify(creator).createGeburtType(geburtsdatum);
+ }
+
+ @Test
+ void shouldHaveGeburtType() {
+ var kontakt = callCreator(vorgang);
+
+ assertThat(kontakt.getGeburt()).isEqualTo(geburtType);
+ }
+ }
+
+ @Nested
+ class WhenHavingInvalidGeburtsdatum {
+
+ @ParameterizedTest
+ @NullAndEmptySource
+ @ValueSource(strings = { "unreadable" })
+ void shouldNotSetForInvalidGeburtsdatum(String geburtsdatum) {
+ var result = callCreator(createVorgangWithAntragstellerGeburtsdatum(geburtsdatum));
+
+ assertThat(result.getGeburt()).isNull();
+ }
+
+ @ParameterizedTest
+ @NullAndEmptySource
+ @ValueSource(strings = { "unreadable" })
+ void shouldNotCallCreateGeburtType(String geburtsdatum) {
+ callCreator(createVorgangWithAntragstellerGeburtsdatum(geburtsdatum));
+
+ verify(creator, never()).createGeburtType(any());
+ }
+
+ }
+
+ private VorgangWithEingang createVorgangWithAntragstellerGeburtsdatum(@Nullable String geburtsdatum) {
+ return VorgangWithEingangTestFactory.createBuilder().eingang(
+ EingangTestFactory.createBuilder().antragsteller(
+ AntragstellerTestFactory.createBuilder().geburtsdatum(geburtsdatum).build()).build()).build();
+ }
+
+ private KontaktType callCreator(VorgangWithEingang vorgang) {
+ return creator.toKontaktType(vorgang.getEingang().getAntragsteller());
+ }
+ }
+
+ @Nested
+ class TestCreateGeburtType {
+
+ @Mock
+ private XMLGregorianCalendar geburtsdatum;
+
+ private MockedStatic<DateConverter> dateConverter;
+
+ @BeforeEach
+ void setUp() {
+ dateConverter = mockStatic(DateConverter.class);
+ dateConverter.when(() -> DateConverter.convertGermanFormatToISO(AntragstellerTestFactory.GEBURTSDATUM_STR))
+ .thenReturn(Optional.of(geburtsdatum));
+ }
+
+ @AfterEach
+ void tearDown() {
+ dateConverter.close();
+ }
+
+ @Test
+ void shouldCreate() {
+ var geburtType = callCreator(geburtsdatum);
+
+ assertThat(geburtType.getDatum()).isEqualTo(geburtsdatum);
+ }
+
+ private GeburtType callCreator(XMLGregorianCalendar geburtsdatum) {
+ return creator.createGeburtType(geburtsdatum);
+ }
+ }
+
+ @Nested
+ class TestGetAntragstellerIfHasRequiredData {
+
+ @Mock
+ private XMLGregorianCalendar geburtsdatum;
+
+ @Test
+ void shouldBeEmptyIfAntragstellerNull() {
+ var antragsteller = callCreator(buildVorgang(null));
+
+ assertThat(antragsteller).isEmpty();
+ }
+
+ @Test
+ void shouldBeEmptyIfNoneOfRequiredDataExists() {
+ try (var dateConverter = mockStatic(DateConverter.class)) {
+ dateConverter.when(() -> DateConverter.convertGermanFormatToISO(null)).thenReturn(Optional.empty());
+
+ var antragsteller = callCreator(buildVorgang(Antragsteller.builder().build()));
+
+ assertThat(antragsteller).isEmpty();
+ }
+ }
+
+ @Test
+ void shouldNotBeEmptyIfHasVorname() {
+ var antragsteller = callCreator(buildVorgang(Antragsteller.builder().vorname(AntragstellerTestFactory.VORNAME).build()));
+
+ assertThat(antragsteller).isNotEmpty();
+ }
+
+ @Test
+ void shouldNotBeEmptyIfHasNachname() {
+ var antragsteller = callCreator(buildVorgang(Antragsteller.builder().nachname(AntragstellerTestFactory.NACHNAME).build()));
+
+ assertThat(antragsteller).isNotEmpty();
+ }
+
+ @Test
+ void shouldNotBeEmptyIfHasAnrede() {
+ var antragsteller = callCreator(buildVorgang(Antragsteller.builder().anrede(AntragstellerTestFactory.ANREDE).build()));
+
+ assertThat(antragsteller).isNotEmpty();
+ }
+
+ @Test
+ void shouldNotBeEmptyIfHasGeburtsdatum() {
+ try (var dateConverter = mockStatic(DateConverter.class)) {
+ dateConverter.when(() -> DateConverter.convertGermanFormatToISO(AntragstellerTestFactory.GEBURTSDATUM_STR))
+ .thenReturn(Optional.of(geburtsdatum));
+
+ var antragsteller = callCreator(
+ buildVorgang(Antragsteller.builder().geburtsdatum(AntragstellerTestFactory.GEBURTSDATUM_STR).build()));
+
+ assertThat(antragsteller).isNotEmpty();
+ }
+ }
+
+ private Optional<Antragsteller> callCreator(VorgangWithEingang vorgang) {
+ return creator.getAntragstellerIfHasRequiredData(vorgang);
+ }
+
+ private VorgangWithEingang buildVorgang(Antragsteller antragsteller) {
+ return VorgangWithEingangTestFactory.createBuilder().eingang(EingangTestFactory.createBuilder().antragsteller(antragsteller).build())
+ .build();
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/KontaktTypeTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/KontaktTypeTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..964eb818e77f28b7fb396c3a4d1d33d0937c418f
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/KontaktTypeTestFactory.java
@@ -0,0 +1,10 @@
+package de.ozgcloud.alfa.vorgang;
+
+import de.xoev.xdomea.KontaktType;
+
+public class KontaktTypeTestFactory {
+
+ public static KontaktType create() {
+ return new KontaktType();
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/KopfCreatorTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/KopfCreatorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..ad2a07d492a41a25956fe6032f940df5b82c0f9e
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/KopfCreatorTest.java
@@ -0,0 +1,324 @@
+package de.ozgcloud.alfa.vorgang;
+
+import static de.ozgcloud.alfa.export.XdomeaPropertiesTestFactory.*;
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+import java.time.ZoneOffset;
+import java.time.ZonedDateTime;
+
+import javax.xml.datatype.XMLGregorianCalendar;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.NullAndEmptySource;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockedStatic;
+import org.mockito.Spy;
+
+import com.thedeanda.lorem.LoremIpsum;
+
+import de.ozgcloud.alfa.common.DateConverter;
+import de.ozgcloud.alfa.common.UUIDConverter;
+import de.ozgcloud.alfa.export.XdomeaProperties;
+import de.xoev.xdomea.BehoerdenkennungType;
+import de.xoev.xdomea.Code;
+import de.xoev.xdomea.KontaktType;
+import de.xoev.xdomea.NachrichtentypCodeType;
+import de.xoev.xdomea.NkAbgabeType;
+import de.xoev.xdomea.OrganisationseinheitType;
+import de.xoev.xdomea.SystemType;
+
+class KopfCreatorTest {
+
+ @Spy
+ @InjectMocks
+ private KopfCreator creator;
+
+ @Mock
+ private XdomeaProperties xdomeaProperties;
+
+ @Nested
+ class TestCreateKopf {
+
+ static final ZonedDateTime CREATION_TIME = ZonedDateTime.now();
+
+ private MockedStatic<UUIDConverter> mockedUUIDConverter;
+
+ @BeforeEach
+ void setUpUUIDMock() {
+ mockedUUIDConverter = mockStatic(UUIDConverter.class);
+ }
+
+ @AfterEach
+ void tearDown() {
+ mockedUUIDConverter.close();
+ }
+
+ @Test
+ void shouldSetProcessId() {
+ var uuid = LoremIpsum.getInstance().getWords(1);
+ mockedUUIDConverter.when(() -> UUIDConverter.fromObjectId(VorgangHeaderTestFactory.ID)).thenReturn(uuid);
+
+ var kopf = createKopf();
+
+ assertThat(kopf.getProzessID()).isEqualTo(uuid);
+ }
+
+ @Test
+ void shouldSetNachrichtentyp() {
+ var expectedValue = new NachrichtentypCodeType();
+ doReturn(expectedValue).when(creator).createNachrichtentyp();
+
+ var kopf = createKopf();
+
+ assertThat(kopf.getNachrichtentyp()).isEqualTo(expectedValue);
+ }
+
+ @Test
+ void shouldSetErstellungszeitpunkt() {
+ try (var zonedDateTime = mockStatic(ZonedDateTime.class); var dateConverter = mockStatic(DateConverter.class)) {
+ zonedDateTime.when(() -> ZonedDateTime.now(ZoneOffset.UTC)).thenReturn(CREATION_TIME);
+
+ var expectedValue = mock(XMLGregorianCalendar.class);
+ dateConverter.when(() -> DateConverter.toXmlGregorianCalendar(CREATION_TIME)).thenReturn(expectedValue);
+
+ var kopf = createKopf();
+
+ assertThat(kopf.getErstellungszeitpunkt()).isEqualTo(expectedValue);
+ }
+ }
+
+ @Test
+ void shouldSetAbsender() {
+ var expectedValue = new KontaktType();
+ doReturn(expectedValue).when(creator).createAbsender(any());
+
+ var kopf = createKopf();
+
+ assertThat(kopf.getAbsender()).isEqualTo(expectedValue);
+ }
+
+ @Test
+ void shouldSetEmpfaenger() {
+ var expectedValue = new KontaktType();
+ doReturn(expectedValue).when(creator).createKontaktType();
+
+ var kopf = createKopf();
+
+ assertThat(kopf.getEmpfaenger()).isEqualTo(expectedValue);
+ }
+
+ @Test
+ void shouldSetSendendesSystem() {
+ var sendendesSystem = new SystemType();
+ doReturn(sendendesSystem).when(creator).createSendendesSystem();
+
+ var kopf = createKopf();
+
+ assertThat(kopf.getSendendesSystem()).isEqualTo(sendendesSystem);
+ }
+
+ @Test
+ void shouldSetImportbestaetigung() {
+ var kopf = createKopf();
+
+ assertThat(kopf.isImportbestaetigung()).isTrue();
+ }
+
+ @Test
+ void shouldSetEmpfangsbestaetigung() {
+ var kopf = createKopf();
+
+ assertThat(kopf.isEmpfangsbestaetigung()).isTrue();
+ }
+
+ private NkAbgabeType createKopf() {
+ return creator.createKopf(VorgangWithEingangTestFactory.create());
+ }
+ }
+
+ @Nested
+ class TestCreateNachrichtentype {
+
+ @Test
+ void shouldSetCode() {
+ var nachrichtentyp = creator.createNachrichtentyp();
+
+ assertThat(nachrichtentyp.getCode()).isEqualTo(KopfCreator.NACHRICHTENTYP_ABGABE_ABGABE_TYPE_CODE);
+ }
+
+ @Test
+ void shouldSetListURI() {
+ var nachrichtentyp = creator.createNachrichtentyp();
+
+ assertThat(nachrichtentyp.getListURI()).isEqualTo(KopfCreator.NACHRICHTENTYP_CODE_TYPE_LIST_URI);
+ }
+
+ @Test
+ void shouldSetListVersionID() {
+ var nachrichtentyp = creator.createNachrichtentyp();
+
+ assertThat(nachrichtentyp.getListVersionID()).isEqualTo(KopfCreator.NACHRICHTENTYP_CODE_TYPE_LIST_VERSION_ID);
+ }
+ }
+
+ @Nested
+ class TestCreateAbsender {
+
+ @Test
+ void shouldCallCreateKontaktType() {
+ creator.createAbsender(ZustaendigeStelleTestFactory.ORGANISATIONSEINHEITEN_ID);
+
+ verify(creator).createKontaktType();
+ }
+
+ @Test
+ void shouldSetOrganisationseinheitType() {
+ var expectedValue = new OrganisationseinheitType();
+ doReturn(expectedValue).when(creator).createOrganisationseinheitType(any());
+
+ var absender = creator.createAbsender(ZustaendigeStelleTestFactory.ORGANISATIONSEINHEITEN_ID);
+
+ assertThat(absender.getOrganisationseinheit()).isEqualTo(expectedValue);
+ }
+ }
+
+ @Nested
+ class TestCreateKontaktType {
+
+ @Nested
+ class OnBehoerdenschluesselNotSet {
+
+ @ParameterizedTest
+ @NullAndEmptySource
+ void shouldNotCreateBehoerdenkennung(String behoerdenschluessel) {
+ when(xdomeaProperties.getBehoerdenschluessel()).thenReturn(behoerdenschluessel);
+
+ creator.createKontaktType();
+
+ verify(creator, never()).createBehoerdenkennung();
+ }
+
+ @ParameterizedTest
+ @NullAndEmptySource
+ void shouldNotSetBehoerdenkennung(String behoerdenschluessel) {
+ when(xdomeaProperties.getBehoerdenschluessel()).thenReturn(behoerdenschluessel);
+
+ var kontaktType = creator.createKontaktType();
+
+ assertThat(kontaktType.getBehoerdenkennung()).isNull();
+ }
+ }
+
+ @Nested
+ class OnBehoerdenschluesselSet {
+
+ private static final BehoerdenkennungType expectedValue = new BehoerdenkennungType();
+
+ @BeforeEach
+ void init() {
+ when(xdomeaProperties.getBehoerdenschluessel()).thenReturn(BEHOERDENSCHLUESSEL);
+ doReturn(expectedValue).when(creator).createBehoerdenkennung();
+ }
+
+ @Test
+ void shouldCreateBehoerdenkennung() {
+ creator.createKontaktType();
+
+ verify(creator).createBehoerdenkennung();
+ }
+
+ @Test
+ void shouldSetBehoerdenkennung() {
+ var kontaktType = creator.createKontaktType();
+
+ assertThat(kontaktType.getBehoerdenkennung()).isEqualTo(expectedValue);
+ }
+ }
+ }
+
+ @Nested
+ class TestCreateOrganisationseinheitType {
+
+ @Test
+ void shouldSetName() {
+ var organisationseinheitType = creator.createOrganisationseinheitType(ZustaendigeStelleTestFactory.ORGANISATIONSEINHEITEN_ID);
+
+ assertThat(organisationseinheitType.getName()).isEqualTo(ZustaendigeStelleTestFactory.ORGANISATIONSEINHEITEN_ID);
+ }
+ }
+
+ @Nested
+ class TestCreateBehoerdenkennung {
+
+ private final Code expectedBehoerdenschluessel = new Code();
+
+ @BeforeEach
+ void init() {
+ doReturn(expectedBehoerdenschluessel).when(creator).createBehoerdenschluessel();
+ }
+
+ @Test
+ void shouldcreateBehoerdenschluessel() {
+ creator.createBehoerdenkennung();
+
+ verify(creator).createBehoerdenschluessel();
+ }
+
+ @Test
+ void shouldSetBehoerdenschluessel() {
+ var behoerdenkennungType = creator.createBehoerdenkennung();
+
+ assertThat(behoerdenkennungType.getBehoerdenschluessel()).isEqualTo(expectedBehoerdenschluessel);
+ }
+ }
+
+ @Nested
+ class TestCreateBehoerdenschlussel {
+
+ @BeforeEach
+ void init() {
+ when(xdomeaProperties.getBehoerdenschluessel()).thenReturn(BEHOERDENSCHLUESSEL);
+ when(xdomeaProperties.getBehoerdenschluesselUri()).thenReturn(BEHOERDENSCHLUESSEL_URI);
+ when(xdomeaProperties.getBehoerdenschluesselVersion()).thenReturn(BEHOERDENSCHLUESSEL_VERSION);
+ }
+
+ @Test
+ void shouldSetCode() {
+ var behoerdenschlussel = creator.createBehoerdenschluessel();
+
+ assertThat(behoerdenschlussel.getCode()).isEqualTo(BEHOERDENSCHLUESSEL);
+ }
+
+ @Test
+ void shouldSetListURI() {
+ var behoerdenschlussel = creator.createBehoerdenschluessel();
+
+ assertThat(behoerdenschlussel.getListURI()).isEqualTo(BEHOERDENSCHLUESSEL_URI);
+ }
+
+ @Test
+ void shouldSetListVersionID() {
+ var behoerdenschlussel = creator.createBehoerdenschluessel();
+
+ assertThat(behoerdenschlussel.getListVersionID()).isEqualTo(BEHOERDENSCHLUESSEL_VERSION);
+ }
+ }
+
+ @Nested
+ class TestCreateSendendesSystem {
+
+ @Test
+ void shouldSetSystemName() {
+ var sendendesSystem = creator.createSendendesSystem();
+
+ assertThat(sendendesSystem.getProduktname()).isEqualTo(KopfCreator.PRODUKT_NAME);
+ }
+ }
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/NameNatuerlichePersonTypeCreatorTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/NameNatuerlichePersonTypeCreatorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..04bed62960387ee3ebef07bcc2cc59156371547d
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/NameNatuerlichePersonTypeCreatorTest.java
@@ -0,0 +1,91 @@
+package de.ozgcloud.alfa.vorgang;
+
+import static org.assertj.core.api.Assertions.*;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+
+import de.xoev.xdomea.NameNatuerlichePersonType;
+
+class NameNatuerlichePersonTypeCreatorTest {
+
+ @InjectMocks
+ private NameNatuerlichePersonTypeCreator creator;
+
+ @Nested
+ class TestCreate {
+
+ @Test
+ void shouldHaveAnrede() {
+ var nameNatuerlichePerson = callCreator(AntragstellerTestFactory.create());
+
+ assertThat(nameNatuerlichePerson.getAnrede()).isEqualTo(AntragstellerTestFactory.ANREDE);
+ }
+
+ @Test
+ void shouldHaveEmptyAnrede() {
+ var nameNatuerlichePerson = callCreator(AntragstellerTestFactory.createBuilder().anrede(null).build());
+
+ assertThat(nameNatuerlichePerson.getAnrede()).isEmpty();
+ }
+
+ @Test
+ void shouldHaveVorname() {
+ var nameNatuerlichePerson = callCreator(AntragstellerTestFactory.create());
+
+ assertThat(nameNatuerlichePerson.getVorname().getName()).isEqualTo(AntragstellerTestFactory.VORNAME);
+ }
+
+ @Test
+ void shouldHaveEmptyVorname() {
+ var nameNatuerlichePerson = callCreator(AntragstellerTestFactory.createBuilder().vorname(null).build());
+
+ assertThat(nameNatuerlichePerson.getVorname().getName()).isEmpty();
+ }
+
+ @Test
+ void shouldHaveFamilienname() {
+ var nameNatuerlichePerson = callCreator(AntragstellerTestFactory.create());
+
+ assertThat(nameNatuerlichePerson.getFamilienname().getName()).isEqualTo(AntragstellerTestFactory.NACHNAME);
+ }
+
+ @Test
+ void shouldHaveEmptyFamilienname() {
+ var nameNatuerlichePerson = callCreator(AntragstellerTestFactory.createBuilder().nachname(null).build());
+
+ assertThat(nameNatuerlichePerson.getFamilienname().getName()).isEmpty();
+ }
+
+ @Nested
+ class TestWhenNullAntragsteller {
+
+ @Test
+ void shouldHaveEmptyAnrede() {
+ var nameNatuerlichePerson = callCreator(null);
+
+ assertThat(nameNatuerlichePerson.getAnrede()).isEmpty();
+ }
+
+ @Test
+ void shouldHaveEmptyVorname() {
+ var nameNatuerlichePerson = callCreator(null);
+
+ assertThat(nameNatuerlichePerson.getVorname().getName()).isEmpty();
+ }
+
+ @Test
+ void shouldHaveEmptyFamilienname() {
+ var nameNatuerlichePerson = callCreator(null);
+
+ assertThat(nameNatuerlichePerson.getFamilienname().getName()).isEmpty();
+ }
+ }
+
+ private NameNatuerlichePersonType callCreator(Antragsteller antragsteller) {
+ return creator.create(antragsteller);
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/NameNatuerlichePersonTypeTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/NameNatuerlichePersonTypeTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..09b861eca1903f844baf2075c85fd3f9b01219ae
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/NameNatuerlichePersonTypeTestFactory.java
@@ -0,0 +1,10 @@
+package de.ozgcloud.alfa.vorgang;
+
+import de.xoev.xdomea.NameNatuerlichePersonType;
+
+public class NameNatuerlichePersonTypeTestFactory {
+
+ public static NameNatuerlichePersonType create() {
+ return new NameNatuerlichePersonType();
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/VorgangTypeCreatorTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/VorgangTypeCreatorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..47ec3761ac84e0351a9cae1dcea008c995cb80a3
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/VorgangTypeCreatorTest.java
@@ -0,0 +1,197 @@
+package de.ozgcloud.alfa.vorgang;
+
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.Optional;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.Spy;
+
+import de.ozgcloud.alfa.common.AlfaTestUtils;
+import de.ozgcloud.alfa.export.AllgemeineMetadatenTypeTestFactory;
+import de.ozgcloud.alfa.export.IdentifikationObjektTypeTestFactory;
+import de.xoev.xdomea.AllgemeineMetadatenType;
+import de.xoev.xdomea.AnwendungsspezifischeErweiterungType;
+import de.xoev.xdomea.AnwendungsspezifischeErweiterungXMLType;
+import de.xoev.xdomea.IdentifikationObjektType;
+import de.xoev.xdomea.KontaktType;
+import de.xoev.xdomea.VorgangType;
+
+class VorgangTypeCreatorTest {
+
+ @Spy
+ @InjectMocks
+ private VorgangTypeCreator creator;
+
+ @Mock
+ private AnwendungsspezifischeErweiterungTypeCreator anwendungsspezifischeErweiterungTypeCreator;
+
+ @Mock
+ private AnwendungsspezifischeErweiterungXMLTypeCreator anwendungsspezifischeErweiterungXMLTypeCreator;
+
+ @Mock
+ private KontaktTypeCreator kontaktTypeCreator;
+
+ @Nested
+ class TestCreate {
+
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+
+ private final IdentifikationObjektType identifikationObjekt = IdentifikationObjektTypeTestFactory.create();
+ private final AllgemeineMetadatenType allgemeineMetadaten = AllgemeineMetadatenTypeTestFactory.create();
+ private final AnwendungsspezifischeErweiterungType anwendungsspezifischeErweiterung = AnwendungsspezifischeErweiterungTypeTestFactory.create();
+ private final AnwendungsspezifischeErweiterungXMLType anwendungsspezifischeErweiterungXML = new AnwendungsspezifischeErweiterungXMLType();
+ private final KontaktType kontakt = KontaktTypeTestFactory.create();
+
+ @BeforeEach
+ void init() {
+ doReturn(identifikationObjekt).when(creator).createIdentifikation();
+ doReturn(allgemeineMetadaten).when(creator).createAllgemeineMetadaten(vorgang);
+
+ when(anwendungsspezifischeErweiterungTypeCreator.create(vorgang)).thenReturn(anwendungsspezifischeErweiterung);
+ when(anwendungsspezifischeErweiterungXMLTypeCreator.create(vorgang)).thenReturn(anwendungsspezifischeErweiterungXML);
+ when(kontaktTypeCreator.create(vorgang)).thenReturn(Optional.of(kontakt));
+ }
+
+ @Test
+ void shouldCallAnwendungsspezifischeErweiterungTypeCreator() {
+ callCreator();
+
+ verify(anwendungsspezifischeErweiterungTypeCreator).create(vorgang);
+ }
+
+ @Test
+ void shouldHaveAnwendungsspezifischeErweiterungType() {
+ var vorgangType = callCreator();
+
+ assertThat(vorgangType.getAnwendungsspezifischeErweiterung()).isEqualTo(anwendungsspezifischeErweiterung);
+ }
+
+ @Test
+ void shouldCallAnwendungsspezifischeErweiterungXMLTypeCreator() {
+ callCreator();
+
+ verify(anwendungsspezifischeErweiterungXMLTypeCreator).create(vorgang);
+ }
+
+ @Test
+ void shouldHaveAnwendungsspezifischeErweiterungXMLType() {
+ var vorgangType = callCreator();
+
+ assertThat(vorgangType.getAnwendungsspezifischeErweiterungXML()).isEqualTo(anwendungsspezifischeErweiterungXML);
+ }
+
+ @Test
+ void shouldCallCreateIdentifikation() {
+ callCreator();
+
+ verify(creator).createIdentifikation();
+ }
+
+ @Test
+ void shouldHaveIdentifikation() {
+ var vorgangType = callCreator();
+
+ assertThat(vorgangType.getIdentifikation()).isEqualTo(identifikationObjekt);
+ }
+
+ @Test
+ void shouldCallCreateAllgemeineMetadaten() {
+ callCreator();
+
+ verify(creator).createAllgemeineMetadaten(vorgang);
+ }
+
+ @Test
+ void shouldHaveAllgemeineMetadaten() {
+ var vorgangType = callCreator();
+
+ assertThat(vorgangType.getAllgemeineMetadaten()).isEqualTo(allgemeineMetadaten);
+ }
+
+ @Test
+ void shouldCallKontaktTypeCreator() {
+ callCreator();
+
+ verify(kontaktTypeCreator).create(vorgang);
+ }
+
+ @Test
+ void shouldHaveKontakt() {
+ var vorgangType = callCreator();
+
+ assertThat(vorgangType.getKontakt()).containsExactly(kontakt);
+ }
+
+ @Test
+ void shouldNotHaveKontakt() {
+ when(kontaktTypeCreator.create(vorgang)).thenReturn(Optional.empty());
+ var vorgangType = callCreator();
+
+ assertThat(vorgangType.getKontakt()).isEmpty();
+ }
+
+ private VorgangType callCreator() {
+ return creator.create(vorgang);
+ }
+ }
+
+ @Nested
+ class TestCreateAllgemeineMetadaten {
+
+ private final VorgangWithEingang vorgang = VorgangWithEingangTestFactory.create();
+
+ @Test
+ void shouldHaveBetreff() {
+ var allgemeineMetadaten = creator.createAllgemeineMetadaten(vorgang);
+
+ assertThat(allgemeineMetadaten.getBetreff()).isEqualTo(VorgangHeaderTestFactory.NAME);
+ }
+
+ @Test
+ void shouldHaveKennzeichen() {
+ var allgemeineMetadaten = creator.createAllgemeineMetadaten(vorgang);
+
+ assertThat(allgemeineMetadaten.getKennzeichen()).isEqualTo(VorgangHeaderTestFactory.NUMMER);
+ }
+
+ @Test
+ void shouldHaveBemerkung() {
+ var allgemeineMetadaten = creator.createAllgemeineMetadaten(vorgang);
+
+ assertThat(allgemeineMetadaten.getBemerkung()).isEmpty();
+ }
+
+ @Test
+ void shouldHaveMedium() {
+ var allgemeineMetadaten = creator.createAllgemeineMetadaten(vorgang);
+
+ assertThat(allgemeineMetadaten.getMedium().getCode()).isEqualTo(VorgangTypeCreator.ALLGEMEINE_METADATEN_MEDIUM_CODE);
+ }
+
+ }
+
+ @Nested
+ class TestCreateIdentifikation {
+
+ @Test
+ void shouldHaveId() {
+ var identifikation = creator.createIdentifikation();
+
+ assertThat(identifikation.getID()).matches(AlfaTestUtils.UUID_REGEX);
+ }
+
+ @Test
+ void shouldHaveNummerImUebergeordnetenContainer() {
+ var identifikation = creator.createIdentifikation();
+
+ assertThat(identifikation.getNummerImUebergeordnetenContainer()).isEqualTo(VorgangTypeCreator.NUMMER_IM_UEBERGEORDNETEN_CONTAINER);
+ }
+ }
+
+}
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/VorgangTypeTestFactory.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/VorgangTypeTestFactory.java
new file mode 100644
index 0000000000000000000000000000000000000000..45ca4e476144809edd9e1b2a064a884bef92d68d
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/VorgangTypeTestFactory.java
@@ -0,0 +1,10 @@
+package de.ozgcloud.alfa.vorgang;
+
+import de.xoev.xdomea.VorgangType;
+
+public class VorgangTypeTestFactory {
+
+ public static VorgangType create() {
+ return new VorgangType();
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/WrappedValueExtractorITCase.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/WrappedValueExtractorITCase.java
new file mode 100644
index 0000000000000000000000000000000000000000..2235bb23d85ac3e6a812a49aa88b2ec107a32ea7
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/WrappedValueExtractorITCase.java
@@ -0,0 +1,55 @@
+package de.ozgcloud.alfa.vorgang;
+
+import static de.ozgcloud.alfa.vorgang.WrappedValueExtractor.*;
+import static org.assertj.core.api.Assertions.*;
+
+import java.util.Map;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+public class WrappedValueExtractorITCase {
+
+ @Nested
+ class TestExtractWrappedValues {
+
+ @Test
+ void shouldPreserveWrapperKeyWithoutParent() {
+ Map<String, Object> formData = Map.of(WRAPPER_KEY, "Kiel");
+
+ var formDataWithoutValueKeys = WrappedValueExtractor.extractWrappedValues(formData);
+
+ assertThat(formDataWithoutValueKeys).isEqualTo(formData);
+ }
+
+ @Test
+ void shouldEliminateWrapperKeyWithoutSiblings() {
+ Map<String, Object> formData = Map.of("ort", Map.of(WRAPPER_KEY, "Kiel"));
+ Map<String, Object> expected = Map.of("ort", "Kiel");
+
+ var formDataWithoutValueKeys = WrappedValueExtractor.extractWrappedValues(formData);
+
+ assertThat(formDataWithoutValueKeys).isEqualTo(expected);
+ }
+
+ @Test
+ void shouldPreserveWrapperKeyIfHasSiblings() {
+ Map<String, Object> formData = Map.of("ort", Map.of(WRAPPER_KEY, "Kiel", "value2", "Kiel"));
+
+ var formDataWithoutValueKeys = WrappedValueExtractor.extractWrappedValues(formData);
+
+ assertThat(formDataWithoutValueKeys).isEqualTo(formData);
+ }
+
+ @Test
+ void shouldPreserveNonWrapperKeys() {
+ Map<String, Object> formData = Map.of("empfangendestelle",
+ Map.of(WRAPPER_KEY, Map.of("OrganisationseinheitenAuswahl", Map.of(WRAPPER_KEY, "123456"))));
+ Map<String, Object> expected = Map.of("empfangendestelle", Map.of("OrganisationseinheitenAuswahl", "123456"));
+
+ var formDataWithoutValueKeys = WrappedValueExtractor.extractWrappedValues(formData);
+
+ assertThat(formDataWithoutValueKeys).isEqualTo(expected);
+ }
+ }
+}
diff --git a/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/WrappedValueExtractorTest.java b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/WrappedValueExtractorTest.java
new file mode 100644
index 0000000000000000000000000000000000000000..419c371d6aaf4f8a75904ec986814ffa4187881b
--- /dev/null
+++ b/alfa-xdomea/src/test/java/de/ozgcloud/alfa/vorgang/WrappedValueExtractorTest.java
@@ -0,0 +1,176 @@
+package de.ozgcloud.alfa.vorgang;
+
+import static de.ozgcloud.alfa.vorgang.WrappedValueExtractor.*;
+import static org.assertj.core.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+import java.util.Map;
+
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.MockedStatic;
+
+public class WrappedValueExtractorTest {
+
+ @Nested
+ class TestExtractWrappedValues {
+
+ private static final String KEY1 = "key1";
+ private static final String KEY2 = "key2";
+ private static final String KEY3 = "key3";
+
+ @Captor
+ private ArgumentCaptor<Object> valueCaptor;
+ private final Map<String, Object> originalData = Map.of(KEY1, "value1", KEY2, true, KEY3, 100);
+ private final Map<String, Object> extractedData = Map.of(KEY1, "extracted1", KEY2, "extracted2", KEY3, "extracted3");
+
+ @Test
+ void shouldCallReplaceWrappedValueWithDirectValue() {
+ try (MockedStatic<WrappedValueExtractor> wrappedValueExtractor = mockStatic(WrappedValueExtractor.class)) {
+ unmockMethodUnderTest(wrappedValueExtractor);
+
+ WrappedValueExtractor.extractWrappedValues(originalData);
+
+ wrappedValueExtractor.verify(() -> WrappedValueExtractor.replaceWrappedValueWithDirectValue(valueCaptor.capture()), times(
+ originalData.size()));
+ assertThat(valueCaptor.getAllValues()).containsExactlyElementsOf(originalData.values());
+ }
+ }
+
+ @Test
+ void shouldReturnMapWithReplacedValues() {
+ try (MockedStatic<WrappedValueExtractor> wrappedValueExtractor = mockStatic(WrappedValueExtractor.class)) {
+ unmockMethodUnderTest(wrappedValueExtractor);
+ wrappedValueExtractor.when(() -> WrappedValueExtractor.replaceWrappedValueWithDirectValue(originalData.get(KEY1))).thenReturn(extractedData.get(KEY1));
+ wrappedValueExtractor.when(() -> WrappedValueExtractor.replaceWrappedValueWithDirectValue(originalData.get(KEY2))).thenReturn(extractedData.get(KEY2));
+ wrappedValueExtractor.when(() -> WrappedValueExtractor.replaceWrappedValueWithDirectValue(originalData.get(KEY3))).thenReturn(extractedData.get(KEY3));
+
+ var result = WrappedValueExtractor.extractWrappedValues(originalData);
+
+ assertThat(result).isEqualTo(extractedData);
+ }
+ }
+
+ private void unmockMethodUnderTest(MockedStatic<WrappedValueExtractor> wrappedValueExtractor) {
+ wrappedValueExtractor.when(() -> WrappedValueExtractor.extractWrappedValues(any())).thenCallRealMethod();
+ }
+ }
+
+ @Nested
+ class TestReplaceWrappedValueWithDirectValue {
+
+ private final String simpleValue = "simple value";
+ private final Map<String, Object> mapValue = Map.of("key1", "value1", "key2", "value2");
+ private final Map<String, Object> wrappedValue = Map.of(WRAPPER_KEY, "value1");
+
+ @Test
+ void shouldReturnValue() {
+ try (MockedStatic<WrappedValueExtractor> wrappedValueExtractor = mockStatic(WrappedValueExtractor.class)) {
+ unmockMethodUnderTest(wrappedValueExtractor);
+
+ var result = WrappedValueExtractor.replaceWrappedValueWithDirectValue(simpleValue);
+
+ assertThat(result).isEqualTo(simpleValue);
+ }
+ }
+
+ @Test
+ void shouldCallIsWrappedValue() {
+ try (MockedStatic<WrappedValueExtractor> wrappedValueExtractor = mockStatic(WrappedValueExtractor.class)) {
+ unmockMethodUnderTest(wrappedValueExtractor);
+
+ WrappedValueExtractor.replaceWrappedValueWithDirectValue(mapValue);
+
+ wrappedValueExtractor.verify(() -> WrappedValueExtractor.isWrappedValue(mapValue));
+ }
+ }
+
+ @Test
+ void shouldCallItself() {
+ try (MockedStatic<WrappedValueExtractor> wrappedValueExtractor = mockStatic(WrappedValueExtractor.class)) {
+ unmockMethodUnderTest(wrappedValueExtractor);
+ wrappedValueExtractor.when(() -> WrappedValueExtractor.isWrappedValue(wrappedValue)).thenReturn(true);
+
+ WrappedValueExtractor.replaceWrappedValueWithDirectValue(wrappedValue);
+
+ wrappedValueExtractor.verify(() -> WrappedValueExtractor.replaceWrappedValueWithDirectValue(wrappedValue.get(WRAPPER_KEY)));
+ }
+ }
+
+ @Test
+ void shouldReturnResultOfCallingItself() {
+ try (MockedStatic<WrappedValueExtractor> wrappedValueExtractor = mockStatic(WrappedValueExtractor.class)) {
+ unmockMethodUnderTest(wrappedValueExtractor);
+ wrappedValueExtractor.when(() -> WrappedValueExtractor.isWrappedValue(wrappedValue)).thenReturn(true);
+
+ var result = WrappedValueExtractor.replaceWrappedValueWithDirectValue(wrappedValue);
+
+ assertThat(result).isEqualTo(wrappedValue.get(WRAPPER_KEY));
+ }
+ }
+
+ @Test
+ void shouldCallExtractWrappedValues() {
+ try (MockedStatic<WrappedValueExtractor> wrappedValueExtractor = mockStatic(WrappedValueExtractor.class)) {
+ unmockMethodUnderTest(wrappedValueExtractor);
+ wrappedValueExtractor.when(() -> WrappedValueExtractor.isWrappedValue(mapValue)).thenReturn(false);
+
+ WrappedValueExtractor.replaceWrappedValueWithDirectValue(mapValue);
+
+ wrappedValueExtractor.verify(() -> WrappedValueExtractor.extractWrappedValues(mapValue));
+ }
+ }
+
+ @Test
+ void shouldReturnResultOfExtractWrappedValues() {
+ final Map<String, Object> extractVrappedValuesResult = Map.of("resultKey", "resultValue");
+ try (MockedStatic<WrappedValueExtractor> wrappedValueExtractor = mockStatic(WrappedValueExtractor.class)) {
+ unmockMethodUnderTest(wrappedValueExtractor);
+ wrappedValueExtractor.when(() -> WrappedValueExtractor.isWrappedValue(mapValue)).thenReturn(false);
+ wrappedValueExtractor.when(() -> WrappedValueExtractor.extractWrappedValues(any())).thenReturn(extractVrappedValuesResult);
+
+ var result = WrappedValueExtractor.replaceWrappedValueWithDirectValue(mapValue);
+
+ assertThat(result).isEqualTo(extractVrappedValuesResult);
+ }
+ }
+
+ private void unmockMethodUnderTest(MockedStatic<WrappedValueExtractor> wrappedValueExtractor) {
+ wrappedValueExtractor.when(() -> WrappedValueExtractor.replaceWrappedValueWithDirectValue(any())).thenCallRealMethod();
+ }
+ }
+
+ @Nested
+ class TestIsWrappedValue {
+
+ @Test
+ void shouldReturnTrueIfWrapped() {
+ var result = WrappedValueExtractor.isWrappedValue(Map.of(WRAPPER_KEY, "value1"));
+
+ assertThat(result).isTrue();
+ }
+
+ @Test
+ void shouldReturnFalseIfHasMultipleEntries() {
+ var result = WrappedValueExtractor.isWrappedValue(Map.of(WRAPPER_KEY, "value1", "key2", "value2"));
+
+ assertThat(result).isFalse();
+ }
+
+ @Test
+ void shouldReturnFalseIfNotWrapped() {
+ var result = WrappedValueExtractor.isWrappedValue(Map.of("key1", "value1"));
+
+ assertThat(result).isFalse();
+ }
+
+ @Test
+ void shouldReturnFalseIfEmpty() {
+ var result = WrappedValueExtractor.isWrappedValue(Map.of());
+
+ assertThat(result).isFalse();
+ }
+ }
+}
diff --git a/alfa-xdomea/src/test/resources/META-INF/services/org.junit.jupiter.api.extension.Extension b/alfa-xdomea/src/test/resources/META-INF/services/org.junit.jupiter.api.extension.Extension
new file mode 100644
index 0000000000000000000000000000000000000000..79b126e6cdb86bec1f4f08c205de8961bde1934a
--- /dev/null
+++ b/alfa-xdomea/src/test/resources/META-INF/services/org.junit.jupiter.api.extension.Extension
@@ -0,0 +1 @@
+org.mockito.junit.jupiter.MockitoExtension
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/resources/application-itcase.yaml b/alfa-xdomea/src/test/resources/application-itcase.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..c6f85b1e94d61d1ee6c5992b97cbac70b7260e24
--- /dev/null
+++ b/alfa-xdomea/src/test/resources/application-itcase.yaml
@@ -0,0 +1,5 @@
+ozgcloud:
+ xdomea:
+ behoerdenschluessel: ABC
+ behoerdenschluesselUri: http://meine.behoer.de
+ behoerdenschluesselVersion: 1.0.15b
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/resources/junit-platform.properties b/alfa-xdomea/src/test/resources/junit-platform.properties
new file mode 100644
index 0000000000000000000000000000000000000000..1cebb76d5a58ac034b2627d12411d82d1e85821e
--- /dev/null
+++ b/alfa-xdomea/src/test/resources/junit-platform.properties
@@ -0,0 +1 @@
+junit.jupiter.extensions.autodetection.enabled = true
\ No newline at end of file
diff --git a/alfa-xdomea/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker b/alfa-xdomea/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker
new file mode 100644
index 0000000000000000000000000000000000000000..ca6ee9cea8ec189a088d50559325d4e84ff8ad09
--- /dev/null
+++ b/alfa-xdomea/src/test/resources/mockito-extensions/org.mockito.plugins.MockMaker
@@ -0,0 +1 @@
+mock-maker-inline
\ No newline at end of file
diff --git a/pom.xml b/pom.xml
index e1e8d8fc73a898af035a72f0cee6eed9f3c434a8..b94a9aeca3933d3690cf4dfe516a54515f43d240 100644
--- a/pom.xml
+++ b/pom.xml
@@ -42,6 +42,7 @@
<modules>
<module>alfa-client</module>
<module>alfa-server</module>
+ <module>alfa-xdomea</module>
<module>alfa-service</module>
</modules>
@@ -54,7 +55,6 @@
<ozgcloud-common-pdf.version>3.0.1</ozgcloud-common-pdf.version>
<user-manager.version>2.8.0</user-manager.version>
<zufi-manager.version>1.5.0</zufi-manager.version>
- <archive-manager.version>0.1.0-SNAPSHOT</archive-manager.version>
<spring-cloud-config-client.version>4.1.3</spring-cloud-config-client.version>
<!-- TODO: die Version über ozgcloud-common ziehen -->
@@ -140,11 +140,6 @@
</exclusion>
</exclusions>
</dependency>
- <dependency>
- <groupId>de.ozgcloud.archive</groupId>
- <artifactId>archive-manager-interface</artifactId>
- <version>${archive-manager.version}</version>
- </dependency>
<dependency>
<groupId>io.jsonwebtoken</groupId>
diff --git a/release-startdev.sh b/release-startdev.sh
index 960b59df8fb9a765221405fe7166050d4a5d6e9d..1a0b61139aba8cad4e1b13f77bcb9f9382148b8c 100755
--- a/release-startdev.sh
+++ b/release-startdev.sh
@@ -17,7 +17,8 @@ echo
#
PROJECTS="pom.xml:main
alfa-service/pom.xml:parent
- alfa-server/pom.xml:parent
+ alfa-xdomea/pom.xml:parent
+ alfa-server/pom.xml:parent
alfa-client/pom.xml:parent "
for PROJECT in $PROJECTS;
diff --git a/src/main/helm/templates/_helpers.tpl b/src/main/helm/templates/_helpers.tpl
index d372c36a7bf03ba41f97df64697eda36d8ecf120..35797e518111a96685b6f6af018c73ac614727df 100644
--- a/src/main/helm/templates/_helpers.tpl
+++ b/src/main/helm/templates/_helpers.tpl
@@ -53,10 +53,6 @@ app.kubernetes.io/namespace: {{ include "app.namespace" . }}
{{ printf "dns:///%s.%s:9090" ( coalesce .Values.vorgangManagerName "vorgang-manager" ) .Release.Namespace | replace "+" "_" | trunc 63 | trimSuffix "-" }}
{{- end -}}
-{{- define "app.grpc_client_archive_manager_address" -}}
-{{ printf "dns:///%s.%s:9090" ( coalesce .Values.archiveManagerName "vorgang-manager" ) .Release.Namespace | replace "+" "_" | trunc 63 | trimSuffix "-" }}
-{{- end -}}
-
{{- define "app.grpc_client_user-manager_address" -}}
{{ printf "dns:///%s.%s:9000" ( coalesce .Values.usermanagerName "user-manager" ) .Release.Namespace }}
{{- end -}}
diff --git a/src/main/helm/templates/deployment.yaml b/src/main/helm/templates/deployment.yaml
index 91335d88865df4177cdc971a2585193d9811cf61..585408d9e599665f5ac4777b117051c601ebeaec 100644
--- a/src/main/helm/templates/deployment.yaml
+++ b/src/main/helm/templates/deployment.yaml
@@ -78,10 +78,6 @@ spec:
value: {{ include "app.grpc_client_user-manager_address" . }}
- name: grpc_client_user-manager_negotiationType
value: {{ (.Values.userManager).grpcClientNegotiationType | default "TLS" }}
- - name: grpc_client_archive-manager_address
- value: {{ include "app.grpc_client_archive_manager_address" . }}
- - name: grpc_client_archive-manager_negotiationType
- value: {{ (.Values.archiveManager).grpcClientNegotiationType | default "TLS" }}
- name: spring_profiles_active
value: {{ include "app.envSpringProfiles" . }}
- name: keycloak_realm
diff --git a/src/test/helm/deployment_archive_manager_address_env_test.yaml b/src/test/helm/deployment_archive_manager_address_env_test.yaml
deleted file mode 100644
index 148184f0fae94370660e8f49ba6caa74b9182653..0000000000000000000000000000000000000000
--- a/src/test/helm/deployment_archive_manager_address_env_test.yaml
+++ /dev/null
@@ -1,49 +0,0 @@
-#
-# Copyright (C) 2024 Das Land Schleswig-Holstein vertreten durch den
-# Ministerpräsidenten des Landes Schleswig-Holstein
-# Staatskanzlei
-# Abteilung Digitalisierung und zentrales IT-Management der Landesregierung
-#
-# Lizenziert unter der EUPL, Version 1.2 oder - sobald
-# diese von der Europäischen Kommission genehmigt wurden -
-# Folgeversionen der EUPL ("Lizenz");
-# Sie dürfen dieses Werk ausschließlich gemäß
-# dieser Lizenz nutzen.
-# Eine Kopie der Lizenz finden Sie hier:
-#
-# https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
-#
-# Sofern nicht durch anwendbare Rechtsvorschriften
-# gefordert oder in schriftlicher Form vereinbart, wird
-# die unter der Lizenz verbreitete Software "so wie sie
-# ist", OHNE JEGLICHE GEWÄHRLEISTUNG ODER BEDINGUNGEN -
-# ausdrücklich oder stillschweigend - verbreitet.
-# Die sprachspezifischen Genehmigungen und Beschränkungen
-# unter der Lizenz sind dem Lizenztext zu entnehmen.
-#
-
-suite: test deployment archive-manager address
-release:
- name: alfa
- namespace: sh-helm-test
-templates:
- - templates/deployment.yaml
-set:
- baseUrl: test.company.local
- ozgcloud:
- environment: test
- bundesland: sh
- bezeichner: helm
- sso:
- serverUrl: https://sso.company.local
- imagePullSecret: image-pull-secret
-tests:
- - it: should set the archive-manager name
- set:
- archiveManagerName: my-test-archive-manager-name
- asserts:
- - contains:
- path: spec.template.spec.containers[0].env
- content:
- name: grpc_client_archive-manager_address
- value: dns:///my-test-archive-manager-name.sh-helm-test:9090
diff --git a/src/test/helm/deployment_defaults_env_test.yaml b/src/test/helm/deployment_defaults_env_test.yaml
index ec868f133c64569d5ddf0cf73c8dc2c1cde3e9b8..9bdb30b9dcc2621609553f09a9fcefb01a63fcfa 100644
--- a/src/test/helm/deployment_defaults_env_test.yaml
+++ b/src/test/helm/deployment_defaults_env_test.yaml
@@ -54,11 +54,6 @@ tests:
content:
name: grpc_client_user-manager_address
value: dns:///user-manager.sh-helm-test:9000
- - contains:
- path: spec.template.spec.containers[0].env
- content:
- name: grpc_client_archive-manager_address
- value: dns:///vorgang-manager.sh-helm-test:9090
- it: should have service binding root
set:
@@ -155,21 +150,3 @@ tests:
content:
name: grpc_client_vorgang-manager_negotiationType
value: TLS
-
- - it: should set archive-manager negotiationType plaintext
- set:
- archiveManager.grpcClientNegotiationType: PLAINTEXT
- asserts:
- - contains:
- path: spec.template.spec.containers[0].env
- content:
- name: grpc_client_archive-manager_negotiationType
- value: PLAINTEXT
-
- - it: should contain default archive-manager negotiationType tls
- asserts:
- - contains:
- path: spec.template.spec.containers[0].env
- content:
- name: grpc_client_archive-manager_negotiationType
- value: TLS