public async Task <NavigationResult> SendToMPA(Message message, CancellationToken cancellationToken, Dictionary <string, string> navigationParameters = null)
{
message.Content = PlainText.Parse(Regex.Replace(message.Content.ToString(), @"\r\n?|\n", " "));
return(await SendToMPA(new List <Message> {
message
}, cancellationToken, navigationParameters));
}
public async Task ReceiveAsync(Message message, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var userContext = await _contextManager.GetUserContextAsync(message.From, cancellationToken);
var contact = await GetContact(message, cancellationToken);
if (message.Content.ToString().Trim().Contains("#DEVACTION#"))
{
await _devActionHandler.HandleAsync(message, cancellationToken);
}
else
{
if (message.Content.ToString().Trim().Contains("Main Menu"))
{
message.Content = PlainText.Parse("#MainMenu_");
}
await _sender.SendDelayedComposingAsync(message.From, 2000, cancellationToken);
await ReceiveMessageAsync(message, contact, userContext, cancellationToken);
}
}
catch (Exception ex)
{
await _sender.SendMessageAsync("Oops, something went wrong...", message.From, cancellationToken);
}
}
public async Task OnboardingReceiverUnitTest(bool isFirst, string teamDivision)
{
var message = new Message
{
From = UnitTestBuilder.GetUserNode(),
To = UnitTestBuilder.GetBotNode(),
Content = PlainText.Parse("UnitTest_" + teamDivision)
};
var userContext = new UserContext
{
FirstInteraction = isFirst
};
bool success = false;
try
{
success = await flowService.SendOnboardingFlowAsync(userContext, message, CancellationToken.None);
userContext = await contextManager.GetUserContextAsync(message.From, CancellationToken.None);
}
catch (Exception ex)
{
ex.ShouldBeNull();
}
finally
{
success.ShouldBeTrue();
if (!isFirst)
{
userContext.TeamDivision.ShouldBe(teamDivision);
}
}
}
public Message GetYesNoQuickReply()
{
var YesNo = new Message()
{
Content = new Select()
{
Scope = SelectScope.Immediate,
Options = new SelectOption[]
{
new SelectOption
{
Text = PlainText.Parse("Yes"),
Value = PlainText.Parse("")
},
new SelectOption
{
Text = PlainText.Parse("No"),
Value = PlainText.Parse("")
}
}
}
};
return(YesNo);
}
public async Task SelectMainTeamReceiverUnitTest(string text, string teamTag)
{
var message = new Message
{
From = UnitTestBuilder.GetUserNode(),
To = UnitTestBuilder.GetBotNode(),
Content = PlainText.Parse(text + teamTag)
};
var context = new UserContext
{
MainTeam = ""
};
bool success = false;
try
{
success = await flowService.SendSelectMainTeamFlowAsync(message, context, CancellationToken.None);
context = await contextManager.GetUserContextAsync(message.From, CancellationToken.None);
}
catch (Exception ex)
{
ex.ShouldBeNull();
}
finally
{
success.ShouldBeTrue();
context.MainTeam.ShouldBe(teamTag);
}
}
public async Task SetAndGetResourceUnitTest(string authKey)
{
Command setResponse;
PlainText getResponse;
using (var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10)))
{
if (authKey.Equals(""))
{
setResponse = await _resourceService.SetAsync("UnitTest", PlainText.Parse("ResourceUnitTest"), _logger, cancellationToken : cts.Token);
getResponse = await _resourceService.GetAsync <PlainText>("UnitTest", _logger, cancellationToken : cts.Token);
}
else
{
var resourceService = new ResourceService(authKey, Models.BlipProtocol.Tcp);
setResponse = await resourceService.SetAsync("UnitTest", PlainText.Parse("ResourceUnitTest"), _logger, cancellationToken : cts.Token);
getResponse = await resourceService.GetAsync <PlainText>("UnitTest", _logger, cancellationToken : cts.Token);
}
}
setResponse.Status.ShouldBe(CommandStatus.Success);
getResponse.ShouldNotBeNull();
getResponse.Text.ShouldBe("ResourceUnitTest");
getResponse.GetMediaType().ToString().ShouldBe("text/plain");
}
public async Task DeleteResourceUnitTest()
{
bool exceptionThrown = false;
using (var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10)))
{
await _resourceService.SetAsync("DeleteUnitTest", PlainText.Parse("Delete"), _logger, cancellationToken : cts.Token);
var getResource = await _resourceService.GetAsync <PlainText>("DeleteUnitTest", _logger, cancellationToken : cts.Token);
getResource.ShouldNotBeNull();
var deleteResponse = await _resourceService.DeleteAsync("DeleteUnitTest", _logger, cts.Token);
deleteResponse.ShouldNotBeNull();
deleteResponse.Status.ShouldBe(CommandStatus.Success);
try
{
getResource = await _resourceService.GetAsync <PlainText>("DeleteUnitTest", _logger, cancellationToken : cts.Token);
}
catch (BlipHttpClientException bex)
{
bex.Reason.Code.ShouldBe(67);
bex.Reason.Description.ShouldBe("The requested resource was not found");
exceptionThrown = true;
}
}
exceptionThrown.ShouldBeTrue();
}
public async Task <bool> SendAgendaFlowAsync(UserContext context, Message message, CancellationToken cancellationToken)
{
try
{
var carousel = await _carouselBuilder.GetCarousel(context.AlertTeams, cancellationToken);
carousel.To = message.From;
var textMessage = new Message()
{
Content = PlainText.Parse("Here's your overview for this week:"),
To = message.From
};
await _sender.SendMessageAsync(textMessage, cancellationToken);
await _sender.SendMessageAsync(carousel, cancellationToken);
await _sender.SendDelayedComposingAsync(message.From, 2000, cancellationToken);
await _sender.SendBackQuickReplyAsync(message.From, _quickReplyBuilder, cancellationToken);
return(true);
}
catch (Exception ex)
{
return(false);
}
}
private List <DocumentSelect> GetItemList(CompetitorElement[] divisionTeams, Flow flowIdentity)
{
var tag = GetTagFromFlow(flowIdentity);
var buttonsTexts = GetButtonTextFromFlow(flowIdentity).Split('|');
var buttonText = buttonsTexts[0];
var secondButtonText = "";
if (buttonsTexts.Length == 2)
{
secondButtonText = buttonsTexts[1];
}
var itemList = new List <DocumentSelect>();
foreach (CompetitorElement c in divisionTeams)
{
var item = new DocumentSelect
{
Header = new DocumentContainer
{
Value = new MediaLink
{
Title = c.Competitor.Name,
Text = c.Competitor.HomeLocation,
Uri = new Uri(c.Competitor.Logo),
AspectRatio = MyConstants.FacebookCarouselAspectRatio
}
}
};
var options = new List <DocumentSelectOption>();
var firstOption = new DocumentSelectOption
{
Label = new DocumentContainer {
Value = PlainText.Parse(buttonText)
},
Value = new DocumentContainer {
Value = "Add" + tag + c.Competitor.AbbreviatedName
}
};
options.Add(firstOption);
if (!secondButtonText.IsNullOrWhiteSpace())
{
var secondOption = new DocumentSelectOption
{
Label = new DocumentContainer {
Value = PlainText.Parse(secondButtonText)
},
Value = new DocumentContainer {
Value = "Remove" + tag + c.Competitor.AbbreviatedName
}
};
options.Add(secondOption);
}
item.Options = options.ToArray();
itemList.Add(item);
}
return(itemList);
}
public async Task SendTextAsync(string text, CancellationToken cancellationToken)
{
var message = new Message(EnvelopeId.NewId())
{
Content = PlainText.Parse(text),
From = GetUserNode(),
};
await _testHost.DeliverIncomingMessageAsync(message);
}
public async Task SendBroadcastLogUnitTest_ShouldSucceed()
{
var client = BuildSenderSubstitute_ReturnsSuccessStatus();
var broadcastService = new BroadcastService(client);
var logger = Substitute.For <ILogger>();
var task = broadcastService.SendMessageAsync(FirstListName, PlainText.Parse("UnitTests"), logger);
await TestInfoLogsWithTwoArgs <string, Document>(task, 2, logger);
}
public async Task SetResourceLogUnitTest_ShouldSucceed()
{
var document = PlainText.Parse("LogUnitTest");
var client = BuildSenderSubstitute_ReturnsSuccessStatus();
var resourceService = new ResourceService(client);
var logger = Substitute.For <ILogger>();
await resourceService.SetAsync("LogUnitTest", document, logger : logger, cancellationToken : CancellationToken.None);
logger.Received(1).Information(Arg.Any <string>(), Arg.Any <string>());
logger.Received(1).Information(Arg.Any <string>(), Arg.Any <PlainText>(), Arg.Any <string>());
}
public async Task <NavigationResult> SendToMPA(string message, Node from, CancellationToken cancellationToken, Dictionary <string, string> navigationParameters = null)
{
var plainContent = PlainText.Parse(Regex.Replace(message, @"\r\n?|\n", " "));
return(await SendToMPA(new List <Message> {
new Message(EnvelopeId.NewId())
{
Content = plainContent, From = from, To = from, Metadata = new Dictionary <string, string>()
}
}, cancellationToken, navigationParameters));
}
private async Task Send_Broadcast_UnitTest(string listName)
{
var sender = Substitute.For <ISender>();
var calls = 0;
sender.When(x => x.SendMessageAsync(Arg.Any <Message>(), Arg.Any <CancellationToken>())).Do(x => calls++);
var broadcastService = new BroadcastService(sender);
await broadcastService.SendMessageAsync(listName, PlainText.Parse("UnitTests"), _logger);
calls.ShouldBeGreaterThan(0);
}
public void PlainText_ToContainer()
{
// Arrange
var plainText = PlainText.Parse("Unit tests");
// Act
var container = plainText.ToDocumentContainer();
// Assert
container.Value.ShouldBe(plainText);
container.Type.ShouldBe(PlainText.MediaType);
}
public void MessagesUnitTest(string messageText)
{
var message = new Message
{
Content = PlainText.Parse(messageText)
};
var task = _client.SendMessageAsync(message, CancellationToken.None);
task.Wait();
task.IsCompleted.ShouldBeTrue();
}
private async Task ImportAnswers(List <Intention> intentions)
{
var answersMap = new Dictionary <string, List <string> >();
//Get intentions on file
var csv = new Chilkat.Csv
{
// Prior to loading the CSV file, indicate that the 1st row
// should be treated as column names:
HasColumnNames = true
};
// Load the CSV records from intentions the file:
bool success = csv.LoadFile(AnswersFilePath.Value);
if (!success)
{
Console.WriteLine(csv.LastErrorText);
return;
}
// Display the contents of the 3rd column (i.e. the country names)
for (int row = 0; row <= csv.NumRows - 1; row++)
{
var intentionName = csv.GetCell(row, 0);
var answer = csv.GetCell(row, 1);
var answersList = answersMap.ContainsKey(intentionName) ? answersMap[intentionName] : new List <string>();
answersList.Add(answer);
answersMap[intentionName] = answersList;
}
var intents = new List <Intention>();
//Add each intention on BLiP IA model
foreach (var intentionKey in answersMap.Keys)
{
var intention = intentions.FirstOrDefault(i => i.Name == intentionKey);
if (intention == null)
{
Console.WriteLine($"{intentionKey} not present in intentions list.");
continue;
}
var answersList = answersMap[intentionKey];
var answersArray = answersList.Select(q => new Answer {
RawValue = q, Type = PlainText.MediaType, Value = PlainText.Parse(q)
}).ToArray();
await _blipAIClient.AddAnswers(intention.Id, answersArray);
}
}
public async Task AgendaReceiverUnitTest()
{
var message = new Message
{
From = UnitTestBuilder.GetUserNode(),
To = UnitTestBuilder.GetBotNode(),
Content = PlainText.Parse("UnitTests")
};
var context = new UserContext
{
AlertTeams = new List <string>()
{
{ "DAL" },
{ "BOS" },
{ "HOU" },
{ "NYE" },
{ "SHD" },
{ "VAL" },
{ "GLA" },
{ "LON" },
{ "FLA" },
{ "SEO" },
{ "PHI" },
{ "SFS" },
}
};
bool success = false;
try
{
success = await flowService.SendAgendaFlowAsync(context, message, CancellationToken.None);
}
catch (Exception ex)
{
ex.ShouldBeNull();
}
finally
{
success.ShouldBeTrue();
}
}
private static ISender BuildSenderSubstitute_ReturnsSuccessStatus()
{
var client = Substitute.For <ISender>();
var responseCommand = new Command()
{
Status = CommandStatus.Success,
Reason = new Reason()
{
Description = "Unit Tests",
Code = 42
},
Resource = PlainText.Parse("Unit tests")
};
client
.ProcessCommandAsync(Arg.Any <Command>(), Arg.Any <CancellationToken>())
.Returns(responseCommand);
return(client);
}
public async Task AlertReceiverUnitTest(string flow, string teamTag)
{
var message = new Message
{
From = UnitTestBuilder.GetUserNode(),
To = UnitTestBuilder.GetBotNode(),
Content = PlainText.Parse(flow + teamTag)
};
var team = flow.Contains("Remove") ? teamTag : string.Empty;
var userContext = new UserContext
{
AlertTeams = new List <string>
{
{ team }
}
};
bool success = false;
try
{
success = await flowService.SendAlertFlowAsync(userContext, message, CancellationToken.None);
userContext = await contextManager.GetUserContextAsync(message.From, CancellationToken.None);
}
catch (Exception ex)
{
ex.ShouldBeNull();
}
finally
{
success.ShouldBeTrue();
if (flow.Contains("Remove"))
{
userContext.AlertTeams.ShouldNotContain(teamTag);
}
else if (flow.Contains("Add"))
{
userContext.AlertTeams.ShouldContain(teamTag);
}
}
}
public Message GetBackQuickReply()
{
var back = new Message()
{
Content = new Select()
{
Text = "Go back:",
Scope = SelectScope.Immediate,
Options = new SelectOption[]
{
new SelectOption
{
Text = PlainText.Parse("🔙"),
Value = PlainText.Parse("#MainMenu_")
}
}
}
};
return(back);
}
public async Task SendBroadcastLogUnitTest_ShouldThrowEx()
{
var logger = Substitute.For <ILogger>();
var client = BuildSenderSubstitute_ThrowsException();
var broadcastService = new BroadcastService(client);
var exceptionThrown = false;
try
{
await broadcastService.SendMessageAsync(FirstListName, PlainText.Parse("UnitTests"), logger);
}
catch (Exception ex)
{
logger.Received(1).Error(ex, Arg.Any <string>(), Arg.Any <string>(), Arg.Any <Document>());
exceptionThrown = true;
}
finally
{
exceptionThrown.ShouldBe(true);
}
}
public MarkupRoot Parse(string plainText)
{
var parsedText = PlainText.Parse(plainText);
var tagStack = new Stack <Tag>();
tagStack.Push(new MarkupRoot());
foreach (var part in parsedText)
{
var currentTag = tagStack.Peek();
if (part.IsPlainText)
{
ParseContent(currentTag, part.ToString());
}
else
{
var openingTag = part as OpeningTag;
if (openingTag != null)
{
currentTag = ParseOpeningTag(openingTag, currentTag, tagStack);
}
else
{
var closingTag = part as ClosingTag;
currentTag = ParseClosingTag(closingTag, currentTag, tagStack);
}
}
}
// Auto-close unclosed tags.
while (tagStack.Count > 1)
{
tagStack.Pop();
}
return(tagStack.Pop() as MarkupRoot);
}
public async Task SetResourceLogUnitTest_ShouldThrowEx()
{
var document = PlainText.Parse("LogUnitTest");
var logger = Substitute.For <ILogger>();
var client = BuildSenderSubstitute_ThrowsException();
var resourceService = new ResourceService(client);
var exceptionThrown = false;
try
{
await resourceService.SetAsync("LogUnitTest", document, logger : logger, cancellationToken : CancellationToken.None);
}
catch (Exception ex)
{
logger.Received(1).Error(ex, Arg.Any <string>(), Arg.Any <PlainText>(), Arg.Any <string>());
exceptionThrown = true;
}
finally
{
exceptionThrown.ShouldBe(true);
}
}
public async Task NewsReceiverUnitTest()
{
var message = new Message
{
From = UnitTestBuilder.GetUserNode(),
To = UnitTestBuilder.GetBotNode(),
Content = PlainText.Parse("UnitTests")
};
bool success = false;
try
{
success = await flowService.SendNewsFlowAsync(message, CancellationToken.None);
}
catch (Exception ex)
{
ex.ShouldBeNull();
}
finally
{
success.ShouldBeTrue();
}
}
public async Task <Document> NoActionPayment(string input, Message messageOriginator, CancellationToken cancellationToken)
{
input = input.Replace("\n#noaction#pagamento#", "");
string[] tokens = input.Split('#');
int preco = 0, quantidade = Convert.ToInt32(tokens[2]);
string modelo, tipoCamisa = tokens[0], tamanho = tokens[1], estampa = tokens[3], cor = null;
if (tipoCamisa == "curso")
{
cor = tokens[4];
preco = 25;
modelo = estampa + " " + tamanho + " " + cor;
}
else
{
modelo = estampa + " " + tamanho;
if (quantidade == 1)
{
preco = 30;
}
else if (quantidade > 1)
{
preco = 25;
}
}
Invoice invoice = CreatePaymentMessage(preco, quantidade, modelo);
var to = Node.Parse($"{Uri.EscapeDataString(messageOriginator.From.ToIdentity().ToString())}@pagseguro.gw.msging.net");
ChatState chatState = new ChatState {
State = ChatStateEvent.Composing
};
await _sender.SendMessageAsync(chatState, messageOriginator.From);
await _sender.SendMessageAsync(invoice, to, cancellationToken);
return(PlainText.Parse("Sucess"));
}
public void DocumentSelect_ToContainer()
{
// Arrange
var documentSelect = new DocumentSelect
{
Header = PlainText.Parse("Unit tests").ToDocumentContainer(),
Options = new DocumentSelectOption[]
{
new DocumentSelectOption
{
Label = PlainText.Parse("Unit test").ToDocumentContainer(),
Value = PlainText.Parse("Unit test").ToDocumentContainer()
}
},
Scope = SelectScope.Immediate
};
// Act
var container = documentSelect.ToDocumentContainer();
// Assert
container.Value.ShouldBe(documentSelect);
container.Type.ShouldBe(DocumentSelect.MediaType);
}
private async Task SendCommandToMPAAsync(string commmand, Message messageOriginator, CancellationToken cancellationToken)
{
var MessageToMPA = new Message(messageOriginator.Id)
{
To = messageOriginator.From,
From = messageOriginator.From,
Content = PlainText.Parse(commmand),
Metadata = messageOriginator.Metadata
};
var firstNavResult = await _mpaService.SendToMPA(MessageToMPA, cancellationToken);
if (firstNavResult.NavigationState == NavigationState.Error)
{
_logger.Error($"Error on sending message to MPA. User from: {messageOriginator.From} message: {(MessageToMPA.Content as PlainText).Text}");
var result = await _mpaService.SendToMPA(GenericErrorCommand, messageOriginator.From, cancellationToken);
if (result.NavigationState == NavigationState.Error)
{
await _genericErrorService.SendGenericErrorAsync(messageOriginator.From, cancellationToken);
}
}
}
/// <summary>
/// Extension that wrappes a text string to DocumentContainer containing a PlainText document with the given text.
/// </summary>
/// <param name="text"></param>
/// <returns></returns>
public static DocumentContainer ToPlainTextDocumentContainer(this string text)
{
return(PlainText.Parse(text).ToDocumentContainer());
}
private Document GetDocument(string raw, string type)
{
if ("text" == type)
{
return(PlainText.Parse(raw));
}
if ("menu" == type || "quickreply" == type)
{
var parts = raw.Split('|');
var select = new Select
{
Text = parts[0],
Options = parts
.Where(p => p != parts[0])
.Select(o => new SelectOption {
Text = o, Value = PlainText.Parse(o)
})
.ToArray(),
Scope = ("quickreply" == type) ? SelectScope.Immediate : SelectScope.Transient
};
return(select);
}
if ("carousel_img" == type)
{
var docColl = new DocumentCollection
{
ItemType = DocumentSelect.MediaType
};
var items = new List <DocumentSelect>();
var cards = raw.Split('%');
foreach (var item in cards)
{
var parts = item.Split('|');
var header = new List <string>();
for (int i = 0; i < parts.Length - 1; i++)
{
header.Add(parts[i]);
}
var btns = parts[parts.Length - 1].Split('&');
var docSel = new DocumentSelect
{
Header = new DocumentContainer
{
Value = new MediaLink
{
Title = header[1],
Text = header[2],
Uri = new Uri("http://site.com/" + header[0] + ".jpg"),
Type = new MediaType(MediaType.DiscreteTypes.Image, MediaType.SubTypes.JPeg)
}
},
Options = btns.Select(b =>
new DocumentSelectOption
{
Label = new DocumentContainer
{
Value = new PlainText {
Text = b
}
}
}
).ToArray()
};
items.Add(docSel);
}
docColl.Items = items.ToArray();
docColl.Total = docColl.Items.Length;
return(docColl);
}
if ("carousel_txt" == type)
{
var docColl = new DocumentCollection
{
ItemType = DocumentSelect.MediaType,
};
var items = new List <DocumentSelect>();
var cards = raw.Split('%');
foreach (var item in cards)
{
var parts = item.Split('|');
var header = new List <string>();
for (int i = 0; i < parts.Length - 1; i++)
{
header.Add(parts[i]);
}
var btns = parts[parts.Length - 1].Split('&');
var docSel = new DocumentSelect
{
Header = new DocumentContainer
{
Value = new PlainText
{
Text = header[0],
}
},
Options = btns.Select(b =>
new DocumentSelectOption
{
Label = new DocumentContainer
{
Value = new PlainText {
Text = b
}
}
}
).ToArray()
};
items.Add(docSel);
}
docColl.Items = items.ToArray();
docColl.Total = docColl.Items.Length;
return(docColl);
}
return(PlainText.Parse(raw));
}
