com.genexus.messaging.queue.SimpleMessageQueue Maven / Gradle / Ivy

Go to download
package com.genexus.messaging.queue;

import com.genexus.*;
import com.genexus.diagnostics.core.ILogger;
import com.genexus.diagnostics.core.LogManager;
import com.genexus.messaging.queue.model.DeleteMessageResult;
import com.genexus.messaging.queue.model.MessageQueueOptions;
import com.genexus.messaging.queue.model.SendMessageResult;
import com.genexus.messaging.queue.model.SimpleQueueMessage;
import com.genexusmessaging.genexusmessagingqueue.simplequeue.SdtMessage;
import com.genexusmessaging.genexusmessagingqueue.simplequeue.SdtMessageOptions;
import com.genexusmessaging.genexusmessagingqueue.simplequeue.SdtMessageResult;

import java.util.ArrayList;
import java.util.List;

public class SimpleMessageQueue {
	private IQueue queue;
	private static ILogger logger = LogManager.getLogger(SimpleMessageQueue.class);

	public SimpleMessageQueue() {

	}

	public SimpleMessageQueue(IQueue queueProvider) {
		queue = queueProvider;
	}

	void validQueue() throws Exception {
		if (queue == null) {
			logger.error("Queue was not instantiated.");
			throw new Exception("Queue was not instantiated.");
		}
	}

	public void clear(GXBaseCollection[] errorMessagesArr, boolean[] success) {
		GXBaseCollection errorMessages = errorMessagesArr[0];
		errorMessages.clear();
		try {
			validQueue();
			success[0] = queue.purge();
		} catch (Exception ex) {
			queueErrorMessagesSetup(ex, errorMessages);
			logger.error("Could not clear queue", ex);
		}
		success[0] = false;
	}

	public short getQueueLength(GXBaseCollection[] errorMessagesArr, boolean[] success) {
		GXBaseCollection errorMessages = errorMessagesArr[0];
		errorMessages.clear();
		short queueLength = 0;
		try {
			validQueue();
			queueLength = queue.getQueueLength().shortValue();
		} catch (Exception ex) {
			queueErrorMessagesSetup(ex, errorMessages);
			logger.error("Could not getQueueLength", ex);
		}
		return queueLength;
	}

	public SdtMessageResult sendMessage(SdtMessage sdtMessage, GXBaseCollection[] errorMessagesArr, boolean[] success) {
		GXBaseCollection messages = new GXBaseCollection<>();
		messages.add(sdtMessage);
		GXBaseCollection result = sendMessages(messages, new SdtMessageOptions(), errorMessagesArr, success);
		return ((result.size() == 1) ? result.item(1) : Convert.toSdtMessageResult(new SendMessageResult()));
	}

	public GXBaseCollection sendMessages(GXBaseCollection sdtMessages, SdtMessageOptions msgOptions, GXBaseCollection[] errorMessagesArr, boolean[] success) {
		GXBaseCollection errorMessages = errorMessagesArr[0];
		List msgList = new ArrayList<>();
		GXBaseCollection listReturn = new GXBaseCollection<>();
		errorMessages.clear();

		for (SdtMessage m : sdtMessages) {
			msgList.add(Convert.toSimpleQueueMessage(m));
		}

		try {
			validQueue();
			List sendMessageResult = queue.sendMessages(msgList, Convert.toMessageQueueOptions(msgOptions));
			success[0] = true;
			for (SendMessageResult msgResult : sendMessageResult) {
				listReturn.add(Convert.toSdtMessageResult(msgResult));
			}
		} catch (Exception ex) {
			queueErrorMessagesSetup(ex, errorMessages);
			logger.error("Could not send queue message", ex);
		}

		return listReturn;
	}

	public GXBaseCollection getMessages(GXBaseCollection[] errorMessagesArr, boolean[] success) {
		return getMessages(null, errorMessagesArr, success);
	}

	public GXBaseCollection getMessages(SdtMessageOptions receiveOptions, GXBaseCollection[] errorMessagesArr, boolean[] success) {
		GXBaseCollection errorMessages = errorMessagesArr[0];

		MessageQueueOptions mqOptions = (receiveOptions != null) ? Convert.toMessageQueueOptions(receiveOptions) : new MessageQueueOptions();
		List receivedMessages = queue.getMessages(mqOptions);
		GXBaseCollection receivedMessagesResult = new GXBaseCollection<>();
		try {
			validQueue();
			for (SimpleQueueMessage m : receivedMessages) {
				receivedMessagesResult.add(Convert.toSdtMessage(m));
			}
			success[0] = true;
		} catch (Exception ex) {
			queueErrorMessagesSetup(ex, errorMessages);
			logger.error(String.format("Could not get Messages from Queue"), ex);
		}
		return receivedMessagesResult;
	}

	public SdtMessageResult deleteMessage(SdtMessage msg, GXBaseCollection[] errorMessagesArr, boolean[] success) {
		GXBaseCollection errorMessages = errorMessagesArr[0];
		errorMessages.clear();
		SdtMessageResult sdtDelete = new SdtMessageResult();
		if (msg == null || msg.getgxTv_SdtMessage_Messagehandleid().isEmpty()) {
			sdtDelete.setgxTv_SdtMessageResult_Messagestatus(DeleteMessageResult.FAILED);
			appendErrorMessage(errorMessages, 1, "Message HandledId property cannot be empty");
			return sdtDelete;
		}

		try {
			validQueue();
			DeleteMessageResult deletedMessage = queue.deleteMessage(msg.getgxTv_SdtMessage_Messagehandleid());
			sdtDelete.setgxTv_SdtMessageResult_Messageid(deletedMessage.getMessageId());
			sdtDelete.setgxTv_SdtMessageResult_Servermessageid(deletedMessage.getMessageServerId());
			sdtDelete.setgxTv_SdtMessageResult_Messagestatus(deletedMessage.getMessageDeleteStatus());
			success[0] = true;
		} catch (Exception ex) {
			queueErrorMessagesSetup(ex, errorMessages);
			logger.error(String.format("Could not delete Message '%s' from Queue", msg.getgxTv_SdtMessage_Messagehandleid()), ex);
		}
		return sdtDelete;
	}

	public GXBaseCollection deleteMessages(GXBaseCollection msgHandlesToDelete, GXBaseCollection[] errorMessagesArr, boolean[] success) {
		GXBaseCollection errorMessages = errorMessagesArr[0];
		errorMessages.clear();
		try {
			validQueue();
			List handles = new ArrayList<>();
			for (SdtMessage msg : msgHandlesToDelete) {
				handles.add(msg.getgxTv_SdtMessage_Messagehandleid());
			}
			List deletedMessage = queue.deleteMessages(handles);
			success[0] = true;
			return Convert.toDeleteExternalMessageResultList(deletedMessage);
		} catch (Exception ex) {
			queueErrorMessagesSetup(ex, errorMessages);
			logger.error(String.format("Could not delete Messages from Queue "), ex);
		}
		return new GXBaseCollection();
	}

	protected void queueErrorMessagesSetup(Exception ex, GXBaseCollection messages) {
		if (messages != null && ex != null) {
			appendErrorMessage(messages, 1, ex.getMessage());
		}
	}

	private void appendErrorMessage(GXBaseCollection messages, int errorType, String errMessage) {
		SdtMessages_Message struct = new SdtMessages_Message();
		struct.setgxTv_SdtMessages_Message_Type((byte) errorType);
		struct.setgxTv_SdtMessages_Message_Description(errMessage);
		messages.add(struct);
	}

}