private async Task <QueryResult> GetTerminalsInternal(string outBaseUrl, NeuronQuery neuronQuery, CancellationToken token = default(CancellationToken))
{
return(await requestProvider.GetAsync <QueryResult>(
$"{outBaseUrl}{HttpNeuronGraphQueryClient.GetTerminalsPathTemplate}{neuronQuery.ToString()}",
token : token
));
}
public async Task <CommonTerminal> GetTerminalById(string id, NeuronQuery neuronQuery, CancellationToken token = default(CancellationToken))
{
CommonTerminal result = null;
await this.terminalRepository.Initialize();
result = (await this.terminalRepository.Get(Guid.Parse(id), neuronQuery, token))?.ToCommon();
return(result);
}
private async Task <Domain.Model.QueryResult> GetAllCore(Guid?centralGuid, NeuronQuery neuronQuery, CancellationToken token = default(CancellationToken))
{
Domain.Model.QueryResult result = null;
NeuronRepository.FillWithDefaults(neuronQuery, this.settingsService);
result = NeuronRepository.GetNeuronResults(
centralGuid,
null,
this.settingsService.DatabaseName,
neuronQuery,
token
);
return(result);
}
internal static Graph.Common.NeuronQuery ToExternalType(this NeuronQuery value)
{
var result = new Graph.Common.NeuronQuery();
result.Id = value.Id?.ToArray();
result.IdNot = value.IdNot?.ToArray();
result.Postsynaptic = value.Postsynaptic?.ToArray();
result.PostsynapticNot = value.PostsynapticNot?.ToArray();
result.Presynaptic = value.Presynaptic?.ToArray();
result.PresynapticNot = value.PresynapticNot?.ToArray();
result.TagContains = value.TagContains?.ToArray();
result.TagContainsNot = value.TagContainsNot?.ToArray();
result.TagContainsIgnoreWhitespace = value.TagContainsIgnoreWhitespace;
result.RegionId = value.RegionId?.ToArray();
result.RegionIdNot = value.RegionIdNot?.ToArray();
result.ExternalReferenceUrl = value.ExternalReferenceUrl?.ToArray();
result.ExternalReferenceUrlContains = value.ExternalReferenceUrlContains?.ToArray();
result.RelativeValues = Extensions.ConvertNullableEnumToExternal <RelativeValues, Graph.Common.RelativeValues>(
value.RelativeValues,
v => ((int)v).ToString()
);
result.NeuronActiveValues = Extensions.ConvertNullableEnumToExternal <ActiveValues, Graph.Common.ActiveValues>(
value.NeuronActiveValues,
v => ((int)v).ToString()
);
result.TerminalActiveValues = Extensions.ConvertNullableEnumToExternal <ActiveValues, Graph.Common.ActiveValues>(
value.TerminalActiveValues,
v => ((int)v).ToString()
);
result.Page = value.Page;
result.PageSize = value.PageSize;
result.SortBy = Extensions.ConvertNullableEnumToExternal <SortByValue, Graph.Common.SortByValue>(
value.SortBy,
v => ((int)v).ToString()
);
result.SortOrder = Extensions.ConvertNullableEnumToExternal <SortOrderValue, Graph.Common.SortOrderValue>(
value.SortOrder,
v => ((int)v).ToString()
);
return(result);
}
public async Task <QueryResult <Terminal> > GetTerminals(NeuronQuery neuronQuery, string userId, CancellationToken token = default(CancellationToken))
{
var commonResult = await this.graphQueryClient.GetTerminals(
this.settingsService.CortexGraphOutBaseUrl + "/",
neuronQuery.ToExternalType(),
token
);
return(await TerminalQueryService.ConvertProcessValidate(
commonResult,
userId,
validationClient,
settingsService,
token
));
}
public async Task <QueryResult <Neuron> > GetNeurons(NeuronQuery neuronQuery, string userId, CancellationToken token = default(CancellationToken))
{
var commonResult = await this.graphQueryClient.GetNeurons(
this.settingsService.CortexGraphOutBaseUrl + "/",
neuronQuery.ToExternalType(),
token
);
var result = commonResult.ToInternalType(n => n.ToInternalType());
result.Items = await result.Items.ProcessValidate(
userId,
this.validationClient,
this.settingsService,
token
);
return(result);
}
public async Task <QueryResult <Neuron> > SendQueryInternal(string queryUrl, string bearerToken, CancellationToken token = default)
{
QueryResult <Neuron> result = new QueryResult <Neuron>()
{
Items = new Neuron[0]
};
if (QueryUrl.TryParse(queryUrl, out QueryUrl request))
{
NeuronQuery query = NeuronQuery.TryParse(request.QueryString, out NeuronQuery nquery) ?
nquery :
new NeuronQuery();
if (request.Id.Length > 0)
{
if (request.HasRelatives)
{
// http://[avatar]/cortex/neurons/[id]/relatives/[id2]
if (request.Id2.Length > 0)
{
result = await this.GetNeuronByIdInternal(request.AvatarUrl, request.Id2, request.Id, query, bearerToken, token);
}
// http://[avatar]/cortex/neurons/[id]/relatives
else
{
result = await this.GetNeuronsInternal(request.AvatarUrl, request.Id, query, bearerToken, token);
}
}
else
{
// http://[avatar]/cortex/neurons/[id]
result = await this.GetNeuronByIdInternal(request.AvatarUrl, request.Id, query, bearerToken, token);
}
}
// http://[avatar]/cortex/neurons
else
{
result = await this.GetNeuronsInternal(request.AvatarUrl, request.Id, query, bearerToken, token);
}
}
return(result);
}
internal static void FillWithDefaults(NeuronQuery neuronQuery, ISettingsService settingsService)
{
if (!neuronQuery.RelativeValues.HasValue)
{
neuronQuery.RelativeValues = settingsService.DefaultRelativeValues;
}
if (!neuronQuery.NeuronActiveValues.HasValue)
{
neuronQuery.NeuronActiveValues = settingsService.DefaultNeuronActiveValues;
}
if (!neuronQuery.TerminalActiveValues.HasValue)
{
neuronQuery.TerminalActiveValues = settingsService.DefaultTerminalActiveValues;
}
if (!neuronQuery.PageSize.HasValue)
{
neuronQuery.PageSize = settingsService.DefaultPageSize;
}
if (!neuronQuery.Page.HasValue)
{
neuronQuery.Page = settingsService.DefaultPage;
}
}
private static NeuronQuery ExtractQuery(dynamic query)
{
var nq = new NeuronQuery();
nq.TagContains = GraphModule.GetQueryArrayOrDefault(query, nameof(NeuronQuery.TagContains));
nq.TagContainsNot = GraphModule.GetQueryArrayOrDefault(query, nameof(NeuronQuery.TagContainsNot));
nq.Id = GraphModule.GetQueryArrayOrDefault(query, nameof(NeuronQuery.Id));
nq.IdNot = GraphModule.GetQueryArrayOrDefault(query, nameof(NeuronQuery.IdNot));
nq.Postsynaptic = GraphModule.GetQueryArrayOrDefault(query, nameof(NeuronQuery.Postsynaptic));
nq.PostsynapticNot = GraphModule.GetQueryArrayOrDefault(query, nameof(NeuronQuery.PostsynapticNot));
nq.Presynaptic = GraphModule.GetQueryArrayOrDefault(query, nameof(NeuronQuery.Presynaptic));
nq.PresynapticNot = GraphModule.GetQueryArrayOrDefault(query, nameof(NeuronQuery.PresynapticNot));
nq.RegionId = GraphModule.GetQueryArrayOrDefault(query, nameof(NeuronQuery.RegionId));
nq.RegionIdNot = GraphModule.GetQueryArrayOrDefault(query, nameof(NeuronQuery.RegionIdNot));
nq.RelativeValues = GraphModule.GetNullableEnumValue <RelativeValues>("relative", query);
nq.PageSize = GraphModule.GetNullableIntValue("pagesize", query);
nq.Page = GraphModule.GetNullableIntValue("page", query);
nq.NeuronActiveValues = GraphModule.GetNullableEnumValue <ActiveValues>("nactive", query);
nq.TerminalActiveValues = GraphModule.GetNullableEnumValue <ActiveValues>("tactive", query);
nq.SortBy = GraphModule.GetNullableEnumValue <SortByValue>("sortby", query);
nq.SortOrder = GraphModule.GetNullableEnumValue <SortOrderValue>("sortorder", query);
return(nq);
}
private async Task <QueryResult <Terminal> > GetTerminalsInternal(string avatarUrl, NeuronQuery neuronQuery, string bearerToken, CancellationToken token = default(CancellationToken))
{
return(await requestProvider.GetAsync <QueryResult <Terminal> >(
$"{avatarUrl}{HttpTerminalQueryClient.GetTerminalsPathTemplate}{neuronQuery.ToString()}",
bearerToken,
token
));
}
private static Domain.Model.QueryResult GetNeuronResults(Guid?centralGuid, Guid?relativeGuid, string settingName, NeuronQuery neuronQuery, CancellationToken token = default(CancellationToken))
{
Domain.Model.QueryResult result = null;
using (var db = ArangoDatabase.CreateWithSetting(settingName))
{
var queryResult = db.CreateStatement <Domain.Model.NeuronResult>(
NeuronRepository.CreateQuery(centralGuid, relativeGuid, neuronQuery, out List <QueryParameter> queryParameters),
queryParameters,
options: new QueryOption()
{
FullCount = true
}
);
var neurons = queryResult.AsEnumerable().ToArray();
if (centralGuid.HasValue)
{
neurons.ToList().ForEach(nr => nr.Terminal = nr.Terminal.CloneExcludeSynapticPrefix());
}
var fullCount = (int)queryResult.Statistics.Extra.Stats.FullCount;
if (
neuronQuery.Page.Value != 1 &&
fullCount == NeuronRepository.CalculateOffset(neuronQuery.Page.Value, neuronQuery.PageSize.Value) &&
neurons.Length == 0
)
{
throw new ArgumentOutOfRangeException("Specified/Default Page is invalid.");
}
result = new Domain.Model.QueryResult()
{
Count = fullCount,
Neurons = neurons
};
}
return(result);
}
public async Task <Domain.Model.QueryResult> GetAll(NeuronQuery neuronQuery, CancellationToken token = default(CancellationToken))
{
return(await this.GetAllCore(null, neuronQuery, token));
}
private async Task <QueryResult <Neuron> > GetNeuronByIdInternal(string avatarUrl, string id, string centralId, NeuronQuery neuronQuery, string bearerToken, CancellationToken token = default(CancellationToken))
{
return(await HttpNeuronQueryClient.GetNeuronsUnescaped(
avatarUrl,
$"{HttpNeuronQueryClient.GetNeuronsPathTemplate}/{centralId}/relatives/{id}",
neuronQuery.ToString(),
token,
requestProvider,
bearerToken
));
}
internal static NeuronQuery ParseNeuronQueryOrEmpty(string queryString)
{
return(NeuronQuery.TryParse(queryString, out NeuronQuery query) ? query : new NeuronQuery());
}
public async Task <QueryResult> GetTerminals(string outBaseUrl, NeuronQuery neuronQuery, CancellationToken token = default(CancellationToken)) =>
await HttpNeuronGraphQueryClient.exponentialRetryPolicy.ExecuteAsync(
async() => await this.GetTerminalsInternal(outBaseUrl, neuronQuery, token).ConfigureAwait(false));
public async Task <QueryResult <Neuron> > GetNeuronById(string avatarUrl, string id, string centralId, NeuronQuery neuronQuery, string bearerToken, CancellationToken token = default(CancellationToken)) =>
await HttpNeuronQueryClient.exponentialRetryPolicy.ExecuteAsync(
async() => await this.GetNeuronByIdInternal(avatarUrl, id, centralId, neuronQuery, bearerToken, token).ConfigureAwait(false));
public async Task <QueryResult <Neuron> > GetNeurons(string avatarUrl, NeuronQuery neuronQuery, string bearerToken, CancellationToken token = default(CancellationToken)) => await this.GetNeurons(avatarUrl, null, neuronQuery, bearerToken, token);
private async Task <QueryResult <Neuron> > GetNeuronsInternal(string avatarUrl, string centralId, NeuronQuery neuronQuery, string bearerToken, CancellationToken token = default(CancellationToken))
{
var path = string.IsNullOrEmpty(centralId) ?
HttpNeuronQueryClient.GetNeuronsPathTemplate :
string.Format(HttpNeuronQueryClient.GetRelativesPathTemplate, centralId);
return(await HttpNeuronQueryClient.GetNeuronsUnescaped(
avatarUrl,
path,
neuronQuery.ToString(),
token,
requestProvider,
bearerToken
));
}
public async Task <QueryResult <Terminal> > GetTerminals(string avatarUrl, NeuronQuery neuronQuery, string bearerToken, CancellationToken token = default(CancellationToken)) =>
await HttpTerminalQueryClient.exponentialRetryPolicy.ExecuteAsync(
async() => await this.GetTerminalsInternal(avatarUrl, neuronQuery, bearerToken, token).ConfigureAwait(false)
);
public async Task <IEnumerable <NeuronResult> > GetAll(Guid?centralGuid = null, RelativeType type = RelativeType.NotSet, NeuronQuery neuronQuery = null, int?limit = 1000, CancellationToken token = default(CancellationToken))
{
IEnumerable <NeuronResult> result = null;
result = this.GetNeuronResults(
centralGuid,
string.Empty,
InMemoryNeuronRepository.ConvertRelativeToDirection(type),
neuronQuery,
limit);
return(await Task.FromResult(result));
}
public async Task <Domain.Model.QueryResult> GetRelative(Guid guid, Guid centralGuid, NeuronQuery neuronQuery, CancellationToken token = default(CancellationToken))
{
return(await this.GetRelativeCore(guid, centralGuid, neuronQuery, token));
}
public async Task <QueryResult> GetNeuronById(string outBaseUrl, string id, string centralId, NeuronQuery neuronQuery, CancellationToken token = default(CancellationToken)) =>
await HttpNeuronGraphQueryClient.exponentialRetryPolicy.ExecuteAsync(
async() => await this.GetNeuronByIdWithCentralInternal(outBaseUrl, id, centralId, neuronQuery, token).ConfigureAwait(false));
private IEnumerable <NeuronResult> GetNeuronResults(Guid?centralGuid, string settingName, EdgeDirection direction, NeuronQuery neuronQuery = null, int?limit = 1000, CancellationToken token = default(CancellationToken))
{
// IEnumerable<NeuronResult> result = null;
//using (var db = ArangoDatabase.CreateWithSetting(settingName))
//{
// var queryString = NeuronRepository.CreateQuery(centralGuid, direction, neuronQuery, limit, out List<QueryParameter> queryParameters);
// result = db.CreateStatement<NeuronResult>(queryString, queryParameters)
// .AsEnumerable()
// .ToArray();
//}
var ns = this.cache.Values.Where(n => centralGuid == null || n.Id == centralGuid.ToString() || n.Terminals.Any(t => t.TargetId == centralGuid.ToString()));
var result = new List <NeuronResult>();
ns.ToList().ForEach(n =>
{
if (centralGuid == null || n.Id == centralGuid.ToString())
{
result.Add(new NeuronResult()
{
Neuron = n
});
}
else
{
result.Add(new NeuronResult()
{
Neuron = n, Terminal = n.Terminals.First(t => t.TargetId == centralGuid.ToString())
});
}
}
);
return(result);
}
private static string CreateQuery(Guid?centralGuid, Guid?relativeGuid, NeuronQuery neuronQuery, out List <QueryParameter> queryParameters)
{
queryParameters = new List <QueryParameter>();
var queryFiltersBuilder = new StringBuilder();
var queryStringBuilder = new StringBuilder();
Func <string, string> valueBuilder = s => $"%{s}%";
Func <string, List <string>, string, string> selector = (f, ls, s) => $"Upper(n.Tag) LIKE Upper(@{f + (ls.IndexOf(s) + 1)})";
// TagContains
NeuronRepository.ExtractFilters(neuronQuery.TagContains, nameof(NeuronQuery.TagContains), valueBuilder, selector, queryParameters, queryFiltersBuilder, "&&");
// TagContainsNot
NeuronRepository.ExtractFilters(neuronQuery.TagContainsNot, nameof(NeuronQuery.TagContainsNot), valueBuilder, selector, queryParameters, queryFiltersBuilder, "||", "NOT");
valueBuilder = s => $"Neuron/{s}";
selector = (f, ls, s) => $"n._id == @{f + (ls.IndexOf(s) + 1)}";
// IdEquals
NeuronRepository.ExtractFilters(neuronQuery.Id, nameof(NeuronQuery.Id), valueBuilder, selector, queryParameters, queryFiltersBuilder, "||");
// IdEqualsNot
NeuronRepository.ExtractFilters(neuronQuery.IdNot, nameof(NeuronQuery.IdNot), valueBuilder, selector, queryParameters, queryFiltersBuilder, "||", "NOT");
valueBuilder = s => s;
selector = (f, ls, s) => $"n.RegionId == @{f + (ls.IndexOf(s) + 1)}";
// RegionIdEquals
NeuronRepository.ExtractFilters(neuronQuery.RegionId, nameof(NeuronQuery.RegionId), valueBuilder, selector, queryParameters, queryFiltersBuilder, "||");
// RegionIdEqualsNot
NeuronRepository.ExtractFilters(neuronQuery.RegionIdNot, nameof(NeuronQuery.RegionIdNot), valueBuilder, selector, queryParameters, queryFiltersBuilder, "||", "NOT");
var neuronAuthorRegion = @"
LET neuronCreationAuthorTag = (
FOR neuronAuthorNeuron in Neuron
FILTER neuronAuthorNeuron._id == CONCAT(""Neuron/"", n.CreationAuthorId)
return neuronAuthorNeuron.Tag
)
LET neuronLastModificationAuthorTag = (
FOR neuronAuthorNeuron in Neuron
FILTER neuronAuthorNeuron._id == CONCAT(""Neuron/"", n.LastModificationAuthorId)
return neuronAuthorNeuron.Tag
)
LET neuronUnifiedLastModificationAuthorTag = (
FOR neuronAuthorNeuron in Neuron
FILTER neuronAuthorNeuron._id == CONCAT(""Neuron/"", n.UnifiedLastModificationAuthorId)
return neuronAuthorNeuron.Tag
)
LET neuronRegionTag = (
FOR regionNeuron in Neuron
FILTER regionNeuron._id == CONCAT(""Neuron/"", n.RegionId)
return regionNeuron.Tag
)";
var neuronAuthorRegionReturn = ", NeuronCreationAuthorTag: FIRST(neuronCreationAuthorTag), NeuronLastModificationAuthorTag: FIRST(neuronLastModificationAuthorTag), NeuronUnifiedLastModificationAuthorTag: FIRST(neuronUnifiedLastModificationAuthorTag), NeuronRegionTag: FIRST(neuronRegionTag)";
if (!centralGuid.HasValue)
{
// Neuron Active
NeuronRepository.AddActiveFilter("n", neuronQuery.NeuronActiveValues.Value, queryFiltersBuilder);
queryStringBuilder.Append($@"
FOR n IN Neuron
{queryFiltersBuilder}
{neuronAuthorRegion}
RETURN {{ Neuron: n, Terminal: {{}}{neuronAuthorRegionReturn} }}");
}
else
{
// Terminal Active
NeuronRepository.AddActiveFilter("t", neuronQuery.TerminalActiveValues.Value, queryFiltersBuilder);
string letPre = string.Empty,
inPre = string.Empty,
filterPre = string.Empty;
string activeSynapticTemplate = string.Empty;
if (Helper.TryConvert(neuronQuery.NeuronActiveValues.Value, out bool active))
{
activeSynapticTemplate = " && {0}.Active == " + active.ToString();
}
if (neuronQuery.RelativeValues.Value.HasFlag(RelativeValues.Presynaptic))
{
// get all presynaptic neurons of current terminal
letPre = $@"LET presynaptics = (
FOR presynaptic IN Neuron
FILTER presynaptic._id == t._from{string.Format(activeSynapticTemplate, "presynaptic")}
return presynaptic
)";
// where "to" is centralGuid
inPre = $@"t._to == @{nameof(centralGuid)} && LENGTH(presynaptics) > 0 ?
presynaptics :";
filterPre = $@"t._to == @{nameof(centralGuid)}";
if (relativeGuid.HasValue)
{
filterPre += $@" && t._from == @{nameof(relativeGuid)}";
}
}
string letPost = string.Empty,
inPost = string.Empty,
filterPost = string.Empty;
if (neuronQuery.RelativeValues.Value.HasFlag(RelativeValues.Postsynaptic))
{
// get postsynaptic neurons
letPost = $@"LET postsynaptics = (
FOR postsynaptic IN Neuron
FILTER postsynaptic._id == t._to{string.Format(activeSynapticTemplate, "postsynaptic")}
return postsynaptic
)";
inPost = $@"t._from == @{nameof(centralGuid)} && LENGTH(postsynaptics) > 0 ?
postsynaptics :";
filterPost = $@"t._from == @{nameof(centralGuid)}";
if (relativeGuid.HasValue)
{
filterPost += $@" && t._to == @{nameof(relativeGuid)}";
}
}
queryStringBuilder.Append($@"
FOR t in Terminal
{letPost}
{letPre}
FOR n IN (
{inPost}
{inPre}
[ {{ }} ]
)
LET terminalCreationAuthorTag = (
FOR terminalAuthorNeuron in Neuron
FILTER terminalAuthorNeuron._id == CONCAT(""Neuron/"", t.CreationAuthorId)
return terminalAuthorNeuron.Tag
)
LET terminalLastModificationAuthorTag = (
FOR terminalAuthorNeuron in Neuron
FILTER terminalAuthorNeuron._id == CONCAT(""Neuron/"", t.LastModificationAuthorId)
return terminalAuthorNeuron.Tag
)
{neuronAuthorRegion}
FILTER {filterPost} {(!string.IsNullOrEmpty(filterPost) && !string.IsNullOrEmpty(filterPre) ? "||" : string.Empty)} {filterPre}
{queryFiltersBuilder}
RETURN {{ Neuron: n, Terminal: t, TerminalCreationAuthorTag: FIRST(terminalCreationAuthorTag), TerminalLastModificationAuthorTag: FIRST(terminalLastModificationAuthorTag){neuronAuthorRegionReturn}}}");
queryParameters.Add(new QueryParameter()
{
Name = nameof(centralGuid),
Value = $"Neuron/{centralGuid.Value.ToString()}"
});
if (relativeGuid.HasValue)
{
queryParameters.Add(new QueryParameter()
{
Name = nameof(relativeGuid),
Value = $"Neuron/{relativeGuid.Value.ToString()}"
});
}
}
var preSynapticParamCount = queryParameters.Count;
// Postsynaptic
NeuronRepository.ApplySynapticFilters(neuronQuery.Postsynaptic, nameof(NeuronQuery.Postsynaptic), queryParameters, queryStringBuilder);
// PostsynapticNot
NeuronRepository.ApplySynapticFilters(neuronQuery.PostsynapticNot, nameof(NeuronQuery.PostsynapticNot), queryParameters, queryStringBuilder, false);
// Presynaptic
NeuronRepository.ApplySynapticFilters(neuronQuery.Presynaptic, nameof(NeuronQuery.Presynaptic), queryParameters, queryStringBuilder);
// PresynapticNot
NeuronRepository.ApplySynapticFilters(neuronQuery.PresynapticNot, nameof(NeuronQuery.PresynapticNot), queryParameters, queryStringBuilder, false);
// Sort and Limit
var lastReturnIndex = queryStringBuilder.ToString().ToUpper().LastIndexOf("RETURN");
queryStringBuilder.Remove(lastReturnIndex, 6);
// were synaptic filters applied?
bool synapticFiltersApplied = preSynapticParamCount < queryParameters.Count;
string sortFieldName = synapticFiltersApplied ? "n.Neuron.Tag" : "n.Tag";
string sortOrder = neuronQuery.SortOrder.HasValue ?
neuronQuery.SortOrder.Value.ToEnumString() :
"ASC";
if (neuronQuery.SortBy.HasValue)
{
sortFieldName = neuronQuery.SortBy.Value.ToEnumString();
if (synapticFiltersApplied)
{
sortFieldName = "n." + sortFieldName;
}
else
{
if (sortFieldName.StartsWith("Neuron."))
{
sortFieldName = sortFieldName.Replace("Neuron.", "n.");
}
else if (sortFieldName.StartsWith("Terminal."))
{
sortFieldName = sortFieldName.Replace("Terminal.", "t.");
}
else
{
sortFieldName = sortFieldName[0].ToString().ToLower() + sortFieldName.Substring(1);
}
}
}
queryStringBuilder.Insert(lastReturnIndex, $"SORT {sortFieldName} {sortOrder} LIMIT @offset, @count RETURN");
queryParameters.Add(new QueryParameter()
{
Name = "offset", Value = NeuronRepository.CalculateOffset(neuronQuery.Page.Value, neuronQuery.PageSize.Value)
});
queryParameters.Add(new QueryParameter()
{
Name = "count", Value = neuronQuery.PageSize.Value
});
return(queryStringBuilder.ToString());
}
public async Task<IEnumerable<Neuron>> GetNeurons(string avatarUrl, string centralId = null, RelativeType type = RelativeType.NotSet, NeuronQuery neuronQuery = null, int? limit = 1000, CancellationToken token = default(CancellationToken))
{
var relatives = await this.neuronQueryClient.GetNeurons(avatarUrl, centralId, type, neuronQuery, limit, token);
if (string.IsNullOrEmpty(centralId))
relatives = relatives.OrderBy(n => n.Tag);
else
{
var posts = relatives.Where(n => n.Type == RelativeType.Postsynaptic);
var pres = relatives.Where(n => n.Type == RelativeType.Presynaptic);
posts = posts.ToList().OrderBy(n => n.Tag);
pres = pres.ToList().OrderBy(n => n.Tag);
relatives = posts.Concat(pres);
}
return relatives;
}
private async Task <QueryResult> GetNeuronByIdWithCentralInternal(string outBaseUrl, string id, string centralId, NeuronQuery neuronQuery, CancellationToken token = default(CancellationToken))
{
return(await HttpNeuronGraphQueryClient.GetNeuronsUnescaped(
outBaseUrl,
$"{HttpNeuronGraphQueryClient.GetNeuronsPathTemplate}/{centralId}/relatives/{id}",
neuronQuery.ToString(),
token,
requestProvider
));
}
public async Task <ActionValidationResult> ReadNeurons(IEnumerable <Guid> neuronIds, string userId, CancellationToken token = default)
{
AssertionConcern.AssertArgumentNotNull(neuronIds, nameof(neuronIds));
neuronIds.ToList().ForEach(g => AssertionConcern.AssertArgumentValid(
guid => guid != Guid.Empty, g, Constants.Messages.Exception.InvalidId, nameof(neuronIds)
));
AssertionConcern.AssertArgumentNotEmpty(userId, Constants.Messages.Exception.InvalidUserId, nameof(userId));
var query = new NeuronQuery()
{
Id = neuronIds.Select(g => g.ToString()),
NeuronActiveValues = ActiveValues.All,
PageSize = neuronIds.Count()
};
// get neurons which are also inactive
var queryResult = await this.neuronGraphQueryClient.GetNeurons(
this.settingsService.CortexGraphOutBaseUrl + "/",
query,
token
);
var actionErrors = new List <ErrorInfo>();
var neuronResults = new List <NeuronValidationResult>();
await this.authorRepository.Initialize();
Author author = await this.authorRepository.GetByUserId(userId);
if (author == null)
{
actionErrors.Add(new ErrorInfo(Constants.Messages.Exception.UnauthorizedUserAccess, ErrorType.Error));
}
else if (queryResult.Neurons.Count() > 0)
{
// loop through each neuron
foreach (var neuron in queryResult.Neurons)
{
var regionTag = neuron.Region.Id != null ? neuron.Region.Tag : "Base";
// get region permit of author user for region
var permit = author.Permits.SingleOrDefault(p =>
p.RegionNeuronId.EqualsString(neuron.Region.Id) &&
p.ReadLevel > 0
);
// does author user have a read permit
if (permit == null)
{
neuronResults.Add(new NeuronValidationResult(Guid.Parse(neuron.Id), new ErrorInfo[]
{
new ErrorInfo(string.Format(Constants.Messages.Exception.UnauthorizedRegionReadTemplate, regionTag), ErrorType.Warning)
}));
}
}
}
return(new ActionValidationResult(
author != null ? author.User.NeuronId : Guid.Empty,
actionErrors.ToArray(),
neuronResults.ToArray()
));
}
private async Task <Domain.Model.QueryResult> GetRelativeCore(Guid guid, Guid?centralGuid, NeuronQuery neuronQuery, CancellationToken token = default(CancellationToken))
{
Domain.Model.QueryResult result = null;
NeuronRepository.FillWithDefaults(neuronQuery, this.settingsService);
using (var db = ArangoDatabase.CreateWithSetting(this.settingsService.DatabaseName))
{
AssertionConcern.AssertStateTrue(await Helper.GraphExists(db), Constants.Messages.Error.GraphNotInitialized);
if (!centralGuid.HasValue)
{
var n = await db.DocumentAsync <Neuron>(guid.ToString());
if (
n != null && (
neuronQuery.NeuronActiveValues.Value.HasFlag(ActiveValues.All) ||
(
Helper.TryConvert(neuronQuery.NeuronActiveValues.Value, out bool activeValue) &&
n.Active == activeValue
)
)
)
{
var region = n.RegionId != null ? await db.DocumentAsync <Neuron>(n.RegionId) : null;
var creationAuthor = (await db.DocumentAsync <Neuron>(n.CreationAuthorId));
var lastModificationAuthor = !string.IsNullOrEmpty(n.LastModificationAuthorId) ?
(await db.DocumentAsync <Neuron>(n.LastModificationAuthorId)) :
null;
var unifiedLastModificationAuthor = !string.IsNullOrEmpty(n.UnifiedLastModificationAuthorId) ?
(await db.DocumentAsync <Neuron>(n.UnifiedLastModificationAuthorId)) :
null;
AssertionConcern.AssertStateTrue(creationAuthor != null, string.Format(Constants.Messages.Error.AuthorNeuronNotFound, n.CreationAuthorId));
result = new Domain.Model.QueryResult()
{
Count = 1,
Neurons = new Domain.Model.NeuronResult[] { new Domain.Model.NeuronResult()
{
Neuron = n,
NeuronCreationAuthorTag = creationAuthor.Tag,
NeuronLastModificationAuthorTag = lastModificationAuthor != null ?
lastModificationAuthor.Tag : string.Empty,
NeuronUnifiedLastModificationAuthorTag = unifiedLastModificationAuthor != null ? unifiedLastModificationAuthor.Tag : string.Empty,
NeuronRegionTag = region != null ? region.Tag : string.Empty
} }
};
}
else
{
result = new Domain.Model.QueryResult()
{
Count = 0,
Neurons = new Domain.Model.NeuronResult[0]
}
};
}
else
{
result = NeuronRepository.GetNeuronResults(centralGuid.Value, guid, this.settingsService.DatabaseName, neuronQuery, token);
}
// KEEP: circular references will now be allowed 2018/10/24
// int c = db.Query()
// .Traversal<Neuron, Terminal>(EdgePrefix + guid.ToString())
// .Depth(1, 999)
// .OutBound()
// .Graph(NeuronRepository.GraphName)
// .Filter(n => n.Vertex.Id == guid.ToString())
// .Select(g => g.Vertex.Id)
// .ToList()
// .Count();
}
return(result);
}
public async Task <QueryResult> GetNeurons(string outBaseUrl, NeuronQuery neuronQuery, CancellationToken token = default(CancellationToken)) => await this.GetNeurons(outBaseUrl, null, neuronQuery, token);
