public async override Task <bool> Process(AwsSnsMessage awsSnsMessage)
{
switch (awsSnsMessage.MessageAttributes.EventType.Value)
{
case "published":
var definition = new {
brief = new {
title = "",
organisation = "",
lotName = ""
},
name = "",
email_address = "",
url = ""
};
var message = JsonConvert.DeserializeAnonymousType(awsSnsMessage.Message, definition);
var slackMessage =
$@"*A buyer has published a new opportunity*
{message.brief.title} ({message.brief.lotName})
{message.brief.organisation}
By: {message.name} ({message.email_address})
{message.url}";
return(await _slackService.SendSlackMessage(_config.Value.BuyerSlackUrl, slackMessage));
default:
_logger.LogDebug("Unknown processor for {@AwsSnsMessage}.", awsSnsMessage);
break;
}
return(true);
}
public async override Task <bool> Process(AwsSnsMessage awsSnsMessage)
{
switch (awsSnsMessage.MessageAttributes.EventType.Value)
{
case "created":
var definition = new {
agency = new {
id = default(int),
name = "",
domains = ""
}
};
var message = JsonConvert.DeserializeAnonymousType(awsSnsMessage.Message, definition);
var slackMessage =
$@":rotating_light:*A new agency was created*:rotating_light:
id: {message.agency.id}
name: {message.agency.name}
domains: {message.agency.domains}
Please update this record accordingly";
return(await _slackService.SendSlackMessage(_config.Value.AgencySlackUrl, slackMessage));
default:
_logger.LogDebug("Unknown processor for {@AwsSnsMessage}.", awsSnsMessage);
break;
}
return(true);
}
public async override Task <bool> Process(AwsSnsMessage awsSnsMessage)
{
switch (awsSnsMessage.MessageAttributes.EventType.Value)
{
case "created":
var definition = new {
user = new {
email_address = "",
role = "",
name = ""
}
};
var message = JsonConvert.DeserializeAnonymousType(awsSnsMessage.Message, definition);
if (message.user.role == "buyer")
{
var slackMessage =
$@"*A new buyer has signed up*
Name: {message.user.name}
Email: {message.user.email_address}";
return(await _slackService.SendSlackMessage(_config.Value.UserSlackUrl, slackMessage));
}
else
{
_logger.LogDebug("Supplier not supported for {@AwsSnsMessage}.", awsSnsMessage);
}
break;
default:
_logger.LogDebug("Unknown processor for {@AwsSnsMessage}.", awsSnsMessage);
break;
}
return(true);
}
public async override Task <bool> Process(AwsSnsMessage awsSnsMessage)
{
switch (awsSnsMessage.MessageAttributes.EventType.Value)
{
case "mailchimp":
var definition = new {
mailchimp = new {
message = "",
error = ""
}
};
var message = JsonConvert.DeserializeAnonymousType(awsSnsMessage.Message, definition);
var slackMessage =
$@":email:*Mailchimp Error*:email:
Message: {message.mailchimp.message}
Error: {message.mailchimp.error}";
return(await _slackService.SendSlackMessage(_config.Value.MailchimpSlackUrl, slackMessage));
default:
_logger.LogDebug("Unknown processor for {@AwsSnsMessage}.", awsSnsMessage);
break;
}
return(true);
}
private async void DoWork(object state)
{
var receiveMessageRequest = new ReceiveMessageRequest()
{
QueueUrl = _config.Value.AwsSqsQueueUrl,
WaitTimeSeconds = _config.Value.AwsSqsLongPollTimeInSeconds
};
_logger.LogDebug("Heartbeat: {Now}", DateTime.Now);
var receiveMessageResponse = await _sqsClient.ReceiveMessageAsync(receiveMessageRequest);
foreach (var message in receiveMessageResponse.Messages)
{
_logger.LogDebug("Message Id: {MessageId}", message.MessageId);
var awsSnsMessage = AwsSnsMessage.FromJson(message.Body);
var messageProcessor = _messageProcessor(awsSnsMessage.MessageAttributes.ObjectType.Value);
if (messageProcessor == null)
{
_logger.LogDebug("Message processor not found for {@AwsSnsMessage}. Deleting message", awsSnsMessage);
await DeleteMessage(message);
continue;
}
var result = await messageProcessor.ProcessMessage(awsSnsMessage);
if (result == true)
{
await DeleteMessage(message);
}
}
}
public async override Task <bool> Process(AwsSnsMessage awsSnsMessage)
{
switch (awsSnsMessage.MessageAttributes.EventType.Value)
{
case "created":
var definition = new {
name = "",
email_address = "",
from_expired = default(bool?),
application = new {
id = -1,
name = "",
status = "",
type = "",
supplier_code = default(int?)
}
};
var message = JsonConvert.DeserializeAnonymousType(awsSnsMessage.Message, definition);
string subject = null;
if (message.application.type == "edit")
{
subject = "An existing seller has started a new application";
}
else if (message.application.type == "new")
{
subject = "A new seller has started an application";
if (message.from_expired.GetValueOrDefault(false))
{
subject += " (from expired)";
}
}
if (string.IsNullOrEmpty(subject) == false)
{
var slackMessage =
$@"*{subject}*
Application Id: {message.application.id}
{message.name} ({message.email_address})";
return(await _slackService.SendSlackMessage(_config.Value.SupplierSlackUrl, slackMessage));
}
else
{
_logger.LogError("Unknown application type for {@AwsSnsMessage}.", awsSnsMessage);
}
break;
default:
_logger.LogDebug("Unknown processor for {@AwsSnsMessage}.", awsSnsMessage);
break;
}
return(true);
}
public async void CanProcessBriefMessage()
{
//Given
var buyer_slack_url = "http://brief.slack.url";
var message =
$@"*A buyer has published a new opportunity*
test brief (atm)
dta
By: me (me@dta)
http://brief.url";
var logger = new Mock <ILogger <AppService> >();
var config = new Mock <IOptions <AppConfig> >();
config.Setup(ac => ac.Value).Returns(new AppConfig {
BuyerSlackUrl = buyer_slack_url
});
var slackService = new Mock <ISlackService>();
slackService.Setup(ss => ss.SendSlackMessage(buyer_slack_url, message)).ReturnsAsync(true);
var briefMessageProcessor = new BriefMessageProcessor(logger.Object, config.Object, slackService.Object);
//When
var awsSnsMessage = new AwsSnsMessage {
Message = JsonConvert.SerializeObject(new {
brief = new {
title = "test brief",
organisation = "dta",
lotName = "atm"
},
name = "me",
email_address = "me@dta",
url = "http://brief.url"
}),
MessageAttributes = new MessageAttributes {
EventType = new TType {
Value = "published"
}
}
};
var result = await briefMessageProcessor.Process(awsSnsMessage);
//Then
slackService.Verify((ss) => ss.SendSlackMessage(buyer_slack_url, message), Times.Exactly(1));
Assert.True(result);
}
public async void CanProcessApplicationMessageWithNullSupplierCode()
{
//Given
var supplier_slack_url = "http://application.slack.url";
var message =
$@"*A new seller has started an application*
Application Id: 321
test supplier ([email protected])";
var logger = new Mock <ILogger <AppService> >();
var config = new Mock <IOptions <AppConfig> >();
config.Setup(ac => ac.Value).Returns(new AppConfig {
SupplierSlackUrl = supplier_slack_url
});
var slackService = new Mock <ISlackService>();
slackService.Setup(ss => ss.SendSlackMessage(supplier_slack_url, message)).ReturnsAsync(true);
var applicationMessageProcessor = new ApplicationMessageProcessor(logger.Object, config.Object, slackService.Object);
//When
var awsSnsMessage = new AwsSnsMessage {
Message = JsonConvert.SerializeObject(new {
name = "test supplier",
email_address = "*****@*****.**",
application = new {
id = 321,
type = "new",
supplier_code = (int?)null
}
}),
MessageAttributes = new MessageAttributes {
EventType = new TType {
Value = "created"
}
}
};
var result = await applicationMessageProcessor.Process(awsSnsMessage);
//Then
slackService.Verify((ss) => ss.SendSlackMessage(supplier_slack_url, message), Times.Exactly(1));
Assert.True(result, "created should return true");
}
public async void CanProcessUserMessage()
{
//Given
var user_slack_url = "http://user.slack.url";
var message =
$@"*A new buyer has signed up*
Name: Foo bar
Email: [email protected]";
var logger = new Mock <ILogger <AppService> >();
var config = new Mock <IOptions <AppConfig> >();
config.Setup(ac => ac.Value).Returns(new AppConfig {
UserSlackUrl = user_slack_url
});
var slackService = new Mock <ISlackService>();
slackService.Setup(ss => ss.SendSlackMessage(user_slack_url, message)).ReturnsAsync(true);
var userMessageProcessor = new UserMessageProcessor(logger.Object, config.Object, slackService.Object);
//When
var awsSnsMessage = new AwsSnsMessage {
Message = JsonConvert.SerializeObject(new {
user = new {
email_address = "*****@*****.**",
role = "buyer",
name = "Foo bar"
}
}),
MessageAttributes = new MessageAttributes {
EventType = new TType {
Value = "created"
}
}
};
var result = await userMessageProcessor.Process(awsSnsMessage);
//Then
slackService.Verify((ss) => ss.SendSlackMessage(user_slack_url, message), Times.Exactly(1));
Assert.True(result, "created should return true");
}
public async override Task <bool> Process(AwsSnsMessage awsSnsMessage)
{
switch (awsSnsMessage.MessageAttributes.EventType.Value)
{
case "abr_failed":
var definition = new {
error = ""
};
var message = JsonConvert.DeserializeAnonymousType(awsSnsMessage.Message, definition);
var slackMessage =
$@":imp:*ABR API failed*:imp:
Error: {message.error}";
return(await _slackService.SendSlackMessage(_config.Value.AbrSlackUrl, slackMessage));
default:
_logger.LogDebug("Unknown processor for {@AwsSnsMessage}.", awsSnsMessage);
break;
}
return(true);
}
public abstract Task <bool> Process(AwsSnsMessage awsSnsMessage);
public async Task <bool> ProcessMessage(AwsSnsMessage awsSnsMessage)
{
return(await Process(awsSnsMessage));
}
