public ReadingMessage ParseMessage(Message message)
{
var snsMessage = SnsMessage.ParseMessage(message.Body);
var reading = JsonConvert.DeserializeObject <Reading>(snsMessage.MessageText);
return(new ReadingMessage
{
ReceiptHandle = message.ReceiptHandle,
Reading = reading
});
}
/// <summary>
/// Confirms a subscription to a notification topic.
/// <param name="awsMsg">The AWS subscription type message.</param>
/// <returns>A confirmed result on success, or an error result.</returns>
/// </summary>
private async Task <IHandleResult> ConfirmSubscription(AWSMessage awsMsg)
{
try
{
await Utils.MakeGetRequest(awsMsg.SubscribeURL);
return(new ConfirmedSubscriptionResult(awsMsg.TopicArn));
}
catch (Exception ex)
{
return(new ErrorResult(ex));
}
}
/// <summary>
/// Handles a notification message.
/// <param name="awsMsg">The AWS notification message, which should contain a message from iVvy.</param>
/// <returns>A new message result, or an invalid signature result.</returns>
/// </summary>
private async Task <IHandleResult> HandleNotification(AWSMessage awsMsg)
{
// Validate the iVvy message data.
var ivMsg = Message.ParseMessage(awsMsg.MessageText);
if (ivMsg == null)
{
return(new InvalidSignatureResult());
}
var isSignatureValid = await ivMsg.IsSignatureValidAsync(
publicKeyCache, receivedPublicKey
);
if (!isSignatureValid)
{
return(new InvalidSignatureResult());
}
return(new NewMessageResult(ivMsg));
}
/// <summary>
/// Handle a notification message from iVvy.
/// <param name="messageStream">The stream that contains the message data.</param>
/// <returns>A specific result of handling the message.</returns>
/// </summary>
public async Task <IHandleResult> HandleMessageAsync(Stream messageStream)
{
// Validate the AWS message signature.
var body = "";
using (var reader = new StreamReader(messageStream))
{
body = await reader.ReadToEndAsync();
}
var awsMsg = AWSMessage.ParseMessage(body);
if (awsMsg == null || !awsMsg.IsMessageSignatureValid())
{
return(new InvalidSignatureResult());
}
// Validate the AWS topic.
var isValid = await isTopicValid(awsMsg.TopicArn);
if (!isValid)
{
return(new InvalidTopicResult());
}
// If the AWS message is to confirm a subscription, then let's confirm it.
if (awsMsg.IsSubscriptionType)
{
return(await ConfirmSubscription(awsMsg));
}
// If the AWS message is a notification, then extract the iVvy message.
if (awsMsg.IsNotificationType)
{
return(await HandleNotification(awsMsg));
}
return(new UnhandledMessageResult());
}
private bool IsSignatureValid(AWSMessage message)
{
return(isLocalMode || message.IsMessageSignatureValid());
}
public Reading ParseMessage(Message message)
{
var snsMessage = SnsMessage.ParseMessage(message.Body);
List <KeyValuePair <string, string> > readingsFromText = new List <KeyValuePair <string, string> >();
var messageText = JsonConvert.SerializeObject(snsMessage.MessageText);
var splitMessage = messageText.Split(",");
foreach (var pair in splitMessage)
{
var keyNum = 1;
var key = "";
var val = "";
var keyValuePairSplit = pair.Split(":");
foreach (var kv in keyValuePairSplit)
{
var count = 0;
foreach (var character in kv)
{
if (Char.IsLetterOrDigit(character))
{
break;
}
count++;
}
var substring = kv.Substring(count);
var countEnd = 0;
foreach (var characterEnd in substring)
{
if (!Char.IsLetterOrDigit(characterEnd))
{
break;
}
countEnd++;
}
var subSubstring = substring.Substring(0, countEnd);
if (keyNum % 2 == 0)
{
val = subSubstring;
keyNum++;
}
else
{
key = subSubstring;
keyNum++;
}
}
KeyValuePair <string, string> readingPair = new KeyValuePair <string, string>(key: key, value: val);
readingsFromText.Add(readingPair);
}
Reading reading = new Reading
{
};
foreach (var pair in readingsFromText)
{
if (pair.Key == "locationId")
{
reading.LocationId = pair.Value;
}
else if (pair.Key == "eventId")
{
reading.EventId = pair.Value;
}
else if (pair.Key == "value")
{
reading.Value = int.Parse(pair.Value);
}
else if (pair.Key == "timestamp")
{
reading.Timestamp = long.Parse(pair.Value);
}
}
return(reading);
}
