public void GetConfigurationTest()
{
// arrage
var httpClient = new HttpClient();
// act
ITranslatorService translatorService = new TranslatorService(httpClient, EnvironmentName, ContentRootPath);
TranslatorConfig config = translatorService.GetConfiguration();
// assert
Assert.Equal(configuration.TranslatorTextAPIKey, config.TranslatorTextAPIKey);
}
public static void Run(TimerInfo myTimer, TraceWriter log)
{
try
{
var translatorSetting = new TranslatorSetting
{
APIKey = ConfigurationManager.AppSettings["TranslatorAPIKey"],
};
var twitterSetting = new TwitterSetting
{
ConsumerKey = ConfigurationManager.AppSettings["TwitterConsumerKey"],
ConsumerSecret = ConfigurationManager.AppSettings["TwitterConsumerSecret"],
AccessToken = ConfigurationManager.AppSettings["TwitterAccessToken"],
AccessTokenSecret = ConfigurationManager.AppSettings["TwitterAccessTokenSecret"],
};
var visionSetting = new VisionSetting
{
APIKey = ConfigurationManager.AppSettings["VisionAPIAPIKey"],
Endpoint = ConfigurationManager.AppSettings["VisionAPIEndpoint"],
};
var cosmosDbSetting = new CosmosDbSetting
{
EndpointUri = ConfigurationManager.AppSettings["CosmosDbEndpointUri"],
PrimaryKey = ConfigurationManager.AppSettings["CosmosDbPrimaryKey"],
};
var analyzeSetting = new AnalyzeSetting
{
Keyword = ConfigurationManager.AppSettings["AnalyzeKeyword"],
};
// services
var logger = new TraceWriterLogger(log);
var translatorService = new TranslatorService(Options.Create(translatorSetting), logger);
var twitterService = new TwitterService(Options.Create(twitterSetting), logger);
var visionService = new VisionService(Options.Create(visionSetting), translatorService, logger);
var categolizedImageRepository = new CategorizedImageRepository(Options.Create(cosmosDbSetting), logger);
var analyzeService = new AnalyzeService(Options.Create(analyzeSetting),
twitterService,
visionService,
categolizedImageRepository,
logger);
// initialize
twitterService.InitializeAsync().Wait();
// run
analyzeService.AnalyzeAsync().Wait();
}
catch (Exception ex)
{
log.Error($"Error {ex.ToString()}");
}
}
public async Task OnTurnAsync(ITurnContext turnContext, NextDelegate next, CancellationToken cancellationToken = default(CancellationToken))
{
if (string.IsNullOrEmpty(turnContext.Activity.Text))
{
await next(cancellationToken);
return;
}
var language = await _languageStateProperty.GetAsync(turnContext, () => null);
if (string.IsNullOrEmpty(language))
{
language = await TranslatorService.Detect(turnContext.Activity.Text);
await _languageStateProperty.SetAsync(turnContext, language);
}
if (!language.StartsWith("en"))
{
// If the language in the message is not english we will translate it to english before continue
var translatedText = await TranslatorService.Translate(turnContext.Activity.Text, language, "en");
turnContext.Activity.Text = translatedText;
}
turnContext.OnSendActivities(async(newContext, activities, nextSend) =>
{
var userLanguage = await _languageStateProperty.GetAsync(turnContext, () => DefaultLanguage) ?? DefaultLanguage;
var shouldTranslate = userLanguage != DefaultLanguage;
// Translate messages sent to the user to user language
if (shouldTranslate)
{
var tasks = new List <Task>();
foreach (Activity currentActivity in activities.Where(a => a.Type == ActivityTypes.Message))
{
tasks.Add(TranslateMessageActivityAsync(currentActivity, userLanguage));
}
if (tasks.Any())
{
await Task.WhenAll(tasks).ConfigureAwait(false);
}
}
return(await nextSend());
});
await next(cancellationToken);
}
static void Main(string[] args)
{
while (true)
{
try {
TranslatorService translatorService = new TranslatorService();
translatorService.Execute();
}
catch (Exception ex) {
Console.WriteLine($"An error occured while translating files: {ex}");
}
Thread.Sleep(Config.Instance.TranslatorExecutionInterval);
}
}
public async void TranslateSentenceTest()
{
// arrage
var expectedTranslation = "hello";
List <Dictionary <string, List <Dictionary <string, string> > > > translationResponse = new List <Dictionary <string, List <Dictionary <string, string> > > >();
Dictionary <string, List <Dictionary <string, string> > > translationResponse_Dictionary = new Dictionary <string, List <Dictionary <string, string> > >();
List <Dictionary <string, string> > translationResponse_Dictionary_List = new List <Dictionary <string, string> >();
Dictionary <string, string> translationResponse_Dictionary_List_Dictionary = new Dictionary <string, string>();
translationResponse_Dictionary_List_Dictionary.Add("text", "hello");
translationResponse_Dictionary_List.Add(translationResponse_Dictionary_List_Dictionary);
translationResponse_Dictionary.Add("translations", translationResponse_Dictionary_List);
translationResponse.Add(translationResponse_Dictionary);
var jsonTranslationResponse = JsonConvert.SerializeObject(translationResponse);
var handlerMock = new Mock <HttpMessageHandler>(MockBehavior.Strict);
handlerMock
.Protected()
.Setup <Task <HttpResponseMessage> >(
"SendAsync",
ItExpr.IsAny <HttpRequestMessage>(),
ItExpr.IsAny <CancellationToken>()
)
.ReturnsAsync(new HttpResponseMessage()
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(jsonTranslationResponse),
})
.Verifiable();
var httpClient = new HttpClient(handlerMock.Object)
{
BaseAddress = new Uri("http://localhost/")
};
// act
ITranslatorService translatorService = new TranslatorService(httpClient, EnvironmentName, ContentRootPath);
var translation = await translatorService.TranslateSentenceAsync("hola", "es", "en");
// assert
Assert.Equal(expectedTranslation, translation);
}
public ChangeLanguageDialog(
UserState userState,
TelemetryClient telemetryClient,
TranslatorService translator,
IOptionsMonitor <BotSettings> optionsAccessor
)
: base(nameof(ChangeLanguageDialog))
{
_languagePreferenceProperty = userState.CreateProperty <string>(TranslationMiddleware.PreferredLanguageSetting);
_pauseTranslationProperty = userState.CreateProperty <bool>(TranslationMiddleware.PauseTranslationSetting);
_translator = translator;
_telemetryClient = telemetryClient;
_options = optionsAccessor.CurrentValue;
AddDialog(new ChoicePrompt("languagePrompt"));
AddDialog(new WaterfallDialog("localRoot",
new WaterfallStep[] { StartDialogAsync, ProcessLanguageResponse }));
InitialDialogId = "localRoot";
}
public async void GetDesiredLanguageTest()
{
// arrage
var expectedLanguage = "es";
var desiredLanguageResponse = new List <DesiredLanguageResponse>()
{
new DesiredLanguageResponse()
{
language = expectedLanguage, alternatives = new List <DesiredLanguageResponse>()
{
new DesiredLanguageResponse()
}
}
};
var jsonDesiredLanguageResponse = JsonConvert.SerializeObject(desiredLanguageResponse);
var handlerMock = new Mock <HttpMessageHandler>(MockBehavior.Strict);
handlerMock
.Protected()
.Setup <Task <HttpResponseMessage> >(
"SendAsync",
ItExpr.IsAny <HttpRequestMessage>(),
ItExpr.IsAny <CancellationToken>()
)
.ReturnsAsync(new HttpResponseMessage()
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(jsonDesiredLanguageResponse),
})
.Verifiable();
var httpClient = new HttpClient(handlerMock.Object)
{
BaseAddress = new Uri("http://localhost/")
};
// act
ITranslatorService translatorService = new TranslatorService(httpClient, EnvironmentName, ContentRootPath);
var language = await translatorService.GetDesiredLanguageAsync("hola");
// assert
Assert.Equal(expectedLanguage, language);
}
public async Task Translate_Yoda_Correctly()
{
//given
var model = new MessageViewModel()
{
Text = "this is war"
};
//when
var mock = new Mock <ILogger <TranslatorService> >();
ILogger <TranslatorService> logger = mock.Object;
var sut = new TranslatorService(logger);
var result = await sut.YodaTranslate(model);
//then
Assert.Equal("War, this is", result);
}
private async Task <IList <CardAction> > TranslateCardActions(string targetLanguage, IEnumerable <CardAction> actions)
{
if (targetLanguage?.StartsWith("en") ?? true)
{
return(actions.ToList());
}
var translatedActions = new List <CardAction>();
foreach (var action in actions)
{
var title = await TranslatorService.Translate(action.Title, "en", targetLanguage);
var value = await TranslatorService.Translate(action.Value as string, "en", targetLanguage);
translatedActions.Add(new CardAction(action.Type, title, action.Image, value: value));
}
return(translatedActions);
}
/// <summary>
/// POST: api/Messages
/// Receive a message from a user and reply to it
/// </summary>
public async Task <HttpResponseMessage> Post([FromBody] Activity activity)
{
if (activity.Type == ActivityTypes.Message)
{
// if (IsSpellCorrectionEnabled)
// {
try
{
// activity.Text = await this.spellService.GetCorrectedTextAsync(activity.Text);
ConnectorClient connector = new ConnectorClient(new Uri(activity.ServiceUrl));
var input = activity.Text;
Task.Run(async() =>
{
// var accessToken = await GetAuthenticationToken(ApiKey);
var output = await TranslatorService.TranslateText(input, targetLang);
Console.WriteLine(output);
activity.Text = output;
await Conversation.SendAsync(activity, () => new RootLuisDialog());
// Activity reply = activity.CreateReply($"Your text translation to English is => '{output}'");
// await connector.Conversations.ReplyToActivityAsync(reply);
}).Wait();
}
catch (Exception ex)
{
Trace.TraceError(ex.ToString());
}
// }
//await Conversation.SendAsync(activity, () => new RootLuisDialog());
}
else
{
this.HandleSystemMessage(activity);
}
var response = Request.CreateResponse(HttpStatusCode.OK);
return(response);
}
public ActionResult Submit()
{
using (var t = DbSession.BeginTransaction())
{
var me = TranslatorService.FindByEmail(HttpContext.User.Identity.Name);
var changes = DbSession.CreateCriteria <Translation>()
.Add(Restrictions.Eq("IsPublished", false))
.Add(Restrictions.Eq("Translator", me))
.CreateAlias("Key", "k")
.CreateAlias("k.Set", "s")
.Future <Translation>();
var votes = DbSession.QueryOver <TranslationVote>()
.Where(x => x.IsPublished == false)
.And(x => x.Translator == me)
.Future();
foreach (var translation in changes.ToList())
{
translation.IsPublished = true;
translation.NeedsReviewing = true;
DbSession.Update(translation);
}
foreach (var vote in votes.ToList())
{
vote.IsPublished = true;
vote.NeedsReviewing = true;
DbSession.Update(vote);
}
t.Commit();
}
return(RedirectToAction("Index"));
}
public IActionResult Index()
{
#region with google api
//var client = TranslationClient.Create();
//List<ProductVM> vMs = new List<ProductVM>();
//var products = context.Products.ToList();
//foreach (var item in products)
//{
// ProductVM p = new ProductVM()
// {
// Description = item.Description,
// Price = item.Price,
// Name = item.Name,
// DescriptionENG = client.TranslateText(item.Description, LanguageCodes.Turkish, LanguageCodes.English).TranslatedText
// };
// vMs.Add(p);
//}
#endregion with yandex api
//var client = TranslationClient.Create();
List <ProductVM> vMs = new List <ProductVM>();
var products = context.Products.ToList();
foreach (var item in products)
{
ProductVM p = new ProductVM()
{
Description = item.Description,
Price = item.Price,
Name = item.Name,
DescriptionENG = TranslatorService.AzToEng(item.Description)
};
vMs.Add(p);
}
return(View(vMs));
}
static ViewModelLocator()
{
ServiceLocator.SetLocatorProvider(() => SimpleIoc.Default);
SimpleIoc.Default.Register <ITranslatorService>(() =>
{
var language = GetLanguage();
var service = new TranslatorService(Constants.TranslatorClientId, Constants.TranslatorClientSecret, language);
return(service);
});
SimpleIoc.Default.Register <VisionServiceClient>(() => new VisionServiceClient(Constants.VisionSubscriptionKey));
SimpleIoc.Default.Register <ISpeechService, SpeechService>();
SimpleIoc.Default.Register <IStreamingService, StreamingService>();
SimpleIoc.Default.Register <ISettingsService, SettingsService>();
SimpleIoc.Default.Register <MainViewModel>();
OnInitialize();
}
public async Task <HttpResponseMessage> Post([FromBody] Activity activity)
{
var translator = new TranslatorService();
if (activity == null)
{
//tc.TrackTrace("MessagesController::NULL Activity received");
}
else if (activity.Type == ActivityTypes.Message)
{
var text = activity.Text;
if (text.ToLowerInvariant() == "ping")
{
ConnectorClient connector = new ConnectorClient(new Uri(activity.ServiceUrl));
Activity reply = activity.CreateReply("pong");
await connector.Conversations.ReplyToActivityAsync(reply);
}
else if (activity.Text.ToLowerInvariant().Contains("command language"))
{
var t = activity.Text.ToLowerInvariant().Replace("command language", "");
t = t.Trim();
await translator.SetLanguage(activity, t);
ConnectorClient connector = new ConnectorClient(new Uri(activity.ServiceUrl));
Activity reply = activity.CreateReply(await translator.TranslateBack(activity, "Your language preference has been set!"));
await connector.Conversations.ReplyToActivityAsync(reply);
}
else
{
var language = await translator.GetLanguage(activity);
if (!string.IsNullOrWhiteSpace(language))
{
var detected = await translator.Detect(text);
if (detected == "en")
{
//do nothing becasue it might be a response.
// await translator.SetLanguage(activity, null);
}
else
{
var translated = await translator.Translate(text, language);
if (!string.IsNullOrWhiteSpace(translated))
{
activity.Text = translated;
}
}
}
await Conversation.SendAsync(activity, () => new LuisModel());
}
}
else
{
await _handleSystemMessage(activity);
}
var response = Request.CreateResponse(HttpStatusCode.OK);
return(response);
}
/// <summary>
/// Initializes a new instance of the <see cref="MicrosoftTranslatorPage"/> class.
/// </summary>
public MicrosoftTranslatorPage()
{
InitializeComponent();
_translatorClient = TranslatorService.Instance;
}
public TranslatorServiceAdapter(ISupportHandler nextHandler) : base(nextHandler)
{
_translatorService = new TranslatorService();
}
public void Init()
{
_translatorService = new TranslatorService(Utils.TranslatorKey);
}
public TranslatingDialogContext(IDialogContext original)
{
_translatorService = new TranslatorService();
_original = original;
}
public TranslatorsController()
{
translatorService = new TranslatorService();
}
/*
* METHODS
*/
void Gets()
{
// DESCRIPTION: Get references to external objects
translatorDictionary = TranslatorService.Instance;
myDisplay = GetComponent <Text>();
}
