XtaClient.java

package de.ozgcloud.xta.client;

import jakarta.validation.Valid;
import jakarta.validation.constraints.NotBlank;

import de.ozgcloud.xta.client.config.XtaClientConfig;
import de.ozgcloud.xta.client.core.WrappedXtaService;
import de.ozgcloud.xta.client.model.XtaIdentifier;
import de.ozgcloud.xta.client.model.XtaMessage;
import de.ozgcloud.xta.client.model.XtaMessageAndTransportReport;
import de.ozgcloud.xta.client.model.XtaMessageMetaDataListing;
import de.ozgcloud.xta.client.model.XtaTransportReport;
import genv3.de.xoev.transport.xta.x211.InvalidMessageIDException;
import genv3.de.xoev.transport.xta.x211.MessageSchemaViolationException;
import genv3.de.xoev.transport.xta.x211.MessageVirusDetectionException;
import genv3.de.xoev.transport.xta.x211.ParameterIsNotValidException;
import genv3.de.xoev.transport.xta.x211.PermissionDeniedException;
import genv3.de.xoev.transport.xta.x211.SyncAsyncException;
import genv3.de.xoev.transport.xta.x211.XTAWSTechnicalProblemException;
import lombok.AccessLevel;
import lombok.Builder;
import lombok.Getter;
import lombok.RequiredArgsConstructor;

@RequiredArgsConstructor(access = AccessLevel.MODULE)
@Builder(access = AccessLevel.MODULE)
@Getter(AccessLevel.MODULE)
public class XtaClient {

	private final WrappedXtaService service;
	private final XtaClientConfig config;

	/**
	 * Fetch metadata of pending messages sent to the {@code xtaIdentifier}. The returned listing contains at most
	 * {@link de.ozgcloud.xta.client.config.XtaClientConfig#getMaxListItems() maxListItems} messages. To fetch the next messages, use
	 * {@link #getNextMessagesMetadata(String)}. Note that {@code xtaIdentifier} has to be configured as a
	 * {@link de.ozgcloud.xta.client.config.XtaClientConfig#getClientIdentifiers() clientIdentifiers}.
	 *
	 * @param clientIdentifier the client identifier value to fetch messages for
	 * @return the listing result with metadata of messages
	 */
	public XtaMessageMetaDataListing getMessagesMetadata(@NotBlank String clientIdentifier)
			throws XTAWSTechnicalProblemException, PermissionDeniedException {
		var identifier = deriveIdentifier(clientIdentifier);
		service.checkAccountActive(identifier);
		return getStatusList(identifier);
	}

	/**
	 * Fetch metadata of pending messages sent to the {@code xtaIdentifier}. This method skips checks but otherwise behaves exactly as
	 * {@link #getMessagesMetadata(String)}.
	 */
	public XtaMessageMetaDataListing getNextMessagesMetadata(@NotBlank String clientIdentifier)
			throws XTAWSTechnicalProblemException, PermissionDeniedException {
		return getStatusList(deriveIdentifier(clientIdentifier));
	}

	private XtaMessageMetaDataListing getStatusList(XtaIdentifier clientIdentifier) throws XTAWSTechnicalProblemException, PermissionDeniedException {
		return service.getStatusList(clientIdentifier, config.getMaxListItems());
	}

	/**
	 * Fetch the message content, close the message, and then fetch the transport report for the given {@code messageId} and reader identifier
	 * {@code clientIdentifier}.
	 *
	 * @param clientIdentifier Identifier of the reading client
	 * @param messageId        Identifier of the message to fetch
	 * @return The message and transport report
	 */
	public XtaMessageAndTransportReport getMessage(@NotBlank String clientIdentifier, @NotBlank String messageId)
			throws XTAWSTechnicalProblemException, PermissionDeniedException, InvalidMessageIDException {
		var identifier = deriveIdentifier(clientIdentifier);

		var message = service.getMessage(messageId, identifier);
		service.close(messageId, identifier);

		var transportReport = service.getTransportReport(messageId, identifier);
		return XtaMessageAndTransportReport.builder()
				.message(message)
				.transportReport(transportReport)
				.build();
	}

	public XtaTransportReport sendMessage(@Valid XtaMessage messageWithoutMessageId)
			throws XTAWSTechnicalProblemException, PermissionDeniedException, InvalidMessageIDException, SyncAsyncException,
			MessageVirusDetectionException, MessageSchemaViolationException, ParameterIsNotValidException {

		var metaData = messageWithoutMessageId.metaData();
		var authorIdentifier = metaData.authorIdentifier();
		service.checkAccountActive(authorIdentifier);
		service.lookupService(metaData.service(), metaData.readerIdentifier(), authorIdentifier);

		var messageId = service.createMessageId(authorIdentifier);
		service.sendMessage(createXtaMessageWithMessageId(messageWithoutMessageId, messageId));

		return service.getTransportReport(messageId, authorIdentifier);
	}

	XtaMessage createXtaMessageWithMessageId(XtaMessage messageWithoutMessageId, String messageId) {
		return messageWithoutMessageId.toBuilder()
				.metaData(messageWithoutMessageId.metaData().toBuilder()
						.messageId(messageId)
						.build())
				.build();
	}

	XtaIdentifier deriveIdentifier(String xtaIdentifier) {
		return config.getClientIdentifiers().stream()
				.filter(id -> id.value().equals(xtaIdentifier))
				.findFirst()
				.orElseThrow(() -> new IllegalArgumentException("Unknown identifier: " + xtaIdentifier));
	}
}