public async Task <Response <EntitiesResult> > EntitiesRecognitionGeneralAsync(MultiLanguageBatchInput input, string modelVersion = null, bool?showStats = null, CancellationToken cancellationToken = default)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
using var message = CreateEntitiesRecognitionGeneralRequest(input, modelVersion, showStats);
await _pipeline.SendAsync(message, cancellationToken).ConfigureAwait(false);
switch (message.Response.Status)
{
case 200:
{
EntitiesResult value = default;
using var document = await JsonDocument.ParseAsync(message.Response.ContentStream, default, cancellationToken).ConfigureAwait(false);
if (document.RootElement.ValueKind == JsonValueKind.Null)
{
value = null;
}
else
{
value = EntitiesResult.DeserializeEntitiesResult(document.RootElement);
}
return(Response.FromValue(value, message.Response));
}
internal static EntityRecognitionTasksItem DeserializeEntityRecognitionTasksItem(JsonElement element)
{
EntitiesResult results = default;
DateTimeOffset lastUpdateDateTime = default;
Optional <string> name = default;
JobStatus status = default;
foreach (var property in element.EnumerateObject())
{
if (property.NameEquals("results"))
{
results = EntitiesResult.DeserializeEntitiesResult(property.Value);
continue;
}
if (property.NameEquals("lastUpdateDateTime"))
{
lastUpdateDateTime = property.Value.GetDateTimeOffset("O");
continue;
}
if (property.NameEquals("name"))
{
name = property.Value.GetString();
continue;
}
if (property.NameEquals("status"))
{
status = new JobStatus(property.Value.GetString());
continue;
}
}
return(new EntityRecognitionTasksItem(lastUpdateDateTime, name.Value, status, results));
}
private async Task <EntitiesResult <AccountType> > SetIsActive(List <int> ids, ActionArguments args, bool isActive)
{
await Initialize();
// Check user permissions
var action = "IsActive";
var actionFilter = await UserPermissionsFilter(action, cancellation : default);
ids = await CheckActionPermissionsBefore(actionFilter, ids);
// Execute and return
using var trx = TransactionFactory.ReadCommitted();
OperationOutput output = await _behavior.Repository.AccountTypes__Activate(
ids : ids,
isActive : isActive,
validateOnly : ModelState.IsError,
top : ModelState.RemainingErrors,
userId : UserId);
AddErrorsAndThrowIfInvalid(output.Errors);
var result = (args.ReturnEntities ?? false) ?
await GetByIds(ids, args, action, cancellation : default) :
EntitiesResult <AccountType> .Empty();
// Check user permissions again
await CheckActionPermissionsAfter(actionFilter, ids, result.Data);
trx.Complete();
return(result);
}
static void SaveArtResults(SemtimentData _ArtData, SemtimentResult _ArtSent, EntitiesResult _ArtEnt)
{
List <QuickTypeSemtimentData.Document> list = new List <QuickTypeSemtimentData.Document>();
SemtimentData _AzData = new SemtimentData();
int i = 0;
foreach (QuickTypeSemtimentResult.Document doc in _ArtSent.Documents)
{
if (doc.Score < .3)
{
saveToDB(doc.Id.ToString(), _ArtData.Documents[i].Text, "Negative", _ArtEnt.Documents[i]);
}
else
{
if (doc.Score > .7)
{
saveToDB(doc.Id.ToString(), _ArtData.Documents[i].Text, "Positive", _ArtEnt.Documents[i]);
}
else
{
saveToDB(doc.Id.ToString(), _ArtData.Documents[i].Text, "Nuetral", _ArtEnt.Documents[i]);
}
}
i++;
}
}
public EntitiesResult ProcessEntities(string documentid, string text)
{
TextAnalyticsClient client = AuthenticateTextAnalytics(_azureRegion, _textAnalyticsKey);
EntitiesResult result = client.Entities(text);
return(result);
}
internal EntityRecognitionTasksItem(DateTimeOffset lastUpdateDateTime, string name, JobStatus status, EntitiesResult results) : base(lastUpdateDateTime, name, status)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
Results = results;
}
protected override Task OnSuccessfulSave(EntitiesResult <EmailTemplate> data)
{
if (data?.Data != null && data.Data.Any(e => e.IsDeployed ?? false))
{
Response.Headers.Set("x-definitions-version", Constants.Stale);
}
return(base.OnSuccessfulSave(data));
}
internal EntityRecognitionTasksItem(DateTimeOffset lastUpdateDateTime, TextAnalyticsOperationStatus status, EntitiesResult resultsInternal) : base(lastUpdateDateTime, status)
{
if (resultsInternal == null)
{
throw new ArgumentNullException(nameof(resultsInternal));
}
ResultsInternal = resultsInternal;
}
protected override async Task OnSuccessfulSave(EntitiesResult <AdminUser> result)
{
if (result.Data != null && result.Data.Any(e => e.Id == _service.UserId))
{
Response.Headers.Set("x-admin-user-settings-version", Constants.Stale);
Response.Headers.Set("x-admin-permissions-version", Constants.Stale);
}
await base.OnSuccessfulSave(result);
}
static EntitiesResult GetEntities(string _Azuretoken, EntitiesData _Data)
{
String _JsonData = _Data.ToJson();
var client = new RestClient("https://westus2.api.cognitive.microsoft.com/text/analytics/v2.0/entities");
var request = new RestRequest(Method.POST);
request.AddHeader("Ocp-Apim-Subscription-Key", _Azuretoken);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("undefined", _JsonData, ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
EntitiesResult _Entities = EntitiesResult.FromJson(response.Content);
return(_Entities);
}
public void Entities()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
HttpMockServer.Initialize(this.GetType(), "Entities");
ITextAnalyticsClient client = GetClient(HttpMockServer.CreateInstance());
EntitiesResult result = client.Entities("Microsoft released Windows 10");
Assert.Equal("Microsoft", result.Entities[0].Name);
Assert.Equal("a093e9b9-90f5-a3d5-c4b8-5855e1b01f85", result.Entities[0].BingId);
Assert.Equal("Microsoft", result.Entities[0].Matches[0].Text);
Assert.Equal(0.12508682244047509, result.Entities[0].Matches[0].WikipediaScore);
Assert.Equal(0.99999618530273438, result.Entities[0].Matches[0].EntityTypeScore);
context.Stop();
}
}
public async Task <EntitiesResult <ResourceDefinition> > UpdateState(List <int> ids, UpdateStateArguments args)
{
await Initialize();
// Check user permissions
var action = "State";
var actionFilter = await UserPermissionsFilter(action, cancellation : default);
ids = await CheckActionPermissionsBefore(actionFilter, ids);
// C# Validation
if (string.IsNullOrWhiteSpace(args.State))
{
throw new ServiceException(_localizer[ErrorMessages.Error_Field0IsRequired, _localizer["State"]]);
}
if (!DefStates.All.Contains(args.State))
{
string validStates = string.Join(", ", DefStates.All);
throw new ServiceException($"'{args.State}' is not a valid definition state, valid states are: {validStates}");
}
// Execute and return
using var trx = TransactionFactory.ReadCommitted();
OperationOutput output = await _behavior.Repository.ResourceDefinitions__UpdateState(
ids : ids,
state : args.State,
validateOnly : ModelState.IsError,
top : ModelState.RemainingErrors,
userId : UserId);
AddErrorsAndThrowIfInvalid(output.Errors);
// Prepare result
var result = (args.ReturnEntities ?? false) ?
await GetByIds(ids, args, action, cancellation : default) :
EntitiesResult <ResourceDefinition> .Empty();
// Check user permissions again
await CheckActionPermissionsAfter(actionFilter, ids, result.Data);
trx.Complete();
return(result);
}
private async Task <EntitiesResult <Currency> > SetIsActive(List <string> ids, ActionArguments args, bool isActive)
{
await Initialize();
// Check user permissions
var action = "IsActive";
var actionFilter = await UserPermissionsFilter(action, cancellation : default);
ids = await CheckActionPermissionsBefore(actionFilter, ids);
var settings = await _behavior.Settings();
foreach (var(id, index) in ids.Indexed())
{
if (ids.Any(id => id != null && id == settings.FunctionalCurrencyId))
{
string path = $"[{index}]";
string msg = _localizer["Error_CannotDeactivateTheFunctionalCurrency"];
ModelState.AddError(path, msg);
}
}
// Execute and return
using var trx = TransactionFactory.ReadCommitted();
OperationOutput output = await _behavior.Repository.Currencies__Activate(
ids : ids,
isActive : isActive,
validateOnly : ModelState.IsError,
top : ModelState.RemainingErrors,
userId : UserId);
AddErrorsAndThrowIfInvalid(output.Errors);
var result = (args.ReturnEntities ?? false) ?
await GetByIds(ids, args, action, cancellation : default) :
EntitiesResult <Currency> .Empty();
// Check user permissions again
await CheckActionPermissionsAfter(actionFilter, ids, result.Data);
trx.Complete();
return(result);
}
static void Main(string[] args)
{
string RedditLogin = ""; // Reddit user login
string RedditPWD = ""; // Reddit user password
string RedditAppID = ""; // Reddit App ID
string RedditAppSecret = ""; // Reddit App secret
string redditAccessToken = ""; // Store key here if you going to build DB a few times it is good for 120min
string AzureSentAppKey = "[YourSetimentAppKey]";
gremlinServer = new GremlinServer("[YourCosmoDB].gremlin.cosmos.azure.com", 443, enableSsl: true,
username: $"/dbs/[database id]/colls/[Graph id]",
password: "******");
// Make sure the graph DB is empty to start
using (var gremlinClient = new GremlinClient(gremlinServer, new GraphSON2Reader(), new GraphSON2Writer(), GremlinClient.GraphSON2MimeType))
{
var result = AzureAsync(gremlinClient, "g.V().drop()"); // Clear DB
Console.WriteLine("\n{{\"Returned\": \"{0}\"}}", result.Result.Count);
}
if (redditAccessToken == "")
{
redditAccessToken = AuthToken(RedditLogin, RedditPWD, RedditAppID, RedditAppSecret); // Get Reddit access token
}
RedditArticles myArt = GetArticles(redditAccessToken); // Get Reddit articles
EntitiesData EntitiesData = CreateEntitiesData(myArt); // Create sentiment entity data structure for entities
EntitiesResult ArtEntities = GetEntities(AzureSentAppKey, EntitiesData); // Get entities from Azure API
SemtimentData SentimentData = CreateSentimentData(myArt); // Create sentiment data structure
SemtimentResult ArtSentiment = GetSentiment(AzureSentAppKey, SentimentData); // Get sentiment for article
SaveArtResults(SentimentData, ArtSentiment, ArtEntities); // Save results in Cosmos DB
/*
* foreach(QuickTypeEntitiesResult.Entity artEnt in ArtEntities.Documents[0].Entities)
* {
* Console.WriteLine("e:" + artEnt.Name);
* }
* System.Threading.Thread.Sleep(1000);
* ParseComments(redditAccessToken, articl.Data.Name.Substring(3));
*/
}
public async Task <EntitiesResult <IdentityServerClient> > ResetClientSecret(ResetClientSecretArguments args)
{
await Initialize();
// Check permissions
var idSingleton = new List <int> {
args.Id
}; // A single Id
var action = PermissionActions.Update;
var actionFilter = await UserPermissionsFilter(action, cancellation : default);
idSingleton = await CheckActionPermissionsBefore(actionFilter, idSingleton);
// Invisible or missing user
if (!idSingleton.Any())
{
// The user cannot view that user, we pretend it doesn't exist
throw new NotFoundException <int>(args.Id);
}
// Reset the secret
var newSecret = CryptographicallyStrongClientSecret();
using var trx = TransactionFactory.ReadCommitted();
await _behavior.Repository.IdentityServerClients__UpdateSecret(args.Id, newSecret, UserId);
var result = (args.ReturnEntities ?? false) ?
await GetByIds(idSingleton, args, action, cancellation : default) :
EntitiesResult <IdentityServerClient> .Empty();
// Check user permissions again
await CheckActionPermissionsAfter(actionFilter, idSingleton, result.Data);
trx.Complete();
return(result);
}
internal static EntityRecognitionTasksItem DeserializeEntityRecognitionTasksItem(JsonElement element)
{
Optional <EntitiesResult> results = default;
DateTimeOffset lastUpdateDateTime = default;
string name = default;
JobStatus status = default;
foreach (var property in element.EnumerateObject())
{
if (property.NameEquals("results"))
{
if (property.Value.ValueKind == JsonValueKind.Null)
{
property.ThrowNonNullablePropertyIsNull();
continue;
}
results = EntitiesResult.DeserializeEntitiesResult(property.Value);
continue;
}
if (property.NameEquals("lastUpdateDateTime"))
{
lastUpdateDateTime = property.Value.GetDateTimeOffset("O");
continue;
}
if (property.NameEquals("name"))
{
name = property.Value.GetString();
continue;
}
if (property.NameEquals("status"))
{
status = new JobStatus(property.Value.GetString());
continue;
}
}
return(new EntityRecognitionTasksItem(lastUpdateDateTime, name, status, results.Value));
}
public TextAnalyticsInsight GetInsights(string documentid, string text)
{
// create the TextAnalyticsInsight object
if (!string.IsNullOrEmpty(text))
{
TextAnalyticsInsight textAnalyticsInsight = new TextAnalyticsInsight();
EntitiesResult entitiesResult = this.ProcessEntities(documentid, text);
KeyPhraseResult keyPhraseResult = this.ProcessKeyPhrases(documentid, text);
SentimentResult sentimentResult = this.ProcessSentiment(documentid, text);
foreach (EntityRecord record in entitiesResult.Entities)
{
textAnalyticsInsight.EntityRecords.Add(new Entity.CognitiveServices.EntityRecord
{
Name = record.Name,
SubType = record.SubType,
Type = record.Type,
WikipediaId = record.WikipediaId,
WikipediaLanguage = record.WikipediaLanguage,
WikipediaUrl = record.WikipediaUrl
});
}
foreach (string keyPhrase in keyPhraseResult.KeyPhrases)
{
textAnalyticsInsight.KeyPhrases.Add(keyPhrase);
}
textAnalyticsInsight.SentimentScore = sentimentResult.Score.Value;
// map the CogServices models to our custom model TextAnalyticsInsight which
// contains all TextAnalytics insights for the paramter Text
return(textAnalyticsInsight);
}
return(new TextAnalyticsInsight());
}
internal EntityRecognitionTasksItem(DateTimeOffset lastUpdateDateTime, string name, TextAnalyticsOperationStatus status, EntitiesResult resultsInternal) : base(lastUpdateDateTime, name, status)
{
ResultsInternal = resultsInternal;
}
internal TasksStateTasksEntityRecognitionTasksItem(DateTimeOffset lastUpdateDateTime, string taskName, State status, EntitiesResult results) : base(lastUpdateDateTime, taskName, status)
{
Results = results;
}
protected override Task OnSuccessfulSave(EntitiesResult <LookupDefinition> data)
{
Response.Headers.Set("x-definitions-version", Constants.Stale);
return(base.OnSuccessfulSave(data));
}
internal EntitiesTaskResult(EntitiesResult results)
{
Results = results;
}
protected override Task <EntitiesResult <EmailForQuery> > ToEntitiesResult(List <EmailForQuery> data, int?count = null, CancellationToken cancellation = default)
{
var result = new EntitiesResult <EmailForQuery>(data, count);
return(Task.FromResult(result));
}
internal Components15Gvwi3SchemasTasksstatePropertiesTasksPropertiesEntityrecognitiontasksItemsAllof1(EntitiesResult results)
{
Results = results;
}
protected override Task OnSuccessfulSave(EntitiesResult <DashboardDefinition> result)
{
Response.Headers.Set("x-definitions-version", Constants.Stale);
return(base.OnSuccessfulSave(result));
}
public async Task <EntitiesResult <DocumentDefinition> > UpdateState(List <int> ids, UpdateStateArguments args)
{
await Initialize();
// Check user permissions
var action = "State";
var actionFilter = await UserPermissionsFilter(action, cancellation : default);
ids = await CheckActionPermissionsBefore(actionFilter, ids);
// Validation
if (string.IsNullOrWhiteSpace(args.State))
{
throw new ServiceException(_localizer[ErrorMessages.Error_Field0IsRequired, _localizer["State"]]);
}
if (!DefStates.All.Contains(args.State))
{
string validStates = string.Join(", ", DefStates.All);
throw new ServiceException($"'{args.State}' is not a valid definition state, valid states are: {validStates}.");
}
var defs = await _behavior.Definitions();
int jvDefId = defs.ManualJournalVouchersDefinitionId;
int index = 0;
ids.ForEach(id =>
{
if (id == jvDefId)
{
string path = $"[{index}]";
string msg = _localizer["Error_CannotModifySystemItem"];
ModelState.AddError(path, msg);
}
index++;
});
// Execute
using var trx = TransactionFactory.ReadCommitted();
OperationOutput output = await _behavior.Repository.DocumentDefinitions__UpdateState(
ids : ids,
state : args.State,
validateOnly : ModelState.IsError,
top : ModelState.RemainingErrors,
userId : UserId);
AddErrorsAndThrowIfInvalid(output.Errors);
// Prepare result
var result = (args.ReturnEntities ?? false) ?
await GetByIds(ids, args, action, cancellation : default) :
EntitiesResult <DocumentDefinition> .Empty();
// Check user permissions again
await CheckActionPermissionsAfter(actionFilter, ids, result.Data);
trx.Complete();
return(result);
}
internal static RecognizeEntitiesResultCollection ConvertToRecognizeEntitiesResultCollection(EntitiesResult results, IDictionary <string, int> idToIndexMap)
{
var recognizeEntities = new List <RecognizeEntitiesResult>();
//Read errors
foreach (DocumentError error in results.Errors)
{
recognizeEntities.Add(new RecognizeEntitiesResult(error.Id, ConvertToError(error.Error)));
}
//Read document entities
foreach (DocumentEntities docEntities in results.Documents)
{
recognizeEntities.Add(new RecognizeEntitiesResult(docEntities.Id, docEntities.Statistics ?? default, ConvertToCategorizedEntityCollection(docEntities)));
}
recognizeEntities = SortHeterogeneousCollection(recognizeEntities, idToIndexMap);
return(new RecognizeEntitiesResultCollection(recognizeEntities, results.Statistics, results.ModelVersion));
}
internal EntityRecognitionTasksItemProperties(EntitiesResult results)
{
Results = results;
}
