protected void btnReceiveMessage_Click(object sender, EventArgs e)
{
if (QueuesList.SelectedIndex > -1)
{
string message = string.Empty;
string selectedQueue = this.QueuesList.SelectedItem.Value.ToString();
ReceiveMessageResponse queueReceiveMessageResponse = new ReceiveMessageResponse();
queueReceiveMessageResponse = objClient.ReceiveMessage(new ReceiveMessageRequest()
{
QueueUrl = selectedQueue, MaxNumberOfMessages = 10
});
ReceiveMessageResult objReceiveMessageResult = new ReceiveMessageResult();
objReceiveMessageResult = queueReceiveMessageResponse.ReceiveMessageResult;
List <Message> messagesList = new List <Message>();
messagesList = objReceiveMessageResult.Message;
foreach (Message objMessage in messagesList)
{
message += objMessage.Body;
receiptHandle = objMessage.ReceiptHandle;
}
Session["MessageReceiptHandle"] = receiptHandle;
txtReceivedMessage.Text = message;
}
else
{
Response.Write("<script>alert('Please select Queue from list.');</script>");
}
}
private int ProcessMessage()
{
int numReceived = 0;
ActivityItems items = null;
try {
ReceiveMessageResponse receiveMessageResponse = sqs.ReceiveMessage(receiveMessageRequest);
if (receiveMessageResponse.IsSetReceiveMessageResult())
{
ReceiveMessageResult receiveMessageResult = receiveMessageResponse.ReceiveMessageResult;
numReceived = receiveMessageResult.Message.Count;
foreach (Message message in receiveMessageResult.Message)
{
items = getActivityItems(message);
dispatchItems(items);
deleteMessageRequest.WithReceiptHandle(message.ReceiptHandle);
sqs.DeleteMessage(deleteMessageRequest);
}
}
} catch (Exception ex) {
log.Warn("An unknown error has occurred. Will retry message.", ex);
}
return(numReceived);
}
public static void ValidateReceiveMessage(ReceiveMessageResult response)
{
if (response != null && response.Messages != null && response.Messages.Count > 0)
{
foreach (Message message in response.Messages)
{
ValidateMD5(message);
}
}
}
public void Test_ReceiveMessage_With_ValidQueue_And_Check_For_ReceivedMessage()
{
bool hasCallbackArrived = false;
string actualValue = string.Empty;
string expectedValue = "A test message body during Unit-Testing";
SQSResponseEventHandler <object, ResponseEventArgs> handler = null;
handler = delegate(object sender, ResponseEventArgs args)
{
ISQSResponse result = args.Response;
//Unhook from event.
_client.OnSQSResponse -= handler;
ReceiveMessageResponse response = result as ReceiveMessageResponse;
if (null != response)
{
ReceiveMessageResult messageResult = response.ReceiveMessageResult;
if (null != messageResult)
{
if (messageResult.Message.Count > 0)
{
Message message = messageResult.Message[0];
if (null != message)
{
actualValue = message.Body;
}
}
}
}
hasCallbackArrived = true;
};
//Hook to event
_client.OnSQSResponse += handler;
//Create request object.
ReceiveMessageRequest request = new ReceiveMessageRequest
{
QueueUrl = (string.Format("{0}/{1}", QueueURL, _queue_UnitTesting)),
};
_client.ReceiveMessage(request);
EnqueueConditional(() => hasCallbackArrived);
EnqueueCallback(() => Assert.IsTrue(string.Compare(expectedValue, actualValue) == 0));
EnqueueTestComplete();
}
/// <summary>
/// Wrapper to receive message and download files <see cref="Threema.MsgApi.Helpers.E2EHelper.ReceiveMessage"/>
/// </summary>
/// <param name="id">Sender id</param>
/// <param name="from">From id</param>
/// <param name="secret">From secret</param>
/// <param name="privateKey">From private key</param>
/// <param name="messageId">Message id</param>
/// <param name="nonce">Nonce as hex-string</param>
/// <param name="box">Box message as hex-string</param>
/// <param name="outputFolder">Optional path to output folder</param>
/// <param name="apiUrl">Optional api url</param>
/// <returns>Array with message-type, message-id and message</returns>
public ArrayList ReceiveMessage(string id, string from, string secret, string privateKey, string messageId, string nonce, string box, string outputFolder = null, string apiUrl = APIConnector.DEFAULTAPIURL)
{
byte[] privateKeyBytes = GetKey(privateKey, Key.KeyType.PRIVATE);
byte[] nonceBytes = DataUtils.HexStringToByteArray(nonce);
E2EHelper e2EHelper = new E2EHelper(this.CreateConnector(from, secret, apiUrl), privateKeyBytes);
byte[] boxBytes = DataUtils.HexStringToByteArray(box);
ReceiveMessageResult res = e2EHelper.ReceiveMessage(id, messageId, boxBytes, nonceBytes, outputFolder);
ArrayList result = new ArrayList();
result.Add(res.Message.GetTypeCode().ToString());
result.Add(res.MessageId);
result.Add(res.Message.ToString());
return(result);
}
public static Message Get(string queue_url)
{
AmazonSQS sqs = AWSClientFactory.CreateAmazonSQSClient();
ReceiveMessageRequest r_msgreq = new ReceiveMessageRequest();
r_msgreq.MaxNumberOfMessages = 1;
r_msgreq.QueueUrl = queue_url;
Decimal Vis_Timeout = System.Convert.ToDecimal(ConfigurationManager.AppSettings["SQS_Visibility"]);
r_msgreq.VisibilityTimeout = Vis_Timeout;
ReceiveMessageResponse r_msgres = sqs.ReceiveMessage(r_msgreq);
//ChangeMessageVisibilityRequest chg_message_vis = new ChangeMessageVisibilityRequest();
//chg_message_vis.QueueUrl = ConfigurationManager.AppSettings["SQSUrl"];
//chg_message_vis.ReceiptHandle = r_msgres.ResponseMetadata.RequestId
ReceiveMessageResult r_msgrst = r_msgres.ReceiveMessageResult;
Message msg = r_msgrst.Message.FirstOrDefault();
return(msg);
}
protected override void Execute()
{
string id = this.threemaId.Value;
string from = this.fromField.Value;
string secret = this.secretField.Value;
byte[] privateKey = this.privateKeyField.GetValue();
byte[] nonce = this.nonceField.GetValue();
string messageId = this.messageIdField.Value;
string outputFolder = this.outputFolderField.GetValue();
E2EHelper e2EHelper = new E2EHelper(this.CreateConnector(from, secret), privateKey);
byte[] box = DataUtils.HexStringToByteArray(System.Console.ReadLine().Trim());
ReceiveMessageResult res = e2EHelper.ReceiveMessage(id, messageId, box, nonce, outputFolder);
System.Console.WriteLine(res.Message.ToString());
res.Files.ForEach(f => { System.Console.WriteLine(f.FullName); });
}
private TaskQueueData GetTask(Priority oPriority)
{
string strUrlQueue = GetQueueUrl(oPriority);
TaskQueueData oData = null;
try
{
using (AmazonSQS oSQSClient = AWSClientFactory.CreateAmazonSQSClient())
{
ReceiveMessageRequest oReceiveMessageRequest = new ReceiveMessageRequest();
oReceiveMessageRequest.QueueUrl = strUrlQueue;
oReceiveMessageRequest.MaxNumberOfMessages = 1;
ReceiveMessageResponse oReceiveMessageResponse = oSQSClient.ReceiveMessage(oReceiveMessageRequest);
if (oReceiveMessageResponse.IsSetReceiveMessageResult())
{
ReceiveMessageResult oReceiveMessageResult = oReceiveMessageResponse.ReceiveMessageResult;
foreach (Message oMessage in oReceiveMessageResult.Message)
{
oData = TaskQueueData.DeserializeFromXml(oMessage.Body);
SQSDataKey oSQSDataKey = new SQSDataKey();
oSQSDataKey.m_oPriority = oPriority;
oSQSDataKey.m_strReceiptHandle = oMessage.ReceiptHandle;
oData.m_oDataKey = oSQSDataKey;
break;
}
}
}
}
catch (AmazonSQSException)
{
}
catch
{
}
return(oData);
}
public static void Main(string[] args)
{
const string QUEUENAME = "MyQueue";
AmazonSQS sqs = AWSClientFactory.CreateAmazonSQSClient();
try
{
Console.WriteLine("===========================================");
Console.WriteLine("Getting Started with Amazon SQS");
Console.WriteLine("===========================================\n");
//Creating a queue
Console.WriteLine("Create a queue called MyQueue.\n");
CreateQueueRequest sqsRequest = new CreateQueueRequest();
sqsRequest.QueueName = QUEUENAME;
CreateQueueResponse createQueueResponse = sqs.CreateQueue(sqsRequest);
String myQueueUrl;
myQueueUrl = createQueueResponse.CreateQueueResult.QueueUrl;
//Confirming the queue exists
ListQueuesRequest listQueuesRequest = new ListQueuesRequest();
ListQueuesResponse listQueuesResponse = sqs.ListQueues(listQueuesRequest);
var getQueueReq = new GetQueueUrlRequest();
getQueueReq.QueueName = "AppZwitschern";
var getQueueResp = sqs.GetQueueUrl(getQueueReq);
Console.WriteLine(":: Url={0}", getQueueResp.GetQueueUrlResult.QueueUrl);
Console.WriteLine("Printing list of Amazon SQS queues.\n");
if (listQueuesResponse.IsSetListQueuesResult())
{
ListQueuesResult listQueuesResult = listQueuesResponse.ListQueuesResult;
foreach (String queueUrl in listQueuesResult.QueueUrl)
{
Console.WriteLine(" QueueUrl: {0}", queueUrl);
}
}
Console.WriteLine();
//Sending a message
Console.WriteLine("Sending a message to MyQueue.\n");
SendMessageRequest sendMessageRequest = new SendMessageRequest();
sendMessageRequest.QueueUrl = myQueueUrl; //URL from initial queue creation
sendMessageRequest.MessageBody = "This is my message text.";
sqs.SendMessage(sendMessageRequest);
//Receiving a message
ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest();
receiveMessageRequest.QueueUrl = myQueueUrl;
ReceiveMessageResponse receiveMessageResponse = sqs.ReceiveMessage(receiveMessageRequest);
if (receiveMessageResponse.IsSetReceiveMessageResult())
{
Console.WriteLine("Printing received message.\n");
ReceiveMessageResult receiveMessageResult = receiveMessageResponse.ReceiveMessageResult;
foreach (Message message in receiveMessageResult.Message)
{
Console.WriteLine(" Message");
if (message.IsSetMessageId())
{
Console.WriteLine(" MessageId: {0}", message.MessageId);
}
if (message.IsSetReceiptHandle())
{
Console.WriteLine(" ReceiptHandle: {0}", message.ReceiptHandle);
}
if (message.IsSetMD5OfBody())
{
Console.WriteLine(" MD5OfBody: {0}", message.MD5OfBody);
}
if (message.IsSetBody())
{
Console.WriteLine(" Body: {0}", message.Body);
}
foreach (Amazon.SQS.Model.Attribute attribute in message.Attribute)
{
Console.WriteLine(" Attribute");
if (attribute.IsSetName())
{
Console.WriteLine(" Name: {0}", attribute.Name);
}
if (attribute.IsSetValue())
{
Console.WriteLine(" Value: {0}", attribute.Value);
}
}
}
}
String messageRecieptHandle = receiveMessageResponse.ReceiveMessageResult.Message[0].ReceiptHandle;
//Deleting a message
Console.WriteLine("Deleting the message.\n");
DeleteMessageRequest deleteRequest = new DeleteMessageRequest();
deleteRequest.QueueUrl = myQueueUrl;
deleteRequest.ReceiptHandle = messageRecieptHandle;
sqs.DeleteMessage(deleteRequest);
}
catch (AmazonSQSException ex)
{
Console.WriteLine("Caught Exception: " + ex.Message);
Console.WriteLine("Response Status Code: " + ex.StatusCode);
Console.WriteLine("Error Code: " + ex.ErrorCode);
Console.WriteLine("Error Type: " + ex.ErrorType);
Console.WriteLine("Request ID: " + ex.RequestId);
Console.WriteLine("XML: " + ex.XML);
}
Console.WriteLine("Press Enter to continue...");
Console.Read();
}
public AlertMessage GetNextMessage()
{
//Receiving a message
ReceiveMessageRequest receiveMessageRequest = new ReceiveMessageRequest();
receiveMessageRequest.QueueUrl = queueUrl;
ReceiveMessageResponse receiveMessageResponse = sqs.ReceiveMessage(receiveMessageRequest);
if (receiveMessageResponse.IsSetReceiveMessageResult())
{
Console.WriteLine("Printing received message.\n");
ReceiveMessageResult receiveMessageResult = receiveMessageResponse.ReceiveMessageResult;
foreach (Message message in receiveMessageResult.Message)
{
AlertMessage m = new AlertMessage();
Console.WriteLine(" Message");
if (message.IsSetMessageId())
{
Console.WriteLine(" MessageId: {0}", message.MessageId);
}
if (message.IsSetReceiptHandle())
{
Console.WriteLine(" ReceiptHandle: {0}", message.ReceiptHandle);
}
if (message.IsSetMD5OfBody())
{
Console.WriteLine(" MD5OfBody: {0}", message.MD5OfBody);
}
if (message.IsSetBody())
{
m.Body = message.Body;
Console.WriteLine(" Body: {0}", message.Body);
}
foreach (Amazon.SQS.Model.Attribute attribute in message.Attribute)
{
Console.WriteLine(" Attribute");
if (attribute.IsSetName() && attribute.Name == "Subject")
{
if (attribute.IsSetValue())
{
m.Subject = attribute.Value;
}
}
if (attribute.IsSetValue())
{
Console.WriteLine(" Value: {0}", attribute.Value);
}
}
// Deleting a message
Console.WriteLine("Deleting the message.\n");
DeleteMessageRequest deleteRequest = new DeleteMessageRequest();
deleteRequest.QueueUrl = queueUrl;
deleteRequest.ReceiptHandle = message.ReceiptHandle;
sqs.DeleteMessage(deleteRequest);
return(m);
}
}
return(null);
}
/// <summary>
/// Decrypt a Message and download the blobs of the Message (e.g. image or file)
/// </summary>
/// <param name="threemaId">Threema ID of the sender</param>
/// <param name="messageId">Message ID</param>
/// <param name="box">Encrypted box data of the file/image message</param>
/// <param name="nonce">Nonce that was used for message encryption</param>
/// <param name="outputFolder">Output folder for storing decrypted images/files</param>
/// <returns>Result of message reception</returns>
public ReceiveMessageResult ReceiveMessage(string threemaId, string messageId, byte[] box, byte[] nonce, string outputFolder)
{
//fetch public key
byte[] publicKey = this.apiConnector.LookupKey(threemaId);
if (publicKey == null)
{
throw new InvalidKeyException("invalid threema id");
}
ThreemaMessage message = CryptTool.DecryptMessage(box, this.privateKey, publicKey, nonce);
if (message == null)
{
return(null);
}
ReceiveMessageResult result = new ReceiveMessageResult(messageId, message);
if (message.GetType() == typeof(ImageMessage))
{
//download image
ImageMessage imageMessage = (ImageMessage)message;
byte[] fileData = this.apiConnector.DownloadFile(imageMessage.BlobId);
if (fileData == null)
{
throw new MessageParseException();
}
byte[] decryptedFileContent = CryptTool.Decrypt(fileData, privateKey, publicKey, imageMessage.Nonce);
FileInfo imageFile = new FileInfo(outputFolder + "/" + messageId + ".jpg");
using (FileStream stream = File.OpenWrite(imageFile.FullName))
{
stream.Write(decryptedFileContent, 0, decryptedFileContent.Length);
stream.Close();
}
result.Files.Add(imageFile);
}
else if (message.GetType() == typeof(FileMessage))
{
//download file
FileMessage fileMessage = (FileMessage)message;
byte[] fileData = this.apiConnector.DownloadFile(fileMessage.BlobId);
byte[] decryptedFileData = CryptTool.DecryptFileData(fileData, fileMessage.EncryptionKey);
FileInfo file = new FileInfo(outputFolder + "/" + messageId + "-" + fileMessage.FileName);
using (FileStream stream = File.OpenWrite(file.FullName))
{
stream.Write(decryptedFileData, 0, decryptedFileData.Length);
stream.Close();
}
result.Files.Add(file);
if (fileMessage.ThumbnailBlobId != null)
{
byte[] thumbnailData = this.apiConnector.DownloadFile(fileMessage.ThumbnailBlobId);
byte[] decryptedThumbnailData = CryptTool.DecryptFileThumbnailData(thumbnailData, fileMessage.EncryptionKey);
FileInfo thumbnailFile = new FileInfo(outputFolder + "/" + messageId + "-thumbnail.jpg");
using (FileStream stream = File.OpenWrite(thumbnailFile.FullName))
{
stream.Write(decryptedThumbnailData, 0, decryptedThumbnailData.Length);
stream.Close();
}
result.Files.Add(thumbnailFile);
}
}
return(result);
}
