Skip to content
Snippets Groups Projects
Commit ff6d0a15 authored by OZGCloud's avatar OZGCloud
Browse files

Revert "Merge pull request 'OZG-6162-archive-manager-anbindung' (#820) from...

Revert "Merge pull request 'OZG-6162-archive-manager-anbindung' (#820) from OZG-6162-archive-manager-anbindung into master"

This reverts commit ee5a9e25, reversing
changes made to a3aa7b84.
parent e343d062
Branches
Tags
No related merge requests found
Showing
with 419 additions and 344 deletions
......@@ -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")
......
......@@ -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>
......
......@@ -16,8 +16,6 @@ grpc:
negotiationType: PLAINTEXT
zufi-manager:
negotiationType: PLAINTEXT
archive-manager:
negotiationType: PLAINTEXT
ozgcloud:
feature:
......
......@@ -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:
......
......@@ -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>
......
......@@ -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) {
......
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);
}
}
package de.ozgcloud.alfa.export;
import java.io.IOException;
import java.io.OutputStream;
interface ExportedVorgangFile {
String getFileName();
void writeToOutputStream(OutputStream outputStream) throws IOException;
}
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());
}
}
}
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);
}
}
}
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();
}
}
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();
}
}
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());
}
}
}
<?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>
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;
}
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) {
}
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();
}
}
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();
}
}
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;
}
}
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);
}
}
}
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment