public Task <ServiceResponse <AnalyzeResponse> > SendAnalysisAsync(AnalyzeRequest a)
{
var response = _requestAnalyzer.AnalyzeRequest(a, Guid.NewGuid().ToString());
var serviceResponse = new ServiceResponse <AnalyzeResponse>(response);
return(Task.FromResult(serviceResponse));
}
public Task <ServiceResponse <byte[]> > SendAnalysisAsync(AnalyzeRequest a, string format)
{
var sortedAnalyzeRequest = new AnalyzeRequest
{
RequestFlags = a.RequestFlags,
Dependencies = a.Dependencies
.OrderBy(t => t.Key.MemberDocId)
.ThenBy(t => t.Key.TypeDocId)
.ToDictionary(t => t.Key, t => t.Value.OrderBy(tt => tt.AssemblyIdentity).ToList() as ICollection <AssemblyInfo>),
UnresolvedAssemblies = new SortedSet <string>(a.UnresolvedAssemblies, StringComparer.Ordinal),
UnresolvedAssembliesDictionary = a.UnresolvedAssembliesDictionary
.OrderBy(t => t.Key)
.ToDictionary(t => t.Key, t => new SortedSet <string>(t.Value) as ICollection <string>),
UserAssemblies = new SortedSet <AssemblyInfo>(a.UserAssemblies),
AssembliesWithErrors = new SortedSet <string>(a.AssembliesWithErrors, StringComparer.Ordinal),
Targets = new SortedSet <string>(a.Targets, StringComparer.Ordinal),
ApplicationName = a.ApplicationName,
Version = a.Version,
BreakingChangesToSuppress = new SortedSet <string>(a.BreakingChangesToSuppress ?? Enumerable.Empty <string>(), StringComparer.Ordinal),
AssembliesToIgnore = a.AssembliesToIgnore.OrderBy(i => i.AssemblyIdentity)
};
var result = sortedAnalyzeRequest.Serialize();
return(Task.FromResult(ServiceResponse.Create(result)));
}
public async Task <PerspectiveAnalysisResponse> Analyze(PerspectiveAnalysisRequest request)
{
var url = $"https://commentanalyzer.googleapis.com/v1alpha1/comments:analyze?key={_perspectiveApiOptions.ApiKey}";
var analyzeRequest = new AnalyzeRequest
{
Comment = new AnalyzeComment
{
Text = request.Text
},
RequestedAttributes = new Dictionary <string, object>
{
{ KnownPerspectiveAnalysisAttributes.Toxicity, new object() },
{ KnownPerspectiveAnalysisAttributes.IdentityAttack, new object() },
{ KnownPerspectiveAnalysisAttributes.SexuallyExplicit, new object() },
},
Languages = new [] { "en" }
};
var analyzeResponse = await _httpClient.Post <AnalyzeResponse>(url, analyzeRequest);
var response = new PerspectiveAnalysisResponse
{
Text = request.Text,
AttributeScores = analyzeResponse.AttributeScores.ToDictionary(
x => x.Key,
x => x.Value.SummaryScore.Value)
};
return(response);
}
private byte[] SerializeRequest(AnalyzeRequest a)
{
var sortedAnalyzeRequest = new AnalyzeRequest
{
RequestFlags = a.RequestFlags,
Dependencies = a.Dependencies
.OrderBy(t => t.Key.MemberDocId)
.ThenBy(t => t.Key.TypeDocId)
.ToDictionary(t => t.Key, t => t.Value.OrderBy(tt => tt.AssemblyIdentity).ToList() as ICollection <AssemblyInfo>),
UnresolvedAssemblies = new SortedSet <string>(a.UnresolvedAssemblies, StringComparer.Ordinal),
UnresolvedAssembliesDictionary = a.UnresolvedAssembliesDictionary
.OrderBy(t => t.Key)
.ToDictionary(t => t.Key, t => new SortedSet <string>(t.Value) as ICollection <string>),
NonUserAssemblies = new SortedSet <AssemblyInfo>(a.NonUserAssemblies),
UserAssemblies = new SortedSet <AssemblyInfo>(a.UserAssemblies),
AssembliesWithErrors = new SortedSet <string>(a.AssembliesWithErrors, StringComparer.Ordinal),
Targets = new SortedSet <string>(a.Targets, StringComparer.Ordinal),
ApplicationName = a.ApplicationName,
Version = a.Version,
BreakingChangesToSuppress = new SortedSet <string>(a.BreakingChangesToSuppress ?? Enumerable.Empty <string>(), StringComparer.Ordinal),
AssembliesToIgnore = a.AssembliesToIgnore.OrderBy(i => i.AssemblyIdentity)
};
return(sortedAnalyzeRequest.Serialize());
}
public void AnalyzeTest()
{
var request = new AnalyzeRequest("text to analyze");
var result = this.Client.Analyze(request);
result.IsValid.Should().BeTrue();
}
private void WriteOutput(AnalyzeRequest a)
{
var sortedAnalyzeRequest = new AnalyzeRequest
{
RequestFlags = a.RequestFlags,
Dependencies = a.Dependencies
.OrderBy(t => t.Key.MemberDocId)
.ThenBy(t => t.Key.TypeDocId)
.ToDictionary(t => t.Key, t => t.Value.OrderBy(tt => tt.AssemblyIdentity).ToList() as ICollection <AssemblyInfo>),
UnresolvedAssemblies = new SortedSet <string>(a.UnresolvedAssemblies, StringComparer.Ordinal),
UnresolvedAssembliesDictionary = a.UnresolvedAssembliesDictionary
.OrderBy(t => t.Key)
.ToDictionary(t => t.Key, t => new SortedSet <string>(t.Value) as ICollection <string>),
UserAssemblies = new SortedSet <AssemblyInfo>(a.UserAssemblies),
AssembliesWithErrors = new SortedSet <string>(a.AssembliesWithErrors, StringComparer.Ordinal),
Targets = new SortedSet <string>(a.Targets, StringComparer.Ordinal),
ApplicationName = a.ApplicationName,
Version = a.Version,
BreakingChangesToSuppress = new SortedSet <string>(a.BreakingChangesToSuppress, StringComparer.Ordinal),
AssembliesToIgnore = a.AssembliesToIgnore.OrderBy(i => i.AssemblyIdentity)
};
var tmp = $"{Path.GetTempFileName()}.json";
using (var ms = new MemoryStream(sortedAnalyzeRequest.Serialize()))
using (var fs = File.OpenWrite(tmp))
{
ms.CopyTo(fs);
}
Process.Start(tmp);
}
public List <RecognizerResult> Analyze(string text)
{
var analyzerRequest = new AnalyzeRequest(text, analyzerLanguage);
var result = analyzer.AnalyzePost(analyzerRequest);
return(result.Select(r => new RecognizerResult(r.Start, r.End, r.Score, r.EntityType)).ToList());
}
public void SerializeAnalyzeRequest()
{
var request = new AnalyzeRequest
{
ApplicationName = "name",
Dependencies = GetDependencies(),
Targets = new List <string> {
"target1", "target2"
},
UnresolvedAssemblies = new List <string> {
"assembly1", "assembly2"
},
UserAssemblies = new List <AssemblyInfo> {
new AssemblyInfo {
AssemblyIdentity = "name1"
}, new AssemblyInfo {
AssemblyIdentity = "name2"
}
},
Version = AnalyzeRequest.CurrentVersion
};
var newtonsoft = request.Serialize().Deserialize <AnalyzeRequest>();
var dcjs = DeserializeObjectDcjs <AnalyzeRequest>(SerializeDcjs(request));
CompareAnalyzeRequest(request, newtonsoft);
CompareAnalyzeRequest(request, dcjs);
}
/// <summary>
/// Creates a new environment. You can only create one environment per service instance.An attempt to create another environment
/// will result in an error. The size of the new environment can be controlled by specifying the size parameter.
/// </summary>
/// <param name="callback">The OnAnalyze callback.</param>
/// <param name="parameters">The analyze parameters.</param>
/// <param name="customData">Optional custom data.</param>
/// <returns>True if the call succeeds, false if the call is unsuccessful.</returns>
public bool Analyze(OnAnalyze callback, Parameters parameters, string customData = default(string))
{
if (callback == null)
{
throw new ArgumentNullException("callback");
}
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
AnalyzeRequest req = new AnalyzeRequest();
req.Callback = callback;
req._Parameters = parameters;
req.Data = customData;
req.OnResponse = OnAnalyzeResponse;
req.Headers["Content-Type"] = "application/json";
req.Headers["Accept"] = "application/json";
req.Parameters["version"] = NaturalLanguageUnderstandingVersion.Version;
fsData data = null;
fsResult r = sm_Serializer.TrySerialize(parameters, out data);
string sendjson = data.ToString();
req.Send = Encoding.UTF8.GetBytes(sendjson);
RESTConnector connector = RESTConnector.GetConnector(SERVICE_ID, SERVICE_ANALYZE);
if (connector == null)
{
return(false);
}
return(connector.Send(req));
}
private ReportingResult GetReportingResult(AnalyzeRequest request, AnalyzeResponse response, IDependencyInfo dependencyInfo)
{
if (response == null)
{
return(null);
}
using (var progressTask = _progressReport.StartTask(LocalizedStrings.ComputingReport))
{
try
{
return(_reportGenerator.ComputeReport(
response.Targets,
response.SubmissionId,
request.RequestFlags,
dependencyInfo?.Dependencies,
response.MissingDependencies,
dependencyInfo?.UnresolvedAssemblies,
response.UnresolvedUserAssemblies,
dependencyInfo?.AssembliesWithErrors,
response.NuGetPackages
));
}
catch (Exception)
{
progressTask.Abort();
throw;
}
}
}
public List <RecognizerResultWithAnalysis> AnalyzePost(AnalyzeRequest analyzeRequest)
{
return(new List <RecognizerResultWithAnalysis>
{
new RecognizerResultWithAnalysis(start: DefaultStart, end: DefaultEnd, score: DefaultScore, entityType: EntityType)
});
}
/// <summary>
/// Gets the Portability of an application as a ReportingResult.
/// </summary>
/// <returns>Set of APIs/assemblies that are not portable/missing.</returns>
private async Task <ReportingResult> GetResultFromServiceAsync(AnalyzeRequest request, IDependencyInfo dependencyInfo)
{
var fullResponse = await RetrieveResultAsync(request);
CheckEndpointStatus(fullResponse.Headers.Status);
using (var progressTask = _progressReport.StartTask(LocalizedStrings.ComputingReport))
{
try
{
var response = fullResponse.Response;
return(_reportGenerator.ComputeReport(
response.Targets,
response.SubmissionId,
request.RequestFlags,
dependencyInfo?.Dependencies,
response.MissingDependencies,
dependencyInfo?.UnresolvedAssemblies,
response.UnresolvedUserAssemblies,
dependencyInfo?.AssembliesWithErrors
));
}
catch (Exception)
{
progressTask.Abort();
throw;
}
}
}
/// <summary>
/// Gets an analysis report based on the options supplied
/// </summary>
/// <param name="options">Options to generate report</param>
/// <returns>A collection of reports</returns>
private async Task <IEnumerable <byte[]> > GetAnalysisResultAsync(IApiPortOptions options)
{
var dependencyInfo = _dependencyFinder.FindDependencies(options.InputAssemblies, _progressReport);
if (dependencyInfo.UserAssemblies.Any())
{
AnalyzeRequest request = GenerateRequest(options, dependencyInfo);
// Create the progress reporter here (instead of within GetResultFromServiceAsync) since the reporter does not work well when run in parallel
using (var progressTask = _progressReport.StartTask(LocalizedStrings.SendingDataToService))
{
try
{
var tasks = options.OutputFormats
.Select(f => GetResultFromServiceAsync(request, f))
.ToList();
await Task.WhenAll(tasks);
return(tasks.Select(t => t.Result).ToList());
}
catch (Exception)
{
progressTask.Abort();
throw;
}
}
}
else
{
_progressReport.ReportIssue(LocalizedStrings.NoFilesAvailableToUpload);
return(Enumerable.Empty <byte[]>());
}
}
public void AnalyzeEmptyStringDoesNotThrow()
{
var request = new AnalyzeRequest(string.Empty);
var result = this.Client.Analyze(request);
result.IsValid.Should().BeFalse();
}
/// <summary>
/// Gets the Portability of an application as a ReportingResult.
/// </summary>
/// <returns>Set of APIs/assemblies that are not portable/missing.</returns>
private async Task <ReportingResult> GetResultFromServiceAsync(AnalyzeRequest request, IDependencyInfo dependencyInfo)
{
var fullResponse = await RetrieveResultAsync(request);
CheckEndpointStatus(fullResponse.Headers.Status);
return(GetReportingResult(request, fullResponse.Response, dependencyInfo));
}
public void UrlSetterNoTrimTest()
{
var body = new AnalyzeRequest {
Url = "https://www.google.com"
};
Assert.AreEqual("https://www.google.com", body.Url);
}
public async Task <ServiceResponse <byte[]> > SendAnalysisAsync(AnalyzeRequest a, string format)
{
var formatInformation = await GetResultFormat(format);
var sendAnalysis = _endpoint + Endpoints.Analyze;
return(await _client.CallAsync(HttpMethod.Post, sendAnalysis, a, formatInformation));
}
public Task AddAsync(AnalyzeRequest request)
{
var bytes = _serializer.Serialize(request);
_model.BasicPublish(Constants.Exchange, Constants.Routing, null, bytes);
return(Task.CompletedTask);
}
/// <summary>
/// Gets the Portability report for the request.
/// </summary>
/// <returns>An array of bytes corresponding to the report.</returns>
private async Task <byte[]> GetResultFromServiceAsync(AnalyzeRequest request, string format)
{
var response = await _apiPortService.SendAnalysisAsync(request, format);
CheckEndpointStatus(response.Headers.Status);
return(response.Response);
}
public AnalyzeResponse AnalyzeRequest(AnalyzeRequest request, string submissionId)
{
// Get the list of targets we should consider in the analysis
var targets = _targetNameParser
.MapTargetsToExplicitVersions(request.Targets.SelectMany(_targetMapper.GetNames))
.OrderBy(x => x.FullName, StringComparer.OrdinalIgnoreCase)
.ToList();
// TODO: It's possible that an AssemblyInfo in UserAssemblies is null.
// This appears to be coming from analysis in the VSIX, possibly
// from CCI. Figure out where this is coming from.
var assemblyIdentities = request?.UserAssemblies.Where(x => x != null && x.AssemblyIdentity != null).Select(a => a.AssemblyIdentity)
?? Enumerable.Empty <string>();
var userAssemblies = new HashSet <string>(assemblyIdentities, StringComparer.OrdinalIgnoreCase);
var notInAnyTarget = request.RequestFlags.HasFlag(AnalyzeRequestFlags.ShowNonPortableApis)
? _analysisEngine.FindMembersNotInTargets(targets, userAssemblies, request.Dependencies)
: new List <MemberInfo>();
var unresolvedAssemblies = request.UnresolvedAssembliesDictionary != null
? request.UnresolvedAssembliesDictionary.Keys
: request.UnresolvedAssemblies;
var missingUserAssemblies = _analysisEngine.FindUnreferencedAssemblies(unresolvedAssemblies, request.UserAssemblies).ToList();
var breakingChangeSkippedAssemblies = request.RequestFlags.HasFlag(AnalyzeRequestFlags.ShowBreakingChanges)
? _analysisEngine.FindBreakingChangeSkippedAssemblies(targets, request.UserAssemblies, request.AssembliesToIgnore).ToList()
: new List <AssemblyInfo>();
var breakingChanges = request.RequestFlags.HasFlag(AnalyzeRequestFlags.ShowBreakingChanges)
? _analysisEngine.FindBreakingChanges(targets, request.Dependencies, breakingChangeSkippedAssemblies, request.BreakingChangesToSuppress, userAssemblies, request.RequestFlags.HasFlag(AnalyzeRequestFlags.ShowRetargettingIssues)).ToList()
: new List <BreakingChangeDependency>();
var reportingResult = _reportGenerator.ComputeReport(
targets,
submissionId,
request.RequestFlags,
request.Dependencies,
notInAnyTarget,
request.UnresolvedAssembliesDictionary,
missingUserAssemblies,
request.AssembliesWithErrors);
return(new AnalyzeResponse
{
CatalogLastUpdated = _analysisEngine.CatalogLastUpdated,
ApplicationName = request.ApplicationName,
MissingDependencies = notInAnyTarget,
UnresolvedUserAssemblies = missingUserAssemblies,
Targets = targets,
ReportingResult = reportingResult,
SubmissionId = submissionId,
BreakingChanges = breakingChanges,
BreakingChangeSkippedAssemblies = breakingChangeSkippedAssemblies
});
}
public AnalyzeRequestTests()
{
var request = new AnalyzeRequest("analyze this text")
{
Indices = new IndexNameMarker[] { typeof(ElasticsearchProject)},
Field = Property.Path<ElasticsearchProject>(p=>p.Name)
};
var response = this._client.Analyze(request);
this._status = response.ConnectionStatus;
}
public AnalyzeRequestTests()
{
var request = new AnalyzeRequest("analyze this text")
{
Indices = new IndexNameMarker[] { typeof(ElasticsearchProject) },
Field = Property.Path <ElasticsearchProject>(p => p.Name)
};
var response = this._client.Analyze(request);
this._status = response.ConnectionStatus;
}
/// <summary>
/// Creates a new environment. You can only create one environment per service instance.An attempt to create another environment
/// will result in an error. The size of the new environment can be controlled by specifying the size parameter.
/// </summary>
/// <param name="successCallback">The success callback.</param>
/// <param name="failCallback">The fail callback.</param>
/// <param name="parameters">The analyze parameters.</param>
/// <param name="customData">Optional custom data.</param>
/// <returns>True if the call succeeds, false if the call is unsuccessful.</returns>
public bool Analyze(SuccessCallback <AnalysisResults> successCallback, FailCallback failCallback, Parameters parameters, Dictionary <string, object> customData = null)
{
if (successCallback == null)
{
throw new ArgumentNullException("successCallback");
}
if (failCallback == null)
{
throw new ArgumentNullException("failCallback");
}
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
AnalyzeRequest req = new AnalyzeRequest();
req.SuccessCallback = successCallback;
req.FailCallback = failCallback;
req.HttpMethod = UnityWebRequest.kHttpVerbPOST;
req.DisableSslVerification = DisableSslVerification;
req.CustomData = customData == null ? new Dictionary <string, object>() : customData;
if (req.CustomData.ContainsKey(Constants.String.CUSTOM_REQUEST_HEADERS))
{
foreach (KeyValuePair <string, string> kvp in req.CustomData[Constants.String.CUSTOM_REQUEST_HEADERS] as Dictionary <string, string> )
{
req.Headers.Add(kvp.Key, kvp.Value);
}
}
req.OnResponse = OnAnalyzeResponse;
req.Headers["X-IBMCloud-SDK-Analytics"] = "service_name=natural_language_understanding;service_version=v1;operation_id=Analyze";
req.Headers["Content-Type"] = "application/json";
req.Headers["Accept"] = "application/json";
req.Parameters["version"] = NaturalLanguageUnderstandingVersion.Version;
fsData data = null;
_serializer.TrySerialize(parameters, out data);
string sendjson = data.ToString();
req.Send = Encoding.UTF8.GetBytes(sendjson);
RESTConnector connector = RESTConnector.GetConnector(Credentials, AnalyzeEndpoint);
if (connector == null)
{
return(false);
}
return(connector.Send(req));
}
public virtual Response <AnalyzeResult> Analyze(string indexName, AnalyzeRequest request, RequestOptions requestOptions = null, CancellationToken cancellationToken = default)
{
using var scope = _clientDiagnostics.CreateScope("IndexesClient.Analyze");
scope.Start();
try
{
return(RestClient.Analyze(indexName, request, requestOptions, cancellationToken));
}
catch (Exception e)
{
scope.Failed(e);
throw;
}
}
/// <summary>
/// 分词
/// </summary>
/// <param name="strSentence"></param>
/// <returns></returns>
public static List <string> GetTokenList(string strSentence)
{
AnalyzeRequest a = new AnalyzeRequest();
a.Text = new string[] { strSentence };
a.Tokenizer = TokenizerName;
var result = client.Analyze(a);
if (result.Tokens == null)
{
return(null);
}
return(result.Tokens.Select(x => x.Token).ToList <string>());
}
/// <summary>
/// Gets an analysis report based on the options supplied
/// </summary>
/// <param name="options">Options to generate report</param>
/// <returns>A collection of reports</returns>
private async Task <MultipleFormatAnalysis> GetAnalysisResultAsync(IApiPortOptions options)
{
var dependencyInfo = _dependencyFinder.FindDependencies(options.InputAssemblies, _progressReport);
if (dependencyInfo.UserAssemblies.Any())
{
AnalyzeRequest request = GenerateRequest(options, dependencyInfo);
// Create the progress reporter here (instead of within GetResultFromServiceAsync) since the reporter does not work well when run in parallel
using (var progressTask = _progressReport.StartTask(LocalizedStrings.AnalyzingCompatibility))
{
try
{
var tasks = options.OutputFormats
.Select(f => new { Format = f, Task = GetResultFromServiceAsync(request, f) })
.ToList();
await Task.WhenAll(tasks.Select(t => t.Task));
var results = tasks.Select(t => new ReportingResultWithFormat
{
Data = t.Task.Result,
Format = t.Format,
}).ToList();
return(new MultipleFormatAnalysis
{
Info = dependencyInfo,
Request = request,
Results = results
});
}
catch (Exception)
{
progressTask.Abort();
throw;
}
}
}
else
{
_progressReport.ReportIssue(LocalizedStrings.NoFilesAvailableToUpload);
return(new MultipleFormatAnalysis
{
Results = Enumerable.Empty <ReportingResultWithFormat>()
});
}
}
public AnalyzeResponse AnalyzeRequest(AnalyzeRequest request, string submissionId)
{
// Get the list of targets we should consider in the analysis
var targets = _targetNameParser
.MapTargetsToExplicitVersions(request.Targets.SelectMany(_targetMapper.GetNames))
.OrderBy(x => x.FullName, StringComparer.OrdinalIgnoreCase)
.ToList();
var notInAnyTarget = request.RequestFlags.HasFlag(AnalyzeRequestFlags.ShowNonPortableApis)
? _analysisEngine.FindMembersNotInTargets(targets, request.Dependencies)
: new List <MemberInfo>();
var unresolvedAssemblies = request.UnresolvedAssembliesDictionary != null
? request.UnresolvedAssembliesDictionary.Keys
: request.UnresolvedAssemblies;
var missingUserAssemblies = _analysisEngine.FindUnreferencedAssemblies(unresolvedAssemblies, request.UserAssemblies).ToList();
var breakingChangeSkippedAssemblies = request.RequestFlags.HasFlag(AnalyzeRequestFlags.ShowBreakingChanges)
? _analysisEngine.FindBreakingChangeSkippedAssemblies(targets, request.UserAssemblies, request.AssembliesToIgnore).ToList()
: new List <AssemblyInfo>();
var breakingChanges = request.RequestFlags.HasFlag(AnalyzeRequestFlags.ShowBreakingChanges)
? _analysisEngine.FindBreakingChanges(targets, request.Dependencies, breakingChangeSkippedAssemblies, request.BreakingChangesToSuppress, request.RequestFlags.HasFlag(AnalyzeRequestFlags.ShowRetargettingIssues)).ToList()
: new List <BreakingChangeDependency>();
var reportingResult = _reportGenerator.ComputeReport(
targets,
submissionId,
request.RequestFlags,
request.Dependencies,
notInAnyTarget,
request.UnresolvedAssembliesDictionary,
missingUserAssemblies,
request.AssembliesWithErrors);
return(new AnalyzeResponse
{
CatalogLastUpdated = _analysisEngine.CatalogLastUpdated,
ApplicationName = request.ApplicationName,
MissingDependencies = notInAnyTarget,
UnresolvedUserAssemblies = missingUserAssemblies,
Targets = targets,
ReportingResult = reportingResult,
SubmissionId = submissionId,
BreakingChanges = breakingChanges,
BreakingChangeSkippedAssemblies = breakingChangeSkippedAssemblies
});
}
public IEnumerable <string> Analyze(string text, int nGramCount)
{
if (string.IsNullOrEmpty(text))
{
return(new List <string>());
}
var request = new AnalyzeRequest(IndexName, text)
{
Analyzer = $"{_analyzerPrefix}{nGramCount}"
};
var result = Client.Analyze(request);
ResponseValidator(result);
return(result.Tokens.Select(t => t.Token));
}
private async Task <ServiceResponse <AnalyzeResponse> > RetrieveResultAsync(AnalyzeRequest request)
{
using (var progressTask = _progressReport.StartTask(LocalizedStrings.AnalyzingCompatibility))
{
try
{
return(await _apiPortService.SendAnalysisAsync(request));
}
catch (Exception)
{
progressTask.Abort();
throw;
}
}
}
public async Task <IssueResults> Nuget([FromBody] NuGetRequest nuGetRequest)
{
var results = await _storage.CreateAsync(CancellationToken.None);
var request = new AnalyzeRequest
{
Id = results.Id,
Original = nuGetRequest.Original,
Updated = nuGetRequest.Updated
};
await _queue.AddAsync(request);
return(results);
}
public async Task <IActionResult> PostBookmark([Required][FromBody] AnalyzeRequest request)
{
var bookmark = await _dbContext.GetBookmarkFromUrlAsync(request.Url);
if (bookmark != null)
{
throw new NoBookmarkExitsException("Bookmark already exists", request.Url);
}
var results = _naturalLanguageService.Analyze(request.Url);
bookmark = new Bookmark(results, request.Tags);
bookmark = await _dbContext.AddBookmarkAsync(bookmark);
return(Created(bookmark.Path, bookmark));
}
public void AnalyzeTest()
{
var request = new AnalyzeRequest("text to analyze");
var result = this.Client.Analyze(request);
result.IsValid.Should().BeTrue();
}
public void AnalyzeEmptyStringDoesNotThrow()
{
var request = new AnalyzeRequest(string.Empty);
var result = this.Client.Analyze(request);
result.IsValid.Should().BeFalse();
}
