private IEnumerable <Uri> getRequestUri(TextTranslationRequestModel model)
{
if (model.IsTranslationEachLanguage)
{
foreach (var language in model.ToLanguages)
{
yield return(getRequestUri(model, language));
}
}
else
{
yield return(getRequestUri(model, string.Empty));
}
}
private Uri getRequestUri(TextTranslationRequestModel model, string languageCode = "")
{
var url = GetApiUrl();
if (string.IsNullOrWhiteSpace(languageCode))
{
url = $"{url}&to={String.Join("&to=", model.ToLanguages)}";
}
else
{
url = $"{url}&to={languageCode}";
}
if (!String.IsNullOrWhiteSpace(model.FromLanguage))
{
url = $"{url}&from={model.FromLanguage}";
}
if (!String.IsNullOrWhiteSpace(model.TextType) && !model.TextType.Equals(TextTypes.Plain, StringComparison.OrdinalIgnoreCase))
{
url = $"{url}&textType={model.TextType}";
}
if (!String.IsNullOrWhiteSpace(model.Category) && !model.Category.Equals(Categories.General, StringComparison.OrdinalIgnoreCase))
{
url = $"{url}&category={model.Category}";
}
if (!String.IsNullOrWhiteSpace(model.ProfanityAction) && !model.ProfanityAction.Equals(ProfanityActions.NoAction, StringComparison.OrdinalIgnoreCase))
{
url = $"{url}&profanityAction={model.ProfanityAction}";
if (!String.IsNullOrWhiteSpace(model.ProfanityMarker) && !model.ProfanityMarker.Equals(ProfanityMarkers.Asterisk, StringComparison.OrdinalIgnoreCase))
{
url = $"{url}&profanityMarker={model.ProfanityMarker}";
}
}
var requestUri = new Uri(url);
//logger.LogInformation($"{TAG} Request uri: {requestUri.ToString()}");
return(requestUri);
}
private void ValidateRequestbody(TextTranslationRequestModel model)
{
var message = "";
var errorMessage = new List <string>();
var inputsCount = model.Inputs.Count();
if (inputsCount == 0)
{
errorMessage.Add("Text to translate is required.");
}
if (inputsCount > 100)
{
errorMessage.Add("The array can have at most 100 elements.");
}
foreach (var input in model.Inputs)
{
// https://docs.microsoft.com/en-us/azure/cognitive-services/translator/request-limits#character-and-array-limits-per-request
// Max 10,000 characters.
// Request to translate (+1) and Response to be translated ( + count of to translate languages)
var contentLength = input.Text.Length * ((model.IsTranslationEachLanguage ? 1 : model.ToLanguages.Count()) + 1);
logger.LogInformation($"{Tag} Calculated characters={contentLength}");
if (contentLength > 10000)
{
errorMessage.Add("The entire text included in the request cannot exceed 10,000 characters including spaces.");
break;
}
}
if (errorMessage.Count > 0)
{
message = "Request body is invalid.";
logger.LogInformation($"{Tag} {message}");
throw new ApiHttpStatusException <IEnumerable <string> >(HttpStatusCode.BadRequest, message, errorMessage.ToArray());
}
}
public async Task <IActionResult> Translate(TextTranslationRequestModel model)
{
var result = await translatorService.TranslateAsync(model);
return(StatusCode(System.Net.HttpStatusCode.OK, result));
}
private static async Task RunProcess(IHost host, string[] args)
{
var text = string.Empty;
var html = false;
var from = string.Empty;
var isTranslationEachLanguage = false;
var toLanguages = new[] { "en", "ru", "ja" };
// code here
foreach (var arg in args)
{
if (arg.Trim().StartsWith("--"))
{
if (arg.Trim().Equals("--html", StringComparison.OrdinalIgnoreCase))
{
html = true;
}
if (arg.Trim().Equals("--each-language", StringComparison.OrdinalIgnoreCase))
{
isTranslationEachLanguage = true;
}
if (arg.Trim().StartsWith("--from", StringComparison.OrdinalIgnoreCase))
{
var tokens = arg.Split('=');
if (tokens.Length > 1)
{
from = tokens[1];
}
}
if (arg.Trim().StartsWith("--to", StringComparison.OrdinalIgnoreCase))
{
var tokens = arg.Split('=');
if (tokens.Length > 1)
{
var temp = tokens[1];
var tempTokens = temp.Split(',');
if (tempTokens.Length > 0)
{
toLanguages = tempTokens;
}
}
}
}
else
{
var localFileService = host.Services.GetRequiredService <ILocalFileService>();
var environment = host.Services.GetRequiredService <IHostEnvironment>();
var filePath = Path.GetFullPath(arg, environment.ContentRootPath);
//Console.WriteLine($"File: {filePath}");
if (localFileService.Exists(filePath))
{
text = await localFileService.ReadAsync(filePath);
}
}
}
if (string.IsNullOrWhiteSpace(text))
{
Console.WriteLine("Please type to want translation then press a return key (or enter key).");
Console.WriteLine("If want to exit this app, press 'ctrl' + 'c'.");
do
{
Console.WriteLine("Input text:");
text = Console.ReadLine();
}while (string.IsNullOrWhiteSpace(text));
}
var translatorService = host.Services.GetRequiredService <ITextTranslatorService>();
var source = new TextTranslationRequestModel
{
Inputs = new Input[]
{
new Input(text),
},
ToLanguages = toLanguages,
FromLanguage = from,
TextType = html ? TextTypes.Html : TextTypes.Plain,
IsTranslationEachLanguage = isTranslationEachLanguage,
};
try
{
var result = await translatorService.TranslateAsync(source);
Console.WriteLine($"Result: {result.ToJson()}");
}
catch (ApiException ex)
{
Console.WriteLine($"Exception: {ex.Message}");
Console.WriteLine(ex.GetDetails().ToJson());
}
catch (Exception ex)
{
Console.WriteLine($"Exception: {ex.Message}");
}
}
public async Task <IEnumerable <TextTranslationResponseModel> > TranslateAsync(TextTranslationRequestModel model)
{
ValidateAzureTranslateConnectionOptions();
ValidateRequestbody(model);
List <TextTranslationResponseModel> resultSet = null;
var requestBody = SerializeToJson(model.Inputs);
using (var client = new HttpClient())
{
foreach (var uri in getRequestUri(model))
{
using (var request = new HttpRequestMessage())
{
request.Method = HttpMethod.Post;
request.RequestUri = uri;
request.Headers.Add(OCP_APIM_SUBSCRIPTION_KEY, options.SubscriptionKey);
request.Headers.Add(OCP_APIM_SUBSCRIPTION_REGION, options.Region);
request.Content = new StringContent(requestBody, Encoding.UTF8, CONTENT_TYPE_VALUE);
var response = await client.SendAsync(request);
if (response.Content == null)
{
throw new Exception($"{Tag} Response content is empty.");
}
var resultJson = await response.Content.ReadAsStringAsync();
var jsonSerializerOptions = new JsonSerializerOptions
{
PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
};
if (response.IsSuccessStatusCode)
{
var resultModel = JsonSerializer.Deserialize <IEnumerable <Models.TextTranslation.TranslationRequest.TextTranslationResponseModel> >(resultJson, jsonSerializerOptions);
logger.LogInformation($"${Tag} The request has been processed. => Translated.");
if (resultSet == null)
{
resultSet = new List <Models.TextTranslation.TranslationRequest.TextTranslationResponseModel>(resultModel);
}
else
{
var resultModelIndex = 0;
resultModel.ToList().ForEach((result) =>
{
var list = resultSet[resultModelIndex].Translations.ToList();
result.Translations.ToList().ForEach((translation) =>
{
list.Add(translation);
});
resultSet[resultModelIndex].Translations = list;
resultModelIndex++;
});
}
}
else
{
var resultModel = JsonSerializer.Deserialize <ErrorResponseModel>(resultJson, jsonSerializerOptions);
logger.LogInformation($"${Tag} The request does not has been processed. => Not Translated.");
throw new ApiHttpStatusException <ErrorModel <int> >(response.StatusCode, resultModel.Error.Message, resultModel.Error);
}
}
}
}
return(resultSet);
}
