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());
}
public async Task SentimentPercentage(string input)
{
var document = new SentimentDocument()
{
Id = "1",
Text = input,
Language = "en"
};
var request = new SentimentRequest();
request.Documents.Add(document);
var client = new SentimentClient(System.Configuration.ConfigurationManager.AppSettings["apikey"]);
var response = await client.GetSentimentAsync(request);
float sum = 0, average = 0;
foreach (var doc in response.Documents)
{
sum += (doc.Score * 100);
}
average = sum / response.Documents.Count;
WriteNewLine("\n\nSentiment analysis value is {0}", average.ToString());
}
private async void Analyze_Text(object sender, RoutedEventArgs e)
{
this.Score = "";
try
{
var language = await GetLanguage();
var document = new SentimentDocument()
{
Id = Guid.NewGuid().ToString(), Text = this.InputText, Language = language
};
var request = new SentimentRequest();
request.Documents.Add(document);
MainWindow mainWindow = Window.GetWindow(this) as MainWindow;
var client = new SentimentClient(mainWindow._scenariosControl.SubscriptionKey);
MainWindow.Log("Request: Analyzing sentiment.");
var response = await client.GetSentimentAsync(request);
MainWindow.Log("Response: Success. Sentiment analyzed.");
var score = response.Documents[0].Score * 100;
this.Score = string.Format("{0}%", score);
}
catch (Exception ex)
{
MainWindow.Log(ex.Message);
}
}
public IEnumerable <AnalyzedTweet> AnalyzeTweets(IEnumerable <Tweet> tweets)
{
if (_httpClient == null)
{
return(FakeAnalysis(tweets));
}
var request = new SentimentRequest
{
Documents = tweets.Distinct(new TweetEqualityComparer()).Select(tweet => new SentimentRequestDocument {
Id = tweet.Id, Text = tweet.Text
}).ToArray()
};
if (!request.Documents.Any())
{
return(Enumerable.Empty <AnalyzedTweet>());
}
SentimentResponse response = GetAnalysisResponseAsync(request).GetAwaiter().GetResult();
var lookup = request.Documents.ToDictionary(doc => doc.Id, doc => doc.Text);
return(response.Documents.Select(doc => new AnalyzedTweet
{
Id = doc.Id,
Text = lookup[doc.Id],
Sentiment = GetSentiment(doc.Score)
}));
}
private static string GetSentiment(string text)
{
try
{
double score = 0;
var apiKey = "Tu api key de azure cognitive service text"";
var document = new SentimentDocument()
{
Id = "OutlookSergio",
Text = text,
Language = "es"
};
var request = new SentimentRequest();
request.Documents.Add(document);
var client = new SentimentClient(apiKey);
var response = client.GetSentiment(request);
foreach (var doc in response.Documents)
{
score += doc.Score;
}
score = Math.Round((score / response.Documents.Count), 2) * 100;
return score + "%";
}
catch(Exception e)
{
return null;
}
}
private void SetSentitment(Item item)
{
var sentimentService = DependencyResolver.Current.GetService <ISentimentService>();
if (sentimentService == null)
{
return;
}
SentimentRequest sr = new SentimentRequest();
IEnumerable <Field> fields = GetTextualFields(item);
foreach (Field f in fields)
{
sr.Documents.Add(new Document()
{
Text = GetFormattedString(f.Value, 10240),
Id = f.DisplayName
});
}
var result = sentimentService.GetSentiment(sr);
if (result == null)
{
return;
}
Sentiment = result;
}
public async Task <float> MakeRequest(string text)
{
var language = await GetLanguage(text);
var document = new SentimentDocument()
{
Id = Guid.NewGuid().ToString(),
Text = text,
Language = language
};
var request = new SentimentRequest();
request.Documents.Add(document);
var client = new SentimentClient(_subKey)
{
Url = ConfigurationManager.AppSettings["TextSentimentServiceUrl"] + "/sentiment"
};
var response = await client.GetSentimentAsync(request);
var score = response.Documents[0].Score * 100;
return(score);
}
public async Task <double> Sentiment(string text)
{
using (var httpClient = new HttpClient())
{
httpClient.BaseAddress = new Uri("https://westcentralus.api.cognitive.microsoft.com/text/analytics/v2.0");
httpClient.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", WebConfigurationManager.AppSettings["TextAnalyticsApiKey"]);
httpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var sentimentRequest = new SentimentRequest()
{
Documents = new List <SentimentDocument>()
{
new SentimentDocument(text)
}
};
string uri = "/text/analytics/v2.0/sentiment";
var response = await httpClient.PostAsJsonAsync <SentimentRequest>(uri, sentimentRequest);
var responseString = await response.Content.ReadAsStringAsync();
var result = JsonConvert.DeserializeObject <TextAnalyticsResult>(responseString);
if (result.Documents.Length == 1)
{
return(result.Documents[0].Score);
}
return(double.NaN);
}
}
public async Task <float> GetSentimentAnalysisAsync(string text)
{
var client = new SentimentClient(this.Settings.Text.Key1)
{
Url = this.Settings.Text.EndPoint
};
var document = new SentimentDocument
{
Id = Guid.NewGuid().ToString(),
Text = text,
Language = "en"
};
var request = new SentimentRequest
{
Documents = new List <IDocument> {
document
}
};
var response = await client.GetSentimentAsync(request);
// Only one document was sent, therefore only one result should be returned.
var result = response.Documents.FirstOrDefault();
if (result == null)
{
throw new ApplicationException("Text Analysis Failed.");
}
return(result.Score);
}
private async Task MessageReceivedAsync(IDialogContext context, IAwaitable <object> result)
{
var activity = await result as Activity;
var document = new SentimentDocument()
{
Id = "23",
Text = activity.Text,
Language = "en"
};
var request = new SentimentRequest();
request.Documents.Add(document);
var response = await _cognitiveClient.GetSentimentAsync(request);
var retrivedDocument = response.Documents.FirstOrDefault();
var sentimentScore = retrivedDocument.Score;
// calculate something for us to return
int length = (activity.Text ?? string.Empty).Length;
// return our reply to the user
await context.PostAsync($"You sent {activity.Text} which was {length} characters");
context.Wait(MessageReceivedAsync);
}
public static async Task <SentimentResponse> Analyze(string text)
{
const string endpointUrl = "https://westus.api.cognitive.microsoft.com/text/analytics/v2.0/sentiment";
const string apiKey = "f79861a34f1f4f488529a45e40bcdfb2";
var client = new HttpClient
{
DefaultRequestHeaders =
{
{ "Ocp-Apim-Subscription-Key", apiKey },
{ "Accept", "application/json" }
}
};
var sentimentRequest = new SentimentRequest
{
Documents = new List <DocumentRequest>
{
new DocumentRequest {
Id = 1, Text = text
}
}
};
var serializedObject = JsonConvert.SerializeObject(sentimentRequest);
var postRequest = await client.PostAsync(endpointUrl, new StringContent(serializedObject, Encoding.UTF8, "application/json"));
return(JsonConvert.DeserializeObject <SentimentResponse>(await postRequest.Content.ReadAsStringAsync()));
}
public static async Task AnalyzeSentimentAsync(string id, string text, string language)
{
var document = new SentimentDocument()
{
Id = id,
Text = text,
Language = language
};
var client = new SentimentClient(Constants.ApiKey)
{
Url = "https://westeurope.api.cognitive.microsoft.com/text/analytics/v2.0/sentiment"
};
var request = new SentimentRequest();
request.Documents.Add(document);
try
{
var response = await client.GetSentimentAsync(request);
foreach (var doc in response.Documents)
{
Console.WriteLine("Sentiment Score: {0}", doc.Score);
}
}
catch (Exception ex)
{
throw ex;
}
}
static void Main(string[] args)
{
var apiKey = "YOUR-TEXT-ANALYTICS-API-SUBSCRIPTION-KEY";
var document = new SentimentDocument()
{
Id = "YOUR-UNIQUE-ID",
Text = "YOUR-TEXT",
Language = "en"
};
var request = new SentimentRequest();
request.Documents.Add(document);
var client = new SentimentClient(apiKey);
var response = client.GetSentiment(request);
foreach (var doc in response.Documents)
{
Console.WriteLine(" Document Id: {0}", doc.Id);
Console.WriteLine(" Score: {0}%", (doc.Score * 100));
}
Console.WriteLine(" Press any key to exit...");
Console.ReadLine();
}
private async Task <SentimentResult> GetSentiment(SentimentRequest request)
{
var response = await _httpClient.PostAsJsonAsync("sentiment", request);
response.EnsureSuccessStatusCode();
return(await response.Content.ReadAsAsync <SentimentResult>());
}
public async Task <IActionResult> Post([FromBody] SentimentRequest request)
{
if (request == null || string.IsNullOrEmpty(request?.Message))
{
throw new Exception("Bad Request");
}
return(Ok(await _mediator.Send(request)));
}
public async Task <IActionResult> Post([FromBody] SentimentRequest request)
{
if (request == null)
{
return(NotFound());
}
return(Ok(await _mediator.Send(request)));
}
public IActionResult GetResult([FromBody] SentimentRequest request)
{
var results = new Dictionary <string, TrackingResult[]>();
for (int i = 0; i < request.Keywords.Length; i++)
{
results[request.Keywords[i]] = GetSingle(request.Keywords[i], request.Type, request.Hours);
}
return(Ok(results));
}
/// <summary>
/// Api call to determine the sentiment of the user input
/// </summary>
/// <param name="text">user input</param>
public virtual SentimentResponse GetSentiment(string text)
{
var sr = new SentimentRequest();
sr.Documents.Add(new Document()
{
Text = text, Id = "Ole"
});
return(TextAnalyticsService.GetSentiment(sr));
}
public IHttpActionResult Sentiment(SentimentRequest sentimentRequest)
{
if (this.Request.Method == HttpMethod.Options)
{
return(new OptionsOkResult());
}
Sentiment result =
this.textAnalize.Sentiment(sentimentRequest.Url, sentimentRequest.Text, sentimentRequest.Mode, sentimentRequest.Language);
return(Ok(result));
}
public void Validate_InvalidLanguage()
{
var text = "I had a wonderful experience! The rooms were wonderful and the staff were helpful.";
var doc = new SentimentDocument()
{
Id = "TEST001", Text = text, Language = "ja"
};
var request = new SentimentRequest();
request.Documents.Add(doc);
request.Validate();
}
public IActionResult GetResultHistory([FromBody] SentimentRequest request)
{
var hours = request.Hours.Max();
var results = new Dictionary <string, RatingRecord[]>();
for (int i = 0; i < request.Keywords.Length; i++)
{
results[request.Keywords[i]] = GetSingleHistory(request.Keywords[i], request.Type, hours);
}
return(Ok(results));
}
public virtual KeyPhraseSentimentResponse GetKeyPhrases(SentimentRequest request)
{
return(PolicyService.ExecuteRetryAndCapture400Errors(
"TextAnalyticsService.GetKeyPhrases",
ApiKeys.TextAnalyticsRetryInSeconds,
() =>
{
var result = TextAnalyticsRepository.GetKeyPhrases(request);
return result;
},
null));
}
public static float AnalyzeSentiment(string id, string text, string language)
{
float score = 0;
var document = new SentimentDocument()
{
Id = id,
Text = text,
Language = language
};
var client = new SentimentClient(Constants.ApiKey)
{
Url = "https://westeurope.api.cognitive.microsoft.com/text/analytics/v2.0/sentiment"
};
var request = new SentimentRequest();
request.Documents.Add(document);
try
{
var response = client.GetSentiment(request);
score = response.Documents.First().Score * 100;
}
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(score);
}
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;
}
}
static void Main(string[] args)
{
// MS Cognitive Services API key
var apiKeyTextAnalytics = "REPLACE_WITH_API_KEY";
var text = @"A thing of beauty is a joy for ever:
Its loveliness increases; it will never
Pass into nothingness; but still will keep
A bower quiet for us, and a sleep
Full of sweet dreams, and health, and quiet breathing.";
// GET text sentiment
var sentimentDocument = new SentimentDocument()
{
Id = "Sentiment",
Text = text,
Language = "en"
};
Console.WriteLine("Analyzing {0}", sentimentDocument.Id + "..");
var sentimentRequest = new SentimentRequest();
sentimentRequest.Documents.Add(sentimentDocument);
var sentimentClient = new SentimentClient(apiKeyTextAnalytics);
var sentimentResponse = sentimentClient.GetSentiment(sentimentRequest);
Console.WriteLine(" Score: {0}%", (sentimentResponse.Documents[0].Score * 100) + " [0% - negative, 100% - positive]");
// GET text keyphrases
var keyPhraseDocument = new KeyPhraseDocument()
{
Id = "KeyPhrases",
Text = text,
Language = "en"
};
Console.WriteLine("Recognizing {0}", keyPhraseDocument.Id + "..");
var keyPhraseRequest = new KeyPhraseRequest();
keyPhraseRequest.Documents.Add(keyPhraseDocument);
var keyPhraseClient = new KeyPhraseClient(apiKeyTextAnalytics);
var keyPhraseResponse = keyPhraseClient.GetKeyPhrases(keyPhraseRequest);
foreach (var keyPhrase in keyPhraseResponse.Documents[0].KeyPhrases)
{
Console.WriteLine(" KeyPhrase: {0}", keyPhrase);
}
}
public ActionResult Sentiment(string text)
{
var sr = new SentimentRequest();
sr.Documents.Add(new Document()
{
Text = text,
Id = "Sample Text"
});
var result = SentimentService.GetSentiment(sr);
return(View("Sentiment", result));
}
private async Task <double> GetSentimentScore(string inputText)
{
var score = 0.0;
var apiUri = "https://westus.api.cognitive.microsoft.com/text/analytics/v2.0/sentiment";
var apikey = "c1715e2472b04c1e99ad75ee6a459d64";
//setup HttpClient with content
var client = new HttpClient();
// Request headers
client.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", apikey);
// Request body
var sentmentRequestDocument = new SentimentRequestDocument()
{
language = "en",
id = "87",
text = inputText
};
var sentmentRequestDocuments = new List <SentimentRequestDocument>();
sentmentRequestDocuments.Add(sentmentRequestDocument);
var requestModel = new SentimentRequest()
{
documents = sentmentRequestDocuments
};
var requestBodyString = JsonConvert.SerializeObject(requestModel);
byte[] byteData = Encoding.UTF8.GetBytes(requestBodyString);
using (var content = new ByteArrayContent(byteData))
{
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
var response = await client.PostAsync(apiUri, content);
if (response.IsSuccessStatusCode)
{
var responseData = await response.Content.ReadAsStringAsync();
var sentimentResponse = JsonConvert.DeserializeObject <SentimentResponse>(responseData);
score = sentimentResponse.documents.FirstOrDefault().score;
}
else
{
score = 0.0;
}
}
return(score);
}
public void TestInvalidRequestContent()
{
var input = new SentimentRequest();
var resp = _subject.PostRequest <SentimentResponse, SentimentRequest>(input, "/v1/sentiment", new AnalysisCell {
Address = "A1", Text = input.text
});
resp.Wait();
Assert.IsNotNull(resp.Result);
Assert.IsFalse(resp.Result.Success);
Assert.IsNotNull(resp.Result.ErrorMessage);
Assert.IsTrue(resp.Result.ErrorMessage.Contains("400"));
}
public virtual KeyPhraseSentimentResponse GetKeyPhrases(SentimentRequest request)
{
try
{
var result = Task.Run(async() => await SentimentRepository.GetKeyPhrasesAsync(request)).Result;
return(result);
}
catch (Exception ex)
{
Logger.Error("SentimentService.GetKeyPhrasesAsync failed", this, ex);
}
return(null);
}
public virtual KeyPhraseSentimentResponse GetKeyPhrases(SentimentRequest request)
{
try
{
var result = TextAnalyticsRepository.GetKeyPhrases(request);
return(result);
}
catch (Exception ex)
{
Logger.Error("SentimentService.GetKeyPhrasesAsync failed", this, ex);
}
return(null);
}
