private async Task QueryAndPopulateEdgeConnections(
List <SelectValue> selections,
List <object> results,
IGraphRequestContext graphRequestContext)
{
var edgeQueryParameters = _connectionEdgeResolver.ListConnectionEdgeQueryParameter(results)
.Where(x => selections.Any(y => y.FieldName.ToLower() == x.SourceFieldName.ToLower())).ToList();
if (edgeQueryParameters.Count > 0)
{
var connectionEdges = (await GetConnectionEdgeRepository().QueryAsync <ConnectionEdge>(
ConnectionEdgeQueryName,
edgeQueryParameters.ToQueryParameters(), null, graphRequestContext)).ToList();
if (connectionEdges.Count > 0)
{
var accessor = TypeAccessor.Create(results.First().GetType());
var dictionary = new Dictionary <string, object>();
results.ForEach(item => dictionary.Add(accessor.GetKey(item), item));
foreach (var connectionEdge in connectionEdges)
{
if (!dictionary.ContainsKey(connectionEdge.SourceId))
{
throw new InvalidOperationException($"{connectionEdge.SourceId} is invalid.");
}
var sourceObject = dictionary[connectionEdge.SourceId];
var edgeObject = DeserializeObject(connectionEdge.MetaValue, connectionEdge.MetaType);
accessor[sourceObject, connectionEdge.SourceFieldName] = edgeObject;
var selection = selections.SingleOrDefault(s => s.FieldName.ToLower() == connectionEdge.SourceFieldName.ToLower());
if (selection != null)
{
var entity = (await _graphQlRepositoryProvider.QueryAsync(EntityQueryName,
CreateQueryStep(connectionEdge),
graphRequestContext)).SingleOrDefault();
if (entity == null)
{
continue;
}
var edgeObjectTypeAccessor = TypeAccessor.Create(edgeObject.GetType());
edgeObjectTypeAccessor[edgeObject, connectionEdge.MetaFieldName] = entity;
await QueryAndPopulateEdgeConnections(new List <SelectValue> {
selection
}, new List <object> {
entity
}, graphRequestContext);
}
}
}
}
}
private async Task <List <object> > QueryAsync(string queryName, QueryStep queryStep, IGraphRequestContext graphRequestContext,
QueryExecutionContext queryExecutionContext,
List <ConnectionEdgeDestinationFilter> connectionEdgeDestinationFilters)
{
var results = (await _graphQlRepositoryProvider.QueryAsync(queryName, queryStep, graphRequestContext)).ToList();
if (!queryStep.SkipConnectionEdgeCheck && results.Count > 0)
{
await _connectionEdgeHandler.QueryAsync(results, queryStep, graphRequestContext, queryExecutionContext,
connectionEdgeDestinationFilters);
}
return(results);
}
private async Task <List <object> > QueryAsync(string queryName, QueryStep queryStep, IGraphRequestContext graphRequestContext)
{
var results = (await _graphQlRepositoryProvider.QueryAsync(queryName, queryStep, graphRequestContext)).ToList();
if (results.Count > 0)
{
if (results.First().GetType() == typeof(SearchResultModel))
{
return(results);
}
await _connectionEdgeHandler.QueryAsync(results, queryStep, graphRequestContext);
}
return(results);
}
private void SetupConnectionEdgeRepository(string[] idList,
List <ConnectionEdge> connectionEdges, string connectionOtherId, List <object> connectionsOthers)
{
_connectionEdgeRepository.QueryAsync <ConnectionEdge>(Arg.Any <string>(),
Arg.Is <IEnumerable <QueryParameter> >(x =>
x.First().ContextValue.Comparison == Comparisons.Equal &&
x.First().ContextValue.Values.Count == idList.Length &&
x.First().ContextValue.Values.All(v => idList.Contains((string)v))), null, null)
.Returns(Task.FromResult(connectionEdges.AsEnumerable()));
_graphQlRepositoryProvider.QueryAsync(Arg.Any <string>(),
Arg.Is <QueryStep>(x =>
x.QueryParameters.First().ContextValue.Comparison == Comparisons.Equal &&
x.QueryParameters.First().ContextValue.Values.Count == 1 &&
x.QueryParameters.First().ContextValue.Values.First().Equals(connectionOtherId)), null)
.Returns(Task.FromResult(connectionsOthers.AsEnumerable()));
}
private async Task <object> GetValue(
TypeAccessor edgeObjectTypeAccessor,
ConnectionEdge connectionEdge,
IGraphRequestContext graphRequestContext,
List <ConnectionEdgeDestinationFilter> connectionEdgeDestinationFilters,
QueryExecutionContext queryExecutionContext)
{
var member = edgeObjectTypeAccessor.GetMembers().Single(x => x.Name == connectionEdge.MetaFieldName);
var destTypeAccessor = TypeAccessor.Create(member.Type);
var destQueryMember = destTypeAccessor.GetMembers().Single(m => m.GetAttribute(typeof(KeyAttribute), true) != null);
var qp = new QueryStep();
qp.QueryParameters.Add(new QueryParameter
{
ContextValue = new ContextValue {
Comparison = Comparisons.Equal, Values = new List <object> {
connectionEdge.DestinationId
}
},
MemberModel = new ModelMember(member.Type, destTypeAccessor, destQueryMember, false)
});
if (connectionEdgeDestinationFilters != null)
{
connectionEdgeDestinationFilters.Where(x => x.Type == member.Type.AssemblyQualifiedName)
.ToList().ForEach(connectionEdgeDestinationFilter =>
{
qp.QueryParameters.Add(new QueryParameter
{
ContextValue = new ContextValue {
Comparison = Comparisons.Equal, Values = connectionEdgeDestinationFilter.Mapper(queryExecutionContext)
},
MemberModel = connectionEdgeDestinationFilter.ModelMember
});
});
}
var entities = (await _graphQlRepositoryProvider.QueryAsync(EntityQueryName, qp, graphRequestContext)).ToList();
if (entities.Count > 1)
{
throw new InvalidOperationException(MultipleEntitiesDetectedError);
}
return(entities.SingleOrDefault());
}
