public void Should_Set_TranslationArgs()
{
var translations = new Dictionary <string, IReadOnlyDictionary <string, string> >
{
["translation1"] = new Dictionary <string, string>
{
["key11"] = "message11",
["key12"] = "message12"
},
["translation2"] = new Dictionary <string, string>
{
["key21"] = "message21"
},
};
var translator = new MessageTranslator(translations);
translator.TranslationArgs.Should().NotBeEmpty();
translator.TranslationArgs.Count.Should().Be(2);
translator.TranslationArgs.Keys.Should().Contain("translation1");
translator.TranslationArgs["translation1"].Length.Should().Be(1);
translator.TranslationArgs["translation1"][0].Should().BeAssignableTo <TranslationArg>();
translator.TranslationArgs["translation1"][0].Name.Should().Be("_translation");
translator.TranslationArgs["translation1"][0].ToString(new Dictionary <string, string>()
{
["key"] = "key11"
}).Should().Be("message11");
translator.TranslationArgs["translation1"][0].ToString(new Dictionary <string, string>()
{
["key"] = "key12"
}).Should().Be("message12");
translator.TranslationArgs["translation1"][0].ToString(new Dictionary <string, string>()
{
["key"] = "key21"
}).Should().Be("key21");
translator.TranslationArgs["translation2"].Length.Should().Be(1);
translator.TranslationArgs["translation2"][0].Should().BeAssignableTo <TranslationArg>();
translator.TranslationArgs["translation2"][0].Name.Should().Be("_translation");
translator.TranslationArgs["translation2"][0].ToString(new Dictionary <string, string>()
{
["key"] = "key11"
}).Should().Be("key11");
translator.TranslationArgs["translation2"][0].ToString(new Dictionary <string, string>()
{
["key"] = "key12"
}).Should().Be("key12");
translator.TranslationArgs["translation2"][0].ToString(new Dictionary <string, string>()
{
["key"] = "key21"
}).Should().Be("message21");
}
public static async Task PostTranslatedAsync(this IDialogContext context, string message, bool sendTyping = true, int delay = 0)
{
if (sendTyping)
{
if (delay == 0)
{
//generate random delay from 1 second to 4 seconds...
delay = rnd.Next(1, 4) * 1000;
}
await PostTypingAsync(context, delay);
}
string language;
if (context.UserData.TryGetValue(Constants.Shared.UserLanguageCodeKey, out language) && language != MessageTranslator.DEFAULT_LANGUAGE)
{
var translatedMessage = await MessageTranslator.TranslateTextAsync(message, language);
await context.PostAsync(translatedMessage);
return;
}
else
{
await context.PostAsync(message);
return;
}
}
public static void Interpret(IPEndPoint source, Message message, NetworkMessage network)
{
NetworkCommon networkCommon = GameObject.FindObjectOfType <Network> ().NetworkCommon;
switch (network.Message)
{
case NetworkMessage.MessageValue.CONNECT:
if (networkCommon is NetworkServer && networkCommon.ID == message.DestID)
{
(networkCommon as NetworkServer).Send(source, MessageTranslator.ToByteArray(
createMessage(networkCommon.ID,
message.SourceID,
NetworkMessage.MessageValue.CONNECTED)));
networkCommon.Connected = true;
Application.LoadLevel(1);
}
break;
case NetworkMessage.MessageValue.CONNECTED:
if (networkCommon is NetworkClient && networkCommon.ID == message.DestID)
{
networkCommon.Connected = true;
Application.LoadLevel(1);
}
break;
}
}
private async Task AfterLessonFinished(IDialogContext context, IAwaitable <string> result)
{
// TODO: inject dependency
var badgeRepository = new Gamification.BadgeRepository();
var updatedProfile = GetUserGamerProfile(context);
var user = context.GetUserData();
updatedProfile.Points += _pointsPerLesson;
var newBadges = badgeRepository.GetEligibleBadges(updatedProfile, _userPointsBeforeLessonPlan);
updatedProfile.Badges.AddRange(newBadges);
if (newBadges != null && newBadges.Any())
{
var tasks = newBadges.Select(async badge =>
{
AdaptiveCard adaptiveCard = new AdaptiveCard()
{
Body = new List <CardElement>()
{
new Image()
{
Size = ImageSize.Medium,
Url = "https://www.kastatic.org/images/badges/meteorite/thumbs-up-512x512.png"
},
new TextBlock()
{
Text = await MessageTranslator.TranslateTextAsync($"You unlocked {badge}", user?.NativeLanguageIsoCode),
Size = TextSize.Large,
Wrap = true
}
}
};
Attachment attachment = new Attachment()
{
ContentType = AdaptiveCard.ContentType,
Content = adaptiveCard
};
var reply = context.MakeMessage();
reply.Attachments.Add(attachment);
await context.PostAsync(reply, CancellationToken.None);
});
await Task.WhenAll(tasks);
}
// The current lesson finished. Plug in Analytics.
var finalMessage = await result;
await context.PostAsync(finalMessage);
// Refactor
var updatedUserData = context.GetUserData();
updatedUserData.GamerProfile = updatedProfile;
context.UpdateUserData(updatedUserData);
context.Done(string.Empty);
}
public static void Send(GameplayMessage.MessageValue messageValue, int id, Vector2 delta, Vector3 originalPosition)
{
Network network = GameObject.FindObjectOfType <Network>();
if (network == null)
{
return;
}
NetworkCommon networkCommon = network.NetworkCommon;
if (networkCommon == null)
{
return;
}
Message m = createMessage(networkCommon.ID,
1 - networkCommon.ID,
messageValue,
id,
delta,
originalPosition);
if (networkCommon is NetworkClient)
{
(networkCommon as NetworkClient).Send(null, MessageTranslator.ToByteArray(m));
}
else
{
(networkCommon as NetworkServer).Broadcast(MessageTranslator.ToByteArray(m));
}
}
public async Task StartAsync(IDialogContext context)
{
var _oldGamerProfile = GetUserGamerProfile(context);
_userPointsBeforeLessonPlan = _oldGamerProfile.Points;
var user = context.GetUserData();
string friendlyUserName = user?.UserName;
ICollection <string> lessonTitle = new List <string>();
// get up to 5 lessons
int i = 0;
foreach (Lesson lesson in LessonPlanModule.LessonPlan.Lessons)
{
if (i >= 7)
{
break;
}
//var lessonInNativaLanguage = await MessageTranslator.TranslateTextAsync(lesson.LessonTitle, user?.NativeLanguageIsoCode);
lessonTitle.Add(lesson.LessonTitle);
i++;
}
var questionInNativeLanguage = await MessageTranslator.TranslateTextAsync($"Which lesson would you like to start?", user?.NativeLanguageIsoCode);
PromptDialog.Choice(
context,
this.AfterLessonSelected,
lessonTitle,
$"{questionInNativeLanguage}",
Shared.DoNotUnderstand,
attempts: Shared.MaxPromptAttempts);
}
/// <summary>
/// 初始化所有对象，并初始化类
/// </summary>
public void Init()
{
Client = new UDPThread(_client); //文本网络对象
LivedHost = new OnlineHost(this.Config); //主机列表
MessageProxy = new MessageTranslator(Client, this.Config, LivedHost); //文本信息翻译层对象
//自动查询主机客户端版本
LivedHost.HostOnline += (s, e) =>
{
if (Config.AutoDetectVersion)
{
this.GetVersion(e.Host);
}
};
//文件传输
FileTaskManager = new FileTaskManager(this.Config);
FileTaskManager.FileReceiveTaskDiscarded += (s, e) => this.SendReleaseFilesSignal(e.TaskInfo.RemoteHost, e.TaskInfo.PackageID);
FileTaskModule = new FSLib.IPMessager.Network.TCPThread(_client)
{
TaskManager = FileTaskManager
};
//与接收消息进行挂钩
MessageProxy.MessageReceived += MessageProxy_MessageReceived;
}
public override void OnInspectorGUI()
{
MessageTranslator targetTranslator = (MessageTranslator)target;
for (int i = 0; i < targetTranslator.translations.Count; i++)
{
Translation t = targetTranslator.translations[i];
EditorGUILayout.BeginHorizontal();
t.From = EditorGUILayout.TextField(t.From);
EditorGUILayout.LabelField("=>", GUILayout.Width(20));
t.To = EditorGUILayout.TextField(t.To);
bool remove = GUILayout.Button("-", GUILayout.Width(25));
EditorGUILayout.EndHorizontal();
if (remove)
{
targetTranslator.translations.RemoveAt(i);
i--;
}
}
EditorGUILayout.BeginHorizontal();
GUILayout.Label("", GUILayout.ExpandWidth(true));
bool add = GUILayout.Button("+", GUILayout.Width(25));
GUILayout.Label("", GUILayout.ExpandWidth(true));
GUILayout.Label("", GUILayout.Width(25));
EditorGUILayout.EndHorizontal();
if (add)
{
targetTranslator.translations.Add(new Translation());
}
}
public void Should_Set_Translations_WithoutModification()
{
var translations = new Dictionary <string, IReadOnlyDictionary <string, string> >
{
["translation1"] = new Dictionary <string, string>
{
["key1"] = "message1",
["key2"] = "message2"
},
["translation2"] = new Dictionary <string, string>
{
["key3"] = "message3",
["key4"] = "message4"
}
};
var translator = new MessageTranslator(translations);
translator.Translations.Keys.Should().Contain("translation1");
translator.Translations.Keys.Count().Should().Be(2);
translator.Translations["translation1"].Keys.Count().Should().Be(2);
translator.Translations["translation1"].Keys.Should().Contain("key1");
translator.Translations["translation1"]["key1"].Should().Be("message1");
translator.Translations["translation1"].Keys.Should().Contain("key2");
translator.Translations["translation1"]["key2"].Should().Be("message2");
translator.Translations["translation2"].Keys.Count().Should().Be(2);
translator.Translations["translation2"].Keys.Should().Contain("key3");
translator.Translations["translation2"]["key3"].Should().Be("message3");
translator.Translations["translation2"].Keys.Should().Contain("key4");
translator.Translations["translation2"]["key4"].Should().Be("message4");
}
public void Should_Translate_And_UseArgs_WithParameters()
{
var translations = new Dictionary <string, IReadOnlyDictionary <string, string> >
{
["translation1"] = new Dictionary <string, string>
{
["key1"] = "message1 {arg1|case=upper} {arg1|case=lower}"
}
};
var translator = new MessageTranslator(translations);
var error = new Error()
{
Messages = new[]
{
"key1",
},
Args = new IArg[]
{
Arg.Text("arg1", "arg1Value"),
}
};
var result = translator.TranslateMessages("translation1", error);
result.Messages.Count.Should().Be(1);
result.Messages.Should().Contain("message1 ARG1VALUE arg1value");
result.AnyPathPlaceholders.Should().Be(false);
result.IndexedPathPlaceholders.Should().BeEmpty();
}
private async Task AskToStartLessonPlan(IDialogContext context)
{
var possibleResponses = new List <string>()
{
BotPersonality.GetStartLessonPlanQuestion(),
BotPersonality.BotResponseToGibberish
};
IReadOnlyCollection <string> translatedResponses;
string language;
if (context.UserData.TryGetValue(Constants.Shared.UserLanguageCodeKey, out language) && language != MessageTranslator.DEFAULT_LANGUAGE)
{
translatedResponses = await MessageTranslator.TranslateTextAsync(possibleResponses, language);
}
else
{
translatedResponses = possibleResponses;
}
PromptDialog.Confirm(
context,
TryStartLessonPlan,
translatedResponses.ElementAtOrDefault(0) ?? string.Empty,
translatedResponses.ElementAtOrDefault(1) ?? string.Empty);
}
public void Should_ThrowException_When_TranslationNameNotFound()
{
var translations = new Dictionary <string, IReadOnlyDictionary <string, string> >
{
["translation1"] = new Dictionary <string, string>
{
["key1"] = "message1"
},
["translation2"] = new Dictionary <string, string>
{
["key2"] = "message2"
}
};
var translator = new MessageTranslator(translations);
var error = new Error()
{
Messages = new[]
{
"key1"
},
Args = new IArg[] { }
};
Action action = () => translator.TranslateMessages("translation3", error);
action.Should().ThrowExactly <KeyNotFoundException>();
}
public void Should_Translate_ReturnSameMessage_When_KeyInTranslation()
{
var translations = new Dictionary <string, IReadOnlyDictionary <string, string> >
{
["translation1"] = new Dictionary <string, string>
{
["key1"] = "message1"
},
["translation2"] = new Dictionary <string, string>
{
["key1"] = "message2"
}
};
var translator = new MessageTranslator(translations);
var error = new Error()
{
Messages = new[]
{
"key123"
},
Args = new IArg[]
{
}
};
var result = translator.TranslateMessages("translation2", error);
result.Messages.Count.Should().Be(1);
result.Messages.Should().Contain("key123");
result.AnyPathPlaceholders.Should().Be(false);
result.IndexedPathPlaceholders.Should().BeEmpty();
}
public void Should_Translate_WithPathArgs_And_Leave_When_MissingPlaceholders()
{
var errorMessages = new[]
{
"message1",
"message2 {_name} {_path}",
"message3",
"message4 {_name}",
"message5 {_path}",
};
var indexedPathsPlaceholders = new Dictionary <int, IReadOnlyList <ArgPlaceholder> >()
{
[1] = new[]
{
ParameterlessNamePlaceholders,
},
[4] = new[]
{
ParameterlessPathPlaceholders
}
};
var results = MessageTranslator.TranslateMessagesWithPathPlaceholders("some.path", errorMessages, indexedPathsPlaceholders);
results.Count.Should().Be(5);
results[0].Should().Be("message1");
results[1].Should().Be("message2 path {_path}");
results[2].Should().Be("message3");
results[3].Should().Be("message4 {_name}");
results[4].Should().Be("message5 some.path");
}
public void Should_ThrowException_When_NullTranslationName()
{
var translations = new Dictionary <string, IReadOnlyDictionary <string, string> >
{
["translation1"] = new Dictionary <string, string>
{
["key1"] = "message1"
},
["translation2"] = new Dictionary <string, string>
{
["key2"] = "message2"
}
};
var translator = new MessageTranslator(translations);
var error = new Error()
{
Messages = new[]
{
"key1"
}
};
Action action = () => translator.TranslateMessages(null, error);
action.Should().ThrowExactly <ArgumentNullException>();
}
public void Should_ThrowException_When_Error_ContainsNullArg()
{
var translations = new Dictionary <string, IReadOnlyDictionary <string, string> >
{
["translation1"] = new Dictionary <string, string>
{
["key1"] = "message1"
},
["translation2"] = new Dictionary <string, string>
{
["key2"] = "message2"
}
};
var translator = new MessageTranslator(translations);
var error = new Error()
{
Messages = new[]
{
"key1",
},
Args = new IArg[]
{
Arg.Text("test", "test"),
null
}
};
Action action = () => translator.TranslateMessages("translation1", error);
action.Should().ThrowExactly <ArgumentNullException>();
}
public void Should_Set_TranslationNames()
{
var translations = new Dictionary <string, IReadOnlyDictionary <string, string> >
{
["translation1"] = new Dictionary <string, string>
{
["key1"] = "message1"
},
["translation2"] = new Dictionary <string, string>
{
["key2"] = "message2"
},
["translation3"] = new Dictionary <string, string>
{
["key3"] = "message3"
},
["translation4"] = new Dictionary <string, string>
{
["key4"] = "message4"
}
};
var translator = new MessageTranslator(translations);
translator.TranslationNames.Should().NotBeNull();
translator.TranslationNames.Count.Should().Be(4);
translator.TranslationNames.Should().Contain("translation1");
translator.TranslationNames.Should().Contain("translation2");
translator.TranslationNames.Should().Contain("translation3");
translator.TranslationNames.Should().Contain("translation4");
}
public void Should_Translate_And_UseArgs_Special_Translation_Recursion()
{
var translations = new Dictionary <string, IReadOnlyDictionary <string, string> >
{
["translation1"] = new Dictionary <string, string>
{
["key1"] = "message1 {_translation|key=key1}",
}
};
var translator = new MessageTranslator(translations);
var error = new Error()
{
Messages = new[]
{
"key1",
},
Args = new IArg[]
{
}
};
var result = translator.TranslateMessages("translation1", error);
result.Messages.Count.Should().Be(1);
result.Messages.Should().Contain("message1 message1 {_translation|key=key1}");
result.AnyPathPlaceholders.Should().Be(false);
result.IndexedPathPlaceholders.Should().BeEmpty();
}
public void Should_Translate_And_ExtractPathPlaceholders()
{
var translations = new Dictionary <string, IReadOnlyDictionary <string, string> >
{
["translation1"] = new Dictionary <string, string>
{
["key1"] = "message1",
}
};
var translator = new MessageTranslator(translations);
var error = new Error()
{
Messages = new[]
{
"key1",
"message with path: {_path}",
"message with name: {_name}",
"message with path and name: {_path} {_name}",
},
Args = new IArg[]
{
}
};
var result = translator.TranslateMessages("translation1", error);
result.Messages.Count.Should().Be(4);
result.Messages.ElementAt(0).Should().Be("message1");
result.Messages.ElementAt(1).Should().Be("message with path: {_path}");
result.Messages.ElementAt(2).Should().Be("message with name: {_name}");
result.Messages.ElementAt(3).Should().Be("message with path and name: {_path} {_name}");
result.AnyPathPlaceholders.Should().Be(true);
result.IndexedPathPlaceholders.Count.Should().Be(3);
result.IndexedPathPlaceholders.Keys.Should().Contain(1);
result.IndexedPathPlaceholders.Keys.Should().Contain(2);
result.IndexedPathPlaceholders.Keys.Should().Contain(3);
result.IndexedPathPlaceholders[1].Count.Should().Be(1);
result.IndexedPathPlaceholders[1].ElementAt(0).Name.Should().Be("_path");
result.IndexedPathPlaceholders[1].ElementAt(0).Placeholder.Should().Be("{_path}");
result.IndexedPathPlaceholders[1].ElementAt(0).Parameters.Should().BeEmpty();
result.IndexedPathPlaceholders[2].Count.Should().Be(1);
result.IndexedPathPlaceholders[2].ElementAt(0).Name.Should().Be("_name");
result.IndexedPathPlaceholders[2].ElementAt(0).Placeholder.Should().Be("{_name}");
result.IndexedPathPlaceholders[2].ElementAt(0).Parameters.Should().BeEmpty();
result.IndexedPathPlaceholders[3].Count.Should().Be(2);
result.IndexedPathPlaceholders[3].ElementAt(0).Name.Should().Be("_path");
result.IndexedPathPlaceholders[3].ElementAt(0).Placeholder.Should().Be("{_path}");
result.IndexedPathPlaceholders[3].ElementAt(0).Parameters.Should().BeEmpty();
result.IndexedPathPlaceholders[3].ElementAt(1).Name.Should().Be("_name");
result.IndexedPathPlaceholders[3].ElementAt(1).Placeholder.Should().Be("{_name}");
result.IndexedPathPlaceholders[3].ElementAt(1).Parameters.Should().BeEmpty();
}
private async Task UserNameReceivedInNativeLanguageAsync(IDialogContext context, IAwaitable <IMessageActivity> result)
{
IMessageActivity userText = await result;
string userTextInEnglish = await MessageTranslator.TranslateTextAsync(userText.Text);
userText.Text = userTextInEnglish;
await context.Forward(_chitChatDialog, this.AfterChitChatComplete, userText, CancellationToken.None);
}
public void Replace_IgnoreReplacementsNotRequired()
{
var mt = new MessageTranslator("blah {validator.const} ${Property} ${Property.Prop} {Const}");
var replacements = new Dictionary <string, string> {
{ "${Property}", "1" }, { "{Const}", "2" }
};
mt.Replace(replacements).Should().Be.EqualTo("blah {validator.const} 1 ${Property.Prop} 2");
}
public void Replace_NullWithEmpty()
{
var mt = new MessageTranslator("blah {validator.const} ${Property} ${Property.Prop} {Const}");
var replacements = new Dictionary <string, string> {
{ "${Property}", null }, { "{Const}", "2" }
};
mt.Replace(replacements).Should().Be.EqualTo("blah {validator.const} ${Property.Prop} 2");
}
public void Replace_Duplications()
{
var mt = new MessageTranslator("blah {Const} ${Property} ${Property} {Const}");
var replacements = new Dictionary <string, string> {
{ "${Property}", "2" }, { "{Const}", "1" }
};
mt.Replace(replacements).Should().Be.EqualTo("blah 1 2 2 1");
}
public MessageService(
IReadOnlyDictionary <string, IReadOnlyDictionary <string, string> > translations,
IReadOnlyDictionary <int, IError> errors,
IReadOnlyDictionary <string, IReadOnlyList <int> > template)
{
_translator = new MessageTranslator(translations);
_cache = BuildMessageCache(_translator, errors, template);
}
public MsgTrans()
{
msgTran = new MessageTranslator(new MessageOutput(),
Properties.Settings.Default.NtStatusXml,
Properties.Settings.Default.WinerrorXml,
Properties.Settings.Default.HresultXml,
Properties.Settings.Default.BugcheckXml,
Properties.Settings.Default.WmXml,
Properties.Settings.Default.BugUrl);
Assert.IsNotNull(msgTran);
}
private void ClientConnection()
{
if (!NetworkCommon.Connected)
{
Invoke("ClientConnection", .1f);
}
NetworkCommon.Send(null, MessageTranslator.ToByteArray(
NetworkTranslator.createMessage(NetworkCommon.ID, 1 - NetworkCommon.ID, NetworkMessage.MessageValue.CONNECT)
));
}
public void Should_ThrowException_When_NullIndexedPathHolders()
{
var errorMessages = new[]
{
"message1",
"message2 {_path}"
};
Action action = () => MessageTranslator.TranslateMessagesWithPathPlaceholders("path", errorMessages, null);
action.Should().ThrowExactly <NullReferenceException>();
}
public IReadOnlyDictionary <string, IReadOnlyList <string> > GetMessages(Dictionary <string, List <int> > errors, string translationName = null)
{
var results = new Dictionary <string, IReadOnlyList <string> >(errors.Count);
translationName = translationName ?? nameof(Translation.English);
foreach (var pair in errors)
{
var path = pair.Key;
var errorsIds = pair.Value;
var capacity = _cache.GetMessageAmount(errorsIds);
if (capacity == 0)
{
continue;
}
var allMessages = new string[capacity];
var index = 0;
for (var i = 0; i < errorsIds.Count; ++i)
{
var errorId = errorsIds[i];
IReadOnlyList <string> messages;
if (!_cache.ContainsPathArgs(translationName, errorId))
{
messages = _cache.GetMessages(translationName, errorId);
}
else if (_cache.IsMessageWithPathArgsCached(translationName, path, errorId))
{
messages = _cache.GetMessagesWithPathArgs(translationName, path, errorId);
}
else
{
var cachedMessages = _cache.GetMessages(translationName, errorId);
var indexedPathPlaceholders = _cache.GetIndexedPathPlaceholders(translationName, errorId);
messages = MessageTranslator.TranslateMessagesWithPathPlaceholders(path, cachedMessages, indexedPathPlaceholders);
}
CopyMessages(messages, allMessages, ref index);
}
results.Add(path, allMessages);
}
return(results);
}
public void Replace_TokensToTranslate()
{
var mt = new MessageTranslator("blah {validator.const} ${Property} ${Property.Prop} {Const}");
var replacements = new Dictionary <string, string>
{
{ "{validator.const}", "1" },
{ "${Property}", "2" },
{ "${Property.Prop}", "3" },
{ "{Const}", "4" }
};
mt.Replace(replacements).Should().Be.EqualTo("blah 1 2 3 4");
}
void ReceiveResult(IAsyncResult ar)
{
var receiveCallback = (ReceiveDelegate)ar.AsyncState;
IPEndPoint ep = null;
var bytes = m_Client.EndReceive(ar, ref ep);
if (this is NetworkServer)
{
(this as NetworkServer).addClient(ep);
}
receiveCallback(bytes, b => MessageTranslator.Interpret(ep, b));
}
