public async Task <Terminal> Get(Guid guid, Graph.Common.NeuronQuery neuronQuery, CancellationToken cancellationToken = default(CancellationToken))
{
Terminal 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);
var t = await db.DocumentAsync <Terminal>(guid.ToString());
if (
t != null && (
neuronQuery.TerminalActiveValues.Value.HasFlag(Graph.Common.ActiveValues.All) ||
(
Helper.TryConvert(neuronQuery.TerminalActiveValues.Value, out bool activeValue) &&
t.Active == activeValue
)
)
)
{
result = t.CloneExcludeSynapticPrefix();
}
}
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);
}
private static void ApplySynapticFilters(IEnumerable <string> synapticsField, string synapticsFieldName, List <QueryParameter> queryParameters, StringBuilder queryStringBuilder, bool include = true)
{
if (synapticsField != null)
{
var synapticList = synapticsField.ToList();
synapticList.ForEach(s =>
NeuronRepository.WrapQueryString(s, queryStringBuilder, synapticsFieldName, (synapticList.IndexOf(s) + 1), include)
);
queryParameters.AddRange(synapticsField.Select(s =>
new QueryParameter()
{
Name = synapticsFieldName + (synapticList.IndexOf(s) + 1),
Value = $"Neuron/{s}"
}
));
}
}
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);
}
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);
}
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());
}
