public void CreateModel()
{
IamAuthenticator authenticator = new IamAuthenticator(
apikey: "{apikey}");
LanguageTranslatorService service = new LanguageTranslatorService("2018-05-01", authenticator);
DetailedResponse <TranslationModel> result;
using (FileStream fs = File.OpenRead("glossary.tmx"))
{
using (MemoryStream ms = new MemoryStream())
{
fs.CopyTo(ms);
result = service.CreateModel(
baseModelId: "en-es",
forcedGlossary: ms,
name: "custom-en-es"
);
}
}
Console.WriteLine(result.Response);
modelId = result.Result.ModelId;
}
public void TranslateDocument()
{
IamAuthenticator authenticator = new IamAuthenticator(
apikey: "{apikey}");
LanguageTranslatorService service = new LanguageTranslatorService("2018-05-01", authenticator);
DetailedResponse <DocumentStatus> result;
using (FileStream fs = File.OpenRead("{filepath}"))
{
using (MemoryStream ms = new MemoryStream())
{
fs.CopyTo(ms);
result = service.TranslateDocument(
file: ms,
filename: "{filename}",
fileContentType: "{fileContentType}",
modelId: "en-fr"
);
}
}
Console.WriteLine(result.Response);
documentId = result.Result.DocumentId;
}
public void TranslateDocument()
{
IamConfig config = new IamConfig(
apikey: apikey
);
LanguageTranslatorService service = new LanguageTranslatorService(versionDate, config);
DetailedResponse <DocumentStatus> result;
using (FileStream fs = File.OpenRead(documentToTranslatePath))
{
using (MemoryStream ms = new MemoryStream())
{
fs.CopyTo(ms);
result = service.TranslateDocument(
file: ms,
filename: Path.GetFileName(documentToTranslatePath),
fileContentType: "text/plain",
modelId: "en-es"
);
}
}
Console.WriteLine(result.Response);
documentId = result.Result.DocumentId;
}
public void CreateModel_Catch_Exception()
{
IClient client = this.CreateClient();
IRequest request = Substitute.For <IRequest>();
client.PostAsync(Arg.Any <string>())
.Returns(request);
request.WithArgument(Arg.Any <string>(), Arg.Any <string>())
.Returns(request);
request.WithBodyContent(Arg.Any <HttpContent>())
.Returns(x =>
{
throw new AggregateException(new ServiceResponseException(Substitute.For <IResponse>(),
Substitute.For <HttpResponseMessage>(HttpStatusCode.BadRequest),
string.Empty));
});
LanguageTranslatorService service =
new LanguageTranslatorService(client);
service.VersionDate = "versionDate";
var customModel = service.CreateModel("model_unit_test");
}
// Update is called once per frame
public IEnumerator CreateService()
{
if (string.IsNullOrEmpty(iamApikey))
{
throw new IBMException("Plesae provide IAM ApiKey for the service.");
}
// Create credential and instantiate service
IamAuthenticator authenticator = new IamAuthenticator(apikey: iamApikey);
// Wait for tokendata
while (!authenticator.CanAuthenticate())
{
yield return(null);
}
service = new LanguageTranslatorService(versionDate, authenticator);
if (!string.IsNullOrEmpty(serviceUrl))
{
service.SetServiceUrl(serviceUrl);
}
Log.Debug("LanguageTranslatorServiceV3", "ListModels result");
Translate(new List <string>()
{
"hola", "como", "estas"
});
}
public void DeleteModel_Success()
{
IClient client = this.CreateClient();
IRequest request = Substitute.For <IRequest>();
client.DeleteAsync(Arg.Any <string>())
.Returns(request);
request.As <DeleteModelResult>()
.Returns(Task.FromResult(new DetailedResponse <DeleteModelResult>()
{
Result = new DeleteModelResult()
{
Status = "success"
}
}));
LanguageTranslatorService service =
new LanguageTranslatorService(client);
service.VersionDate = "versionDate";
var deletedModel = service.DeleteModel("model_id");
Assert.IsNotNull(deletedModel);
client.Received().DeleteAsync(Arg.Any <string>());
Assert.IsTrue(deletedModel.Result.Status.Equals("success"));
}
public void CreateModel_Success()
{
IClient client = this.CreateClient();
IRequest request = Substitute.For <IRequest>();
client.PostAsync(Arg.Any <string>())
.Returns(request);
request.WithArgument(Arg.Any <string>(), Arg.Any <string>())
.Returns(request);
request.WithBodyContent(Arg.Any <HttpContent>())
.Returns(request);
request.As <CustomModels>()
.Returns(Task.FromResult(new CustomModels()
{
ModelId = "new_id"
}));
LanguageTranslatorService service =
new LanguageTranslatorService(client);
var customModel =
service.CreateModel(CreateModelOptions.CreateOptions()
.WithName("base_id")
.WithBaseModelId("model_unit_test")
.SetForcedGlossary(Substitute.For <FileStream>("any_file", FileMode.Create)));
Assert.IsNotNull(customModel);
client.Received().PostAsync(Arg.Any <string>());
Assert.IsFalse(string.IsNullOrEmpty(customModel.ModelId));
}
public void Model_Success()
{
_service =
new LanguageTranslatorService(_username, _password);
_service.SetEndpoint(_endpoint);
TranslationModel createModelResult;
using (FileStream fs = File.OpenRead(_glossaryPath))
{
createModelResult = _service.CreateModel(_baseModel, _customModelName, forcedGlossary: fs);
if (createModelResult != null)
{
_customModelID = createModelResult.ModelId;
}
else
{
Console.WriteLine("result is null.");
}
}
var result = _service.DeleteModel(_customModelID);
Assert.IsNotNull(createModelResult);
Assert.IsNotNull(result);
Assert.IsTrue(result.Status == "OK");
}
public void GetModelDetails_Success()
{
IClient client = this.CreateClient();
IRequest request = Substitute.For <IRequest>();
client.GetAsync(Arg.Any <string>())
.Returns(request);
request.As <TranslationModel>()
.Returns(Task.FromResult(new DetailedResponse <TranslationModel>()
{
Result = new TranslationModel()
{
ModelId = "model_id"
}
}));
LanguageTranslatorService service =
new LanguageTranslatorService(client);
service.VersionDate = "versionDate";
var modelDetails = service.GetModel("model_id");
Assert.IsNotNull(modelDetails);
client.Received().GetAsync(Arg.Any <string>());
Assert.IsFalse(string.IsNullOrEmpty(modelDetails.Result.ModelId));
}
public void LangaugeTranslatorV3WithLoadedCredentials_Success()
{
LanguageTranslatorService service = new LanguageTranslatorService();
Assert.IsTrue(!string.IsNullOrEmpty(service.ApiKey));
Assert.IsTrue(!string.IsNullOrEmpty(service.Url));
}
public async Task <IActionResult> LanguageTranslator([FromBody] JObject request)
{
var watch = System.Diagnostics.Stopwatch.StartNew();
string methodName = "LanguageTranslator";
ResponseDTO response = new ResponseDTO();
try
{
Log.Write(appSettings, LogEnum.DEBUG.ToString(), label, className, methodName, $"REQUEST: {JsonConvert.SerializeObject(request)}");
LanguageTranslatorRequest requestBody = request.ToObject <LanguageTranslatorRequest>();
response.Result = await LanguageTranslatorService.GoogleLanguageTranslator(appSettings, requestBody);
response.Success = true;
watch.Stop();
Log.Write(appSettings, LogEnum.INFO.ToString(), label, className, methodName, $"RESULT: {JsonConvert.SerializeObject(response)} Execution Time: {watch.ElapsedMilliseconds} ms");
return(Ok(response));
}
catch (Exception e)
{
response.Success = false;
response.Msg = e.Message;
watch.Stop();
Log.Write(appSettings, LogEnum.ERROR.ToString(), label, className, methodName, $"ERROR: {JsonConvert.SerializeObject(request)}");
Log.Write(appSettings, LogEnum.ERROR.ToString(), label, className, methodName, $"ERROR: {e.Source + Environment.NewLine + e.Message + Environment.NewLine + e.StackTrace}");
return(BadRequest(response));
}
}
public void Translate_Success_With_Source_Target()
{
IClient client = this.CreateClient();
IRequest request = Substitute.For <IRequest>();
client.PostAsync(Arg.Any <string>())
.Returns(request);
request.WithBody <JObject>(Arg.Any <JObject>(), Arg.Any <MediaTypeHeaderValue>())
.Returns(request);
TranslateResponse response = new TranslateResponse()
{
Translations = new List <Translations>()
{
new Translations()
{
Translation = "text translated"
}
}
};
request.As <TranslateResponse>()
.Returns(Task.FromResult(response));
LanguageTranslatorService service =
new LanguageTranslatorService(client);
var translation = service.Translate("source", "target", "text in any language");
Assert.IsNotNull(translation);
client.Received().PostAsync(Arg.Any <string>());
Assert.IsTrue(translation.Translations.Count == 1);
}
public void GetIdentifiableLanguages_Success()
{
IClient client = this.CreateClient();
IRequest request = Substitute.For <IRequest>();
client.GetAsync(Arg.Any <string>())
.Returns(request);
IdentifiableLanguages response = new IdentifiableLanguages()
{
Languages = new List <IdentifiableLanguage>()
{
new IdentifiableLanguage()
{
Language = "language",
Name = "name"
}
}
};
request.As <IdentifiableLanguages>()
.Returns(Task.FromResult(response));
LanguageTranslatorService service =
new LanguageTranslatorService(client);
var identifiableLanguages = service.GetIdentifiableLanguages();
Assert.IsNotNull(identifiableLanguages);
client.Received().GetAsync(Arg.Any <string>());
Assert.IsTrue(identifiableLanguages.Languages.Count == 1);
Assert.IsTrue(identifiableLanguages.Languages.First().Name.Equals("name"));
}
public void Translate_Catch_Exception()
{
IClient client = this.CreateClient();
IRequest request = Substitute.For <IRequest>();
client.PostAsync(Arg.Any <string>())
.Returns(request);
request.WithBodyContent(Arg.Any <StringContent>())
.Returns(x =>
{
throw new AggregateException(new ServiceResponseException(Substitute.For <IResponse>(),
Substitute.For <HttpResponseMessage>(HttpStatusCode.BadRequest),
string.Empty));
});
LanguageTranslatorService service =
new LanguageTranslatorService(client);
service.VersionDate = "versionDate";
service.Translate(new List <string>()
{
"text in any language"
});
}
public Dictionary <string, string> GetSupportedLangs()
{
Dictionary <string, string> languageList = new Dictionary <string, string>();
try
{
IamAuthenticator authenticator = new IamAuthenticator(
apikey: "o1IZscyN4KLM5hTvs_TVbhdf6_BylgDT1clM35Xlr2oK"
);
LanguageTranslatorService languageTranslator = new LanguageTranslatorService("2018-05-01", authenticator);
languageTranslator.SetServiceUrl("https://api.eu-gb.language-translator.watson.cloud.ibm.com/instances/fe321fb1-62b9-4c3d-8752-37081a369884");
var result = languageTranslator.ListIdentifiableLanguages();
if (result.Result.Languages.Count() > 0)
{
foreach (var item in result.Result.Languages)
{
languageList.Add(item.Language, item.Name);
}
}
}
catch (Exception e)
{
e.ToString();
}
return(languageList);
}
public void CreateModel_Success()
{
languageTranslator =
new LanguageTranslatorService(_userName, _password);
languageTranslator.Endpoint = _endpoint;
TranslationModel result;
using (FileStream fs = File.OpenRead(_glossaryPath))
{
result = languageTranslator.CreateModel(_baseModel, _customModelName, forcedGlossary: fs);
if (result != null)
{
_customModelID = result.ModelId;
}
else
{
Console.WriteLine("result is null.");
}
}
Assert.IsNotNull(result);
Assert.IsFalse(string.IsNullOrEmpty(result.ModelId));
}
public void CreateModel_Success()
{
IClient client = this.CreateClient();
IRequest request = Substitute.For <IRequest>();
client.PostAsync(Arg.Any <string>())
.Returns(request);
request.WithArgument(Arg.Any <string>(), Arg.Any <string>())
.Returns(request);
request.WithBodyContent(Arg.Any <HttpContent>())
.Returns(request);
request.As <TranslationModel>()
.Returns(Task.FromResult(new DetailedResponse <TranslationModel>()
{
Result = new TranslationModel()
{
ModelId = "new_id"
}
}));
LanguageTranslatorService service =
new LanguageTranslatorService(client);
service.VersionDate = "versionDate";
var customModel = service.CreateModel("model_unit_test");
Assert.IsNotNull(customModel);
client.Received().PostAsync(Arg.Any <string>());
Assert.IsFalse(string.IsNullOrEmpty(customModel.Result.ModelId));
}
public void CreateModel()
{
IamConfig config = new IamConfig(
apikey: apikey
);
LanguageTranslatorService service = new LanguageTranslatorService(versionDate, config);
DetailedResponse <TranslationModel> result;
using (FileStream fs = File.OpenRead(glossaryPath))
{
using (MemoryStream ms = new MemoryStream())
{
fs.CopyTo(ms);
result = service.CreateModel(
baseModelId: "en-fr",
forcedGlossary: ms,
name: "dotnetExampleModel"
);
}
}
Console.WriteLine(result.Response);
modelId = result.Result.ModelId;
}
public IEnumerator GetLanguages()
{
while (!authenticator.CanAuthenticate())
{
yield return(null);
}
languageTranslatorService = new LanguageTranslatorService(versionDate, authenticator);
languageTranslatorService.SetServiceUrl("https://gateway-lon.watsonplatform.net/language-translator/api");
languageTranslatorService.ListIdentifiableLanguages(
callback: (DetailedResponse <IdentifiableLanguages> response, IBMError error) =>
{
if (error != null)
{
return;
}
foreach (var element in response.Result.Languages)
{
languages.Add(element.Name);
languagesShort.Add(element.Language);
}
});
}
public void TranslateDocument_Success()
{
IClient client = Substitute.For <IClient>();
IRequest request = Substitute.For <IRequest>();
client.PostAsync(Arg.Any <string>())
.Returns(request);
LanguageTranslatorService service = new LanguageTranslatorService(client);
var versionDate = "versionDate";
service.VersionDate = versionDate;
var file = new MemoryStream();
var filename = "filename";
var fileContentType = "fileContentType";
var modelId = "modelId";
var source = "source";
var target = "target";
var documentId = "documentId";
var result = service.TranslateDocument(file: file, filename: filename, fileContentType: fileContentType, modelId: modelId, source: source, target: target, documentId: documentId);
request.Received().WithArgument("version", versionDate);
}
public void TranslateDocument()
{
TokenOptions tokenOptions = new TokenOptions()
{
IamApiKey = apikey,
ServiceUrl = url
};
LanguageTranslatorService service = new LanguageTranslatorService(tokenOptions, versionDate);
DetailedResponse <DocumentStatus> result;
using (FileStream fs = File.OpenRead(documentToTranslatePath))
{
using (MemoryStream ms = new MemoryStream())
{
fs.CopyTo(ms);
result = service.TranslateDocument(
file: ms,
filename: Path.GetFileName(documentToTranslatePath),
fileContentType: "text/plain",
modelId: "en-es"
);
}
}
Console.WriteLine(result.Response);
documentId = result.Result.DocumentId;
}
public void CreateModel()
{
TokenOptions tokenOptions = new TokenOptions()
{
IamApiKey = apikey,
ServiceUrl = url
};
LanguageTranslatorService service = new LanguageTranslatorService(tokenOptions, versionDate);
DetailedResponse <TranslationModel> result;
using (FileStream fs = File.OpenRead(glossaryPath))
{
using (MemoryStream ms = new MemoryStream())
{
fs.CopyTo(ms);
result = service.CreateModel(
baseModelId: "en-fr",
forcedGlossary: ms,
name: "dotnetExampleModel"
);
}
}
Console.WriteLine(result.Response);
modelId = result.Result.ModelId;
}
public void ConstructorExternalConfig()
{
var apikey = System.Environment.GetEnvironmentVariable("LANGUAGE_TRANSLATOR_APIKEY");
System.Environment.SetEnvironmentVariable("LANGUAGE_TRANSLATOR_APIKEY", "apikey");
LanguageTranslatorService service = Substitute.For <LanguageTranslatorService>("versionDate");
Assert.IsNotNull(service);
System.Environment.SetEnvironmentVariable("LANGUAGE_TRANSLATOR_APIKEY", apikey);
}
public void LisListModels_Sucess()
{
LanguageTranslatorService service =
new LanguageTranslatorService(_userName, _password);
var results = service.ListModels(true, "en", string.Empty);
Assert.IsNotNull(results);
Assert.IsTrue(results.Models.Count > 0);
}
public void GetModelDetails()
{
LanguageTranslatorService service =
new LanguageTranslatorService(_userName, _password);
var results = service.GetModelDetails("en-pt");
Assert.IsNotNull(results);
Assert.IsFalse(string.IsNullOrEmpty(results.ModelId));
}
public void Identify_Sucess()
{
LanguageTranslatorService service =
new LanguageTranslatorService(_userName, _password);
var results = service.Identify("Hello! How are you?");
Assert.IsNotNull(results);
Assert.IsTrue(results.Languages.Count > 0);
}
public void Translate_Sucess()
{
LanguageTranslatorService service =
new LanguageTranslatorService(_userName, _password);
var results = service.Translate("en", "pt", "Hello! How are you?");
Assert.IsNotNull(results);
Assert.IsTrue(results.Translations.Count > 0);
}
public void GetIdentifiableLanguages_Sucess()
{
LanguageTranslatorService service =
new LanguageTranslatorService(_userName, _password);
var results = service.GetIdentifiableLanguages();
Assert.IsNotNull(results);
Assert.IsTrue(results.Languages.Count > 0);
}
public void Identify_Sucess()
{
_service =
new LanguageTranslatorService(_username, _password);
_service.Endpoint = _endpoint;
var results = _service.Identify(_text);
Assert.IsNotNull(results);
Assert.IsTrue(results.Languages.Count > 0);
}
public void GetModelDetails_Success()
{
_service =
new LanguageTranslatorService(_username, _password);
_service.Endpoint = _endpoint;
var results = _service.GetModel(_baseModel);
Assert.IsNotNull(results);
Assert.IsFalse(string.IsNullOrEmpty(results.ModelId));
}
