public static async Task AnalyzeLanguageAsync(string id, string text)
{
var document = new Document()
{
Id = id,
Text = text
};
var client = new LanguageClient(Constants.ApiKey)
{
Url = "https://westeurope.api.cognitive.microsoft.com/text/analytics/v2.0/languages"
};
var request = new LanguageRequest();
request.Documents.Add(document);
try
{
var response = await client.GetLanguagesAsync(request);
foreach (var doc in response.Documents)
{
foreach (var language in doc.DetectedLanguages)
{
Console.WriteLine("The language is: {0} and the confidence is: {1}%", language.Name, language.Score * 100);
}
}
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <AnalyzedText[]> AnalyzeTextAsync(IEnumerable <Document> documents)
{
var documentList = documents.ToList();
var documentDic = documentList.ToDictionary(d => d.Id);
var languageRequest = new LanguageRequest {
Documents = documentList
};
var languageResult = await GetLanguages(languageRequest);
var languageDocumentDic = languageResult.Documents.ToDictionary(ld => ld.Id);
var sentimentRequest = new SentimentRequest
{
Documents = languageResult.Documents.Select(ld => new SentimentRequestDocument
{
Id = ld.Id,
Text = documentDic[ld.Id].Text,
Language = ld.DetectedLanguages.First().Iso6391Name
}).ToList()
};
var sentimentResult = await GetSentiment(sentimentRequest);
return(sentimentResult.Documents.Select(sd => new AnalyzedText
{
Id = sd.Id,
Text = documentDic[sd.Id].Text,
Language = languageDocumentDic[sd.Id].DetectedLanguages.First().Name,
Sentiment = sd.Score
})
.ToArray());
}
/// <summary>
/// Change Language informations.
/// </summary>
/// <param name="request">language request.</param>
/// <returns>Language message.</returns>
public LanguageMessage UpdateLanguage(LanguageRequest request)
{
LanguageMessage message = new LanguageMessage();
try
{
request.FindLanguageDto = FindLanguageDto.LanguageId;
LanguageResponsePivot findMessage = _serviceLanguage.FindLanguages(request.ToPivot());
if (findMessage?.LanguagePivot == null)
{
message.ErrorMessage = LanguageMessageResource.NotFound;
message.OperationSuccess = false;
}
else
{
_serviceLanguage.UpdateLanguage(request.ToPivot());
message.OperationSuccess = true;
}
}
catch (Exception e)
{
message.ErrorType = ErrorType.TechnicalError;
message.ErrorMessage = e.Message;
}
return(message);
}
public IHttpActionResult DeleteLanguage(int languageId)
{
LanguageRequest request = new LanguageRequest
{
LanguageDto = new LanguageDto {
LanguageId = languageId
}
};
List <string> errors = ValidateDeleteLanguage(request);
LanguageMessage message = new LanguageMessage();
if (errors != null && errors.Any())
{
message.ErrorMessage = LanguageMessageResource.ValidationErrors;
message.ErrorType = ErrorType.ValidationError;
message.Errors = new List <string>();
message.OperationSuccess = false;
message.Errors.AddRange(errors);
}
else
{
message = _serviceLanguageClient.DeleteLanguage(request);
}
return(Json(message));
}
public void GetLanguagesTest_TwoLangages()
{
var doc01 = new Document()
{
Id = "TEST001", Text = "Hello my friend."
};
var doc02 = new Document()
{
Id = "TEST002", Text = "Hola mi amigo"
};
var request = new LanguageRequest();
request.NumberOfLanguagesToDetect = 2;
request.Documents.Add(doc01);
request.Documents.Add(doc02);
var client = new LanguageClient(this.apiKey);
var response = client.GetLanguages(request);
Assert.AreEqual("en", response.Documents[0].DetectedLanguages[0].Iso639Name);
Assert.AreEqual("English", response.Documents[0].DetectedLanguages[0].Name);
Assert.AreEqual(1.0, response.Documents[0].DetectedLanguages[0].Score);
Assert.AreEqual("es", response.Documents[1].DetectedLanguages[0].Iso639Name);
Assert.AreEqual("Spanish", response.Documents[1].DetectedLanguages[0].Name);
Assert.AreEqual(1.0, response.Documents[1].DetectedLanguages[0].Score);
}
private static void GetLanguages()
{
var client = new LanguageClient(apiKey);
var request = new LanguageRequest();
var document = new Document()
{
Id = "YOUR-UNIQUE-ID",
Text = "YOUR-TEXT"
};
var response = client.GetLanguages(request);
foreach (var doc in response.Documents)
{
Console.WriteLine("Document Id: {0}", doc.Id);
foreach (var lang in doc.DetectedLanguages)
{
Console.WriteLine("--Language: {0}({1})", lang.Name, lang.Iso639Name);
Console.WriteLine("--Confidence: {0}%", (lang.Score * 100));
}
}
request.Documents.Add(document);
}
private async void Analyze_Text(object sender, RoutedEventArgs e)
{
this.LanguageName = "";
this.Confidence = "";
try
{
var document = new Document()
{
Id = Guid.NewGuid().ToString(), Text = this.InputText
};
var request = new LanguageRequest();
request.Documents.Add(document);
MainWindow mainWindow = Window.GetWindow(this) as MainWindow;
var client = new LanguageClient(mainWindow._scenariosControl.SubscriptionKey);
MainWindow.Log("Request: Identifying language.");
var response = await client.GetLanguagesAsync(request);
MainWindow.Log("Response: Success. Language identified.");
this.LanguageName = string.Format("{0} ({1})", response.Documents[0].DetectedLanguages[0].Name, response.Documents[0].DetectedLanguages[0].Iso639Name);
var confidence = response.Documents[0].DetectedLanguages[0].Score * 100;
this.Confidence = string.Format("{0}%", confidence);
}
catch (Exception ex)
{
MainWindow.Log(ex.Message);
}
}
private async Task <LanguageResult> GetLanguages(LanguageRequest request)
{
var response = await _httpClient.PostAsJsonAsync("languages", request);
response.EnsureSuccessStatusCode();
return(await response.Content.ReadAsAsync <LanguageResult>());
}
/// <summary>
/// From Language Request to Language Request pivot.
/// </summary>
/// <param name="languageRequest">the request to assemble.</param>
/// <returns>Language Request pivot result.</returns>
public static LanguageRequestPivot ToPivot(this LanguageRequest languageRequest)
{
return(new LanguageRequestPivot
{
LanguagePivot = languageRequest.LanguageDto.ToPivot(),
FindLanguagePivot = Utility.EnumToEnum <FindLanguageDto, FindLanguagePivot>(languageRequest.FindLanguageDto)
});
}
public void AppTask_Controller_Put_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
AppTaskController appTaskController = new AppTaskController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(appTaskController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, appTaskController.DatabaseType);
AppTask appTaskLast = new AppTask();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
AppTaskService appTaskService = new AppTaskService(query, db, ContactID);
appTaskLast = (from c in db.AppTasks select c).FirstOrDefault();
}
// ok with AppTask info
IHttpActionResult jsonRet = appTaskController.GetAppTaskWithID(appTaskLast.AppTaskID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <AppTask> Ret = jsonRet as OkNegotiatedContentResult <AppTask>;
AppTask appTaskRet = Ret.Content;
Assert.AreEqual(appTaskLast.AppTaskID, appTaskRet.AppTaskID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Put to return success
IHttpActionResult jsonRet2 = appTaskController.Put(appTaskRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <AppTask> appTaskRet2 = jsonRet2 as OkNegotiatedContentResult <AppTask>;
Assert.IsNotNull(appTaskRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest2);
// Put to return CSSPError because AppTaskID of 0 does not exist
appTaskRet.AppTaskID = 0;
IHttpActionResult jsonRet3 = appTaskController.Put(appTaskRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
OkNegotiatedContentResult <AppTask> appTaskRet3 = jsonRet3 as OkNegotiatedContentResult <AppTask>;
Assert.IsNull(appTaskRet3);
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest3);
}
}
}
public void Log_Controller_Put_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
LogController logController = new LogController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(logController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, logController.DatabaseType);
Log logLast = new Log();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
LogService logService = new LogService(query, db, ContactID);
logLast = (from c in db.Logs select c).FirstOrDefault();
}
// ok with Log info
IHttpActionResult jsonRet = logController.GetLogWithID(logLast.LogID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <Log> Ret = jsonRet as OkNegotiatedContentResult <Log>;
Log logRet = Ret.Content;
Assert.AreEqual(logLast.LogID, logRet.LogID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Put to return success
IHttpActionResult jsonRet2 = logController.Put(logRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <Log> logRet2 = jsonRet2 as OkNegotiatedContentResult <Log>;
Assert.IsNotNull(logRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest2);
// Put to return CSSPError because LogID of 0 does not exist
logRet.LogID = 0;
IHttpActionResult jsonRet3 = logController.Put(logRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
OkNegotiatedContentResult <Log> logRet3 = jsonRet3 as OkNegotiatedContentResult <Log>;
Assert.IsNull(logRet3);
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest3);
}
}
}
public void VPResult_Controller_Put_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
VPResultController vpResultController = new VPResultController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(vpResultController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, vpResultController.DatabaseType);
VPResult vpResultLast = new VPResult();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
VPResultService vpResultService = new VPResultService(query, db, ContactID);
vpResultLast = (from c in db.VPResults select c).FirstOrDefault();
}
// ok with VPResult info
IHttpActionResult jsonRet = vpResultController.GetVPResultWithID(vpResultLast.VPResultID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <VPResult> Ret = jsonRet as OkNegotiatedContentResult <VPResult>;
VPResult vpResultRet = Ret.Content;
Assert.AreEqual(vpResultLast.VPResultID, vpResultRet.VPResultID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Put to return success
IHttpActionResult jsonRet2 = vpResultController.Put(vpResultRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <VPResult> vpResultRet2 = jsonRet2 as OkNegotiatedContentResult <VPResult>;
Assert.IsNotNull(vpResultRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest2);
// Put to return CSSPError because VPResultID of 0 does not exist
vpResultRet.VPResultID = 0;
IHttpActionResult jsonRet3 = vpResultController.Put(vpResultRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
OkNegotiatedContentResult <VPResult> vpResultRet3 = jsonRet3 as OkNegotiatedContentResult <VPResult>;
Assert.IsNull(vpResultRet3);
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest3);
}
}
}
public void BoxModel_Controller_Put_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
BoxModelController boxModelController = new BoxModelController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(boxModelController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, boxModelController.DatabaseType);
BoxModel boxModelLast = new BoxModel();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
BoxModelService boxModelService = new BoxModelService(query, db, ContactID);
boxModelLast = (from c in db.BoxModels select c).FirstOrDefault();
}
// ok with BoxModel info
IHttpActionResult jsonRet = boxModelController.GetBoxModelWithID(boxModelLast.BoxModelID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <BoxModel> Ret = jsonRet as OkNegotiatedContentResult <BoxModel>;
BoxModel boxModelRet = Ret.Content;
Assert.AreEqual(boxModelLast.BoxModelID, boxModelRet.BoxModelID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Put to return success
IHttpActionResult jsonRet2 = boxModelController.Put(boxModelRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <BoxModel> boxModelRet2 = jsonRet2 as OkNegotiatedContentResult <BoxModel>;
Assert.IsNotNull(boxModelRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest2);
// Put to return CSSPError because BoxModelID of 0 does not exist
boxModelRet.BoxModelID = 0;
IHttpActionResult jsonRet3 = boxModelController.Put(boxModelRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
OkNegotiatedContentResult <BoxModel> boxModelRet3 = jsonRet3 as OkNegotiatedContentResult <BoxModel>;
Assert.IsNull(boxModelRet3);
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest3);
}
}
}
public void TVItem_Controller_Put_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
TVItemController tvItemController = new TVItemController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(tvItemController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, tvItemController.DatabaseType);
TVItem tvItemLast = new TVItem();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
TVItemService tvItemService = new TVItemService(query, db, ContactID);
tvItemLast = (from c in db.TVItems select c).LastOrDefault();
}
// ok with TVItem info
IHttpActionResult jsonRet = tvItemController.GetTVItemWithID(tvItemLast.TVItemID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <TVItem> Ret = jsonRet as OkNegotiatedContentResult <TVItem>;
TVItem tvItemRet = Ret.Content;
Assert.AreEqual(tvItemLast.TVItemID, tvItemRet.TVItemID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Put to return success
IHttpActionResult jsonRet2 = tvItemController.Put(tvItemRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <TVItem> tvItemRet2 = jsonRet2 as OkNegotiatedContentResult <TVItem>;
Assert.IsNotNull(tvItemRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest2);
// Put to return CSSPError because TVItemID of 0 does not exist
tvItemRet.TVItemID = 0;
IHttpActionResult jsonRet3 = tvItemController.Put(tvItemRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
OkNegotiatedContentResult <TVItem> tvItemRet3 = jsonRet3 as OkNegotiatedContentResult <TVItem>;
Assert.IsNull(tvItemRet3);
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest3);
}
}
}
public void HelpDoc_Controller_Put_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
HelpDocController helpDocController = new HelpDocController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(helpDocController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, helpDocController.DatabaseType);
HelpDoc helpDocLast = new HelpDoc();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
HelpDocService helpDocService = new HelpDocService(query, db, ContactID);
helpDocLast = (from c in db.HelpDocs select c).FirstOrDefault();
}
// ok with HelpDoc info
IHttpActionResult jsonRet = helpDocController.GetHelpDocWithID(helpDocLast.HelpDocID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <HelpDoc> Ret = jsonRet as OkNegotiatedContentResult <HelpDoc>;
HelpDoc helpDocRet = Ret.Content;
Assert.AreEqual(helpDocLast.HelpDocID, helpDocRet.HelpDocID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Put to return success
IHttpActionResult jsonRet2 = helpDocController.Put(helpDocRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <HelpDoc> helpDocRet2 = jsonRet2 as OkNegotiatedContentResult <HelpDoc>;
Assert.IsNotNull(helpDocRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest2);
// Put to return CSSPError because HelpDocID of 0 does not exist
helpDocRet.HelpDocID = 0;
IHttpActionResult jsonRet3 = helpDocController.Put(helpDocRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
OkNegotiatedContentResult <HelpDoc> helpDocRet3 = jsonRet3 as OkNegotiatedContentResult <HelpDoc>;
Assert.IsNull(helpDocRet3);
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest3);
}
}
}
public List <Language> AddLanguage(LanguageRequest request)
{
Language lang = new Language();
lang.Name = request.title;
_db.Language.Add(lang);
_db.SaveChanges();
return(_db.Language.ToList());
}
public void MWQMSite_Controller_Put_Test()
{
foreach (LanguageEnum LanguageRequest in AllowableLanguages)
{
foreach (int ContactID in new List <int>()
{
AdminContactID
}) //, TestEmailValidatedContactID, TestEmailNotValidatedContactID })
{
MWQMSiteController mwqmSiteController = new MWQMSiteController(DatabaseTypeEnum.SqlServerTestDB);
Assert.IsNotNull(mwqmSiteController);
Assert.AreEqual(DatabaseTypeEnum.SqlServerTestDB, mwqmSiteController.DatabaseType);
MWQMSite mwqmSiteLast = new MWQMSite();
using (CSSPDBContext db = new CSSPDBContext(DatabaseType))
{
Query query = new Query();
query.Language = LanguageRequest;
MWQMSiteService mwqmSiteService = new MWQMSiteService(query, db, ContactID);
mwqmSiteLast = (from c in db.MWQMSites select c).FirstOrDefault();
}
// ok with MWQMSite info
IHttpActionResult jsonRet = mwqmSiteController.GetMWQMSiteWithID(mwqmSiteLast.MWQMSiteID);
Assert.IsNotNull(jsonRet);
OkNegotiatedContentResult <MWQMSite> Ret = jsonRet as OkNegotiatedContentResult <MWQMSite>;
MWQMSite mwqmSiteRet = Ret.Content;
Assert.AreEqual(mwqmSiteLast.MWQMSiteID, mwqmSiteRet.MWQMSiteID);
BadRequestErrorMessageResult badRequest = jsonRet as BadRequestErrorMessageResult;
Assert.IsNull(badRequest);
// Put to return success
IHttpActionResult jsonRet2 = mwqmSiteController.Put(mwqmSiteRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet2);
OkNegotiatedContentResult <MWQMSite> mwqmSiteRet2 = jsonRet2 as OkNegotiatedContentResult <MWQMSite>;
Assert.IsNotNull(mwqmSiteRet2);
BadRequestErrorMessageResult badRequest2 = jsonRet2 as BadRequestErrorMessageResult;
Assert.IsNull(badRequest2);
// Put to return CSSPError because MWQMSiteID of 0 does not exist
mwqmSiteRet.MWQMSiteID = 0;
IHttpActionResult jsonRet3 = mwqmSiteController.Put(mwqmSiteRet, LanguageRequest.ToString());
Assert.IsNotNull(jsonRet3);
OkNegotiatedContentResult <MWQMSite> mwqmSiteRet3 = jsonRet3 as OkNegotiatedContentResult <MWQMSite>;
Assert.IsNull(mwqmSiteRet3);
BadRequestErrorMessageResult badRequest3 = jsonRet3 as BadRequestErrorMessageResult;
Assert.IsNotNull(badRequest3);
}
}
}
public virtual LanguageResponse GetLanguages(LanguageRequest request)
{
return(PolicyService.ExecuteRetryAndCapture400Errors(
"TextAnalyticsService.GetLanguages",
ApiKeys.TextAnalyticsRetryInSeconds,
() =>
{
var result = TextAnalyticsRepository.GetLanguages(request);
return result;
},
null));
}
public virtual LanguageResponse GetLanguages(LanguageRequest request)
{
try {
var result = TextAnalyticsRepository.GetLanguages(request);
return(result);
} catch (Exception ex) {
Logger.Error("LanguageService.GetLanguages failed", this, ex);
}
return(null);
}
public virtual LanguageResponse GetLanguages(LanguageRequest request)
{
try {
var result = Task.Run(async() => await LanguageRepository.GetLanguagesAsync(request)).Result;
return(result);
} catch (Exception ex) {
Logger.Error("LanguageService.GetLanguages failed", this, ex);
}
return(null);
}
public static DetectedLanguage AnalyzeLanguage(string id, string text)
{
DetectedLanguage language = new DetectedLanguage();
var document = new Document()
{
Id = id,
Text = text
};
var client = new LanguageClient(Constants.ApiKey)
{
Url = "https://westeurope.api.cognitive.microsoft.com/text/analytics/v2.0/languages"
};
var request = new LanguageRequest();
request.Documents.Add(document);
try
{
var response = client.GetLanguages(request);
language = response.Documents.First().DetectedLanguages.First();
}
catch (Exception ex)
{
var message = "";
var innerMessage = "";
if (!String.IsNullOrEmpty(ex.Message))
{
message = ex.Message;
}
try
{
if ((ex.InnerException != null) && (!String.IsNullOrEmpty(ex.InnerException.Message)))
{
innerMessage = ex.InnerException.Message;
}
}
catch (Exception innerEx)
{
if ((innerEx.InnerException != null) && (!String.IsNullOrEmpty(innerEx.InnerException.Message)))
{
innerMessage = innerEx.InnerException.Message;
}
}
Console.WriteLine(String.Format("Error in AnalyzeSentiment: {0}:{1}", message, innerMessage));
}
return(language);
}
public static DetectedLanguage AnalyzeLanguage(string id, string text)
{
DetectedLanguage language = new DetectedLanguage();
var document = new Document()
{
Id = id,
Text = text
};
var client = new LanguageClient(Constants.API_KEY)
{
Url = Constants.API_URI_LANG
};
var request = new LanguageRequest();
request.Documents.Add(document);
try
{
var response = client.GetLanguages(request);
language = response.Documents.First().DetectedLanguages.First();
}
catch (Exception ex)
{
var message = "";
var innerMessage = "";
if (!String.IsNullOrEmpty(ex.Message))
{
message = ex.Message;
}
try
{
if ((ex.InnerException != null) && (!String.IsNullOrEmpty(ex.InnerException.Message)))
{
innerMessage = ex.InnerException.Message;
}
}
catch (Exception innerEx)
{
if ((innerEx.InnerException != null) && (!String.IsNullOrEmpty(innerEx.InnerException.Message)))
{
innerMessage = innerEx.InnerException.Message;
}
}
//Console.WriteLine(String.Format("Error in AnalyzeSentiment: {0}:{1}", message, innerMessage));
}
return(language);
}
/// <summary>
/// Validate delete Language.
/// </summary>
/// <param name="request">the request attribute to validate</param>
/// <returns>errors validation</returns>
private List <string> ValidateDeleteLanguage(LanguageRequest request)
{
var errors = new List <string>();
if (request?.LanguageDto == null)
{
errors.Add(LanguageMessageResource.NullRequest);
}
else
{
errors.AddRange(GenericValidationAttribute <LanguageDto> .ValidateAttributes("LanguageId", request.LanguageDto.LanguageId.ToString()));
}
return(errors);
}
public ActionResult Language(string text)
{
LanguageRequest lr = new LanguageRequest();
lr.Documents.Add(new Document()
{
Text = text,
Id = "Sample Text"
});
var result = LanguageService.GetLanguages(lr);
return(View("Language", result));
}
async Task ExecuteCheckTextAnalyticsApiCommand()
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
LanguageClient languageClient = new LanguageClient(ApiKeys.TextAnalyticsApiKey);
languageClient.Url = "https://westeurope.api.cognitive.microsoft.com/text/analytics/v2.0/languages";
LanguageRequest lr = new LanguageRequest();
lr.Documents.Add(new Document()
{
Id = Guid.NewGuid().ToString(),
Text = TextAnalyticsText
});
var lrResult = await languageClient.GetLanguagesAsync(lr);
var language = lrResult.Documents.First().DetectedLanguages.First().Name;
var languageCode = lrResult.Documents.First().DetectedLanguages.First().Iso639Name;
SentimentClient textClient = new SentimentClient(ApiKeys.TextAnalyticsApiKey);
textClient.Url = "https://westeurope.api.cognitive.microsoft.com/text/analytics/v2.0/sentiment";
SentimentRequest sr = new SentimentRequest();
sr.Documents.Add(new SentimentDocument()
{
Id = Guid.NewGuid().ToString(),
Text = TextAnalyticsText,
Language = languageCode
});
var result = await textClient.GetSentimentAsync(sr);
TextAnalyticsResult = $"Language: {language}, Sentiment Score: {result.Documents.First().Score}";
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
}
/// <summary>
/// Create new Language
/// </summary>
/// <param name="request">language request.</param>
/// <returns>Language message.</returns>
public LanguageMessage CreateLanguage(LanguageRequest request)
{
LanguageMessage message = new LanguageMessage();
try
{
message = _serviceLanguage.CreateLanguage(request.ToPivot()).ToMessage();
message.OperationSuccess = true;
}
catch (Exception e)
{
message.ErrorType = ErrorType.TechnicalError;
message.ErrorMessage = e.Message;
}
return(message);
}
public void GetLanguagesTest_OneLangage()
{
var doc01 = new Document()
{
Id = "TEST001", Text = "Hello my friend"
};
var request = new LanguageRequest();
request.Documents.Add(doc01);
var client = new LanguageClient(this.apiKey);
var response = client.GetLanguages(request);
Assert.AreEqual("en", response.Documents[0].DetectedLanguages[0].Iso639Name);
Assert.AreEqual("English", response.Documents[0].DetectedLanguages[0].Name);
Assert.AreEqual(1.0, response.Documents[0].DetectedLanguages[0].Score);
}
public IHttpActionResult UpdateLanguage(LanguageRequest request)
{
var errors = ValidateUpdateLanguage(request);
var message = new LanguageMessage();
if (errors != null && errors.Any())
{
message.ErrorMessage = LanguageMessageResource.ValidationErrors;
message.ErrorType = ErrorType.ValidationError;
message.Errors = new List <string>();
message.OperationSuccess = false;
message.Errors.AddRange(errors);
}
else
{
message = _serviceLanguageClient.UpdateLanguage(request);
}
return(Json(message));
}
private static async Task RunLanguageIdentification()
{
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine("Begining language identification ({0})", DateTime.Now.ToString());
foreach (var conversation in conversations)
{
var client = new LanguageClient(textAnalyticsApiKey);
foreach (var message in conversation.Messages)
{
try
{
var document = new Document()
{
Id = message.Id.ToString(),
Text = message.Text
};
var request = new LanguageRequest();
request.Documents.Add(document);
var response = await client.GetLanguagesAsync(request);
message.Metadata.LanguageName = response.Documents[0].DetectedLanguages[0].Iso639Name;
message.Metadata.LanguageConfidenceScore = response.Documents[0].DetectedLanguages[0].Score;
Console.Write("Conversation {0} | Message {1} | Language {2}", conversation.Id, message.Id, message.Metadata.LanguageName);
}
catch (Exception ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine();
Console.WriteLine("Exception encountered ({0})", DateTime.Now.ToString());
Console.WriteLine("Conversation {0} | Message {1}", conversation.Id, message.Id);
Console.WriteLine(ex.Message);
}
}
Console.WriteLine("Language identification complete ({0})", DateTime.Now.ToString());
Console.WriteLine();
}
}
private async Task <string> GetLanguage(string text)
{
var document = new Document()
{
Id = Guid.NewGuid().ToString(), Text = text
};
var request = new LanguageRequest();
request.Documents.Add(document);
var client = new LanguageClient(_subKey)
{
Url = ConfigurationManager.AppSettings["TextSentimentServiceUrl"] + "/languages"
};
var response = await client.GetLanguagesAsync(request);
return(response.Documents[0].DetectedLanguages[0].Iso639Name);
}
