public async Task ShouldUseMicrosoftTranslatorApi()
{
const string SubscriptionKey = "12345";
const string TargetLocale = "mud and rock language";
HttpRequestMessage message = null;
var card = new AdaptiveCard("1.0")
{
FallbackText = Untranslated,
};
var handler = new TestHandler(request =>
{
message = request;
Assert.AreEqual(JsonConvert.SerializeObject(new[]
{
new
{
Text = Untranslated
}
}), message.Content.ReadAsStringAsync().Result);
return(new HttpResponseMessage
{
Content = new StringContent(JsonConvert.SerializeObject(new[]
{
new TranslatorResponse
{
Translations = new[]
{
new TranslatorResult
{
Text = Translated,
},
},
},
})),
});
});
var client = new HttpClient(handler);
var config = new MicrosoftTranslatorConfig(SubscriptionKey, TargetLocale, client);
var result = await AdaptiveCardTranslator.TranslateAsync(card, config);
var expectedUri = new Uri(new Uri("https://api.cognitive.microsofttranslator.com"),
$"translate?api-version=3.0&to={TargetLocale}");
Assert.AreEqual(HttpMethod.Post, message.Method);
Assert.AreEqual(expectedUri, message.RequestUri);
Assert.AreEqual(SubscriptionKey, message.Headers.GetValues("Ocp-Apim-Subscription-Key").Single());
Assert.AreEqual(Untranslated, card.FallbackText);
Assert.AreEqual(Translated, result.FallbackText);
}
public async Task ArrayElementsShouldOnlyBeTranslatedInInlines()
{
var jObject = new JObject
{
{ "inlines", new JArray {
Untranslated
} },
{ "notInlines", new JArray {
Untranslated
} },
};
var result = await AdaptiveCardTranslator.TranslateAsync(jObject, TranslateOneAsync);
Assert.AreEqual(Translated, result["inlines"].Single().ToString(), "Inlines weren't translated");
Assert.AreEqual(Untranslated, result["notInlines"].Single().ToString(), "A non-inline array element was translated");
}
private async Task TestPropertiesToTranslate(AdaptiveCardTranslatorSettings settings = null)
{
settings ??= AdaptiveCardTranslator.DefaultSettings;
var card = new AdaptiveCard("1.0")
{
Lang = Untranslated,
Speak = Untranslated,
FallbackText = Untranslated,
Body = new List <AdaptiveElement>
{
new AdaptiveTextBlock
{
Text = Untranslated,
},
new AdaptiveImage
{
AltText = Untranslated,
Url = new Uri("url", UriKind.Relative),
},
new AdaptiveTextInput
{
Id = Untranslated,
Placeholder = Untranslated,
Value = Untranslated,
}
},
Actions = new List <AdaptiveAction>
{
new AdaptiveSubmitAction
{
Title = Untranslated,
IconUrl = Untranslated,
Style = Untranslated,
Data = Untranslated,
},
new AdaptiveSubmitAction
{
Data = new Dictionary <string, object>
{
{
"msteams", new Dictionary <string, object>
{
{ "type", "messageBack" },
{ "displayText", Untranslated },
}
},
},
},
},
};
var result = await AdaptiveCardTranslator.TranslateAsync(card, TranslateOneAsync, settings);
var body = result.Body;
var actions = result.Actions;
void AssertTranslation(object propertyContainer, string propertyName)
{
var shouldBeTranslated = settings.PropertiesToTranslate.Contains(propertyName);
var expected = shouldBeTranslated ? Translated : Untranslated;
var actual = propertyContainer.ToJObject()[propertyName].ToString();
var message = $"{propertyName} was{(shouldBeTranslated ? " not" : string.Empty)} translated";
Assert.AreEqual(expected, actual, message);
}
AssertTranslation(result, "lang");
AssertTranslation(result, "speak");
AssertTranslation(result, "fallbackText");
AssertTranslation(body[0], "text");
AssertTranslation(body[1], "altText");
AssertTranslation(body[2], "id");
AssertTranslation(body[2], "placeholder");
AssertTranslation(body[2], "value");
AssertTranslation(actions[0], "title");
AssertTranslation(actions[0], "iconUrl");
AssertTranslation(actions[0], "style");
AssertTranslation(actions[0], "data");
AssertTranslation(((JToken)((AdaptiveSubmitAction)actions[1]).Data)["msteams"], "displayText");
}
public async Task ValuePropertyShouldOnlyBeTranslatedInSpecificCases()
{
var card = new AdaptiveCard("1.0")
{
Body = new List <AdaptiveElement>
{
new AdaptiveFactSet
{
Facts = new List <AdaptiveFact>
{
new AdaptiveFact(string.Empty, Untranslated),
}
},
new AdaptiveChoiceSetInput
{
Id = string.Empty,
Choices = new List <AdaptiveChoice>
{
new AdaptiveChoice
{
Title = string.Empty,
Value = Untranslated,
}
},
Value = Untranslated,
},
new AdaptiveDateInput
{
Id = string.Empty,
Value = Untranslated,
},
new AdaptiveTextInput
{
Id = string.Empty,
Value = Untranslated,
},
new AdaptiveTimeInput
{
Id = string.Empty,
Value = Untranslated,
},
new AdaptiveToggleInput
{
Id = string.Empty,
Title = string.Empty,
Value = Untranslated,
},
},
Actions = new List <AdaptiveAction>
{
new AdaptiveSubmitAction
{
Data = new Dictionary <string, object>
{
{
"msteams", new Dictionary <string, object>
{
{ "type", "imBack" },
{ "value", Untranslated },
}
},
},
},
new AdaptiveSubmitAction
{
Data = new Dictionary <string, object>
{
{
"msteams", new Dictionary <string, object>
{
{ "type", "messageBack" },
{ "value", Untranslated },
}
},
},
},
},
};
var result = await AdaptiveCardTranslator.TranslateAsync(card, TranslateOneAsync);
var body = result.Body;
var actions = result.Actions;
Assert.AreEqual(Translated, ((AdaptiveFactSet)body[0]).Facts.Single().Value, "Fact was not translated");
Assert.AreEqual(Untranslated, ((AdaptiveChoiceSetInput)body[1]).Choices.Single().Value, "Choice was translated");
Assert.AreEqual(Untranslated, ((AdaptiveChoiceSetInput)body[1]).Value, "Choice set input was translated");
Assert.AreEqual(Untranslated, ((AdaptiveDateInput)body[2]).Value, "Date input was translated");
Assert.AreEqual(Translated, ((AdaptiveTextInput)body[3]).Value, "Text input was not translated");
Assert.AreEqual(Untranslated, ((AdaptiveTimeInput)body[4]).Value, "Time input was translated");
Assert.AreEqual(Untranslated, ((AdaptiveToggleInput)body[5]).Value, "Toggle input was translated");
Assert.AreEqual(Translated, ((JToken)((AdaptiveSubmitAction)actions[0]).Data)["msteams"]["value"].ToString(), "ImBack was not translated");
Assert.AreEqual(Untranslated, ((JToken)((AdaptiveSubmitAction)actions[1]).Data)["msteams"]["value"].ToString(), "MessageBack was translated");
}
protected override async Task OnMessageActivityAsync(
ITurnContext <IMessageActivity> turnContext,
CancellationToken cancellationToken)
{
if (turnContext.GetIncomingActionData() is object incomingData)
{
var jObject = JObject.FromObject(incomingData);
async Task SendPreservationFeedback()
{
await turnContext.SendActivityAsync(
$"You sent the following data: {jObject[IdText]}, {jObject[IdNumber]}, {jObject[IdDate]}",
cancellationToken : cancellationToken);
}
switch (jObject["behavior"]?.ToString())
{
case BehaviorSubmit:
await SendPreservationFeedback();
break;
case BehaviorPreserve:
await CardManager.PreserveValuesAsync(turnContext, cancellationToken);
await SendPreservationFeedback();
break;
case BehaviorTranslate:
var language = jObject["language"]?.ToString();
var card = CreateTranslationCard();
if (string.IsNullOrWhiteSpace(Translator.MicrosoftTranslatorConfig.SubscriptionKey))
{
if (string.IsNullOrWhiteSpace(language))
{
language = "Undefined";
}
Task <string> translateOne(string text, CancellationToken ct)
{
return(Task.FromResult($"{language}: {text}"));
}
card = await AdaptiveCardTranslator.TranslateAsync(card, translateOne, cancellationToken : cancellationToken);
await turnContext.SendActivityAsync("No subscription key was configured, so the card has been modified without a translation.");
}
else
{
if (string.IsNullOrWhiteSpace(language))
{
card = await Translator.TranslateAsync(card, cancellationToken);
}
else
{
card = await Translator.TranslateAsync(card, language, cancellationToken);
}
}
// There's no need to convert the card to a JObject
// since the library will do that for us
await turnContext.SendActivityAsync(MessageFactory.Attachment(new Attachment
{
ContentType = AdaptiveCard.ContentType,
Content = card,
}), cancellationToken);
break;
default:
if (jObject["label"] is JToken label)
{
await turnContext.SendActivityAsync(
$"Thank you for choosing {label}!",
cancellationToken : cancellationToken);
}
break;
}
}
else
{
switch (turnContext.Activity.Text)
{
case DemoDeactivateActions:
await ShowDeactivationSample(turnContext, DataIdScopes.Action, cancellationToken);
break;
case DemoDeactivateCards:
await ShowDeactivationSample(turnContext, DataIdScopes.Card, cancellationToken);
break;
case DemoDeactivateCarousels:
await ShowDeactivationSample(turnContext, DataIdScopes.Carousel, cancellationToken);
break;
case DemoDeactivateBatch:
await ShowDeactivationSample(turnContext, DataIdScopes.Batch, cancellationToken);
break;
case DemoPreserveValues:
await ShowPreservationSample(turnContext, cancellationToken);
break;
case DemoTranslateCards:
await ShowTranslationSample(turnContext, cancellationToken);
break;
default:
await ShowMenu(turnContext, cancellationToken);
break;
}
}
// The card manager will not work if its state is not saved
await ConversationState.SaveChangesAsync(turnContext, cancellationToken : cancellationToken);
}
public CardsLibraryBot(ConversationState conversationState, CardManager cardManager, AdaptiveCardTranslator adaptiveCardTranslator)
{
ConversationState = conversationState;
CardManager = cardManager;
Translator = adaptiveCardTranslator;
}
