private async Task <object> ResolveOrdersConnectionAsync(IMediator mediator, IResolveConnectionContext <object> context)
{
var query = context.ExtractQuery <SearchOrderQuery>();
context.CopyArgumentsToUserContext();
var allCurrencies = await _currencyService.GetAllCurrenciesAsync();
//Store all currencies in the user context for future resolve in the schema types
context.SetCurrencies(allCurrencies, query.CultureName);
var authorizationResult = await _authorizationService.AuthorizeAsync(context.GetCurrentPrincipal(), query, new CanAccessOrderAuthorizationRequirement());
if (!authorizationResult.Succeeded)
{
throw new AuthorizationError($"Access denied");
}
var response = await mediator.Send(query);
foreach (var customerOrderAggregate in response.Results)
{
context.SetExpandedObjectGraph(customerOrderAggregate);
}
return(new PagedConnection <CustomerOrderAggregate>(response.Results, query.Skip, query.Take, response.TotalCount));
}
private async Task <object> ResolveConnectionAsync(IMediator mediator, IResolveConnectionContext <object> context)
{
var first = context.First;
var skip = Convert.ToInt32(context.After ?? 0.ToString());
var query = context.GetCartQuery <SearchCartQuery>();
query.Skip = skip;
query.Take = first ?? context.PageSize ?? 10;
query.Sort = context.GetArgument <string>("sort");
query.Filter = context.GetArgument <string>("filter");
query.IncludeFields = context.SubFields.Values.GetAllNodesPaths().ToArray();
context.CopyArgumentsToUserContext();
var authorizationResult = await _authorizationService.AuthorizeAsync(context.GetCurrentPrincipal(), query, new CanAccessCartAuthorizationRequirement());
if (!authorizationResult.Succeeded)
{
throw new ExecutionError($"Access denied");
}
var response = await mediator.Send(query);
foreach (var cartAggregate in response.Results)
{
context.SetExpandedObjectGraph(cartAggregate);
}
return(new PagedConnection <CartAggregate>(response.Results, skip, Convert.ToInt32(context.After ?? 0.ToString()), response.TotalCount));
}
private async Task <object> ResolveCkAttributesQuery(IResolveConnectionContext <object> arg)
{
Logger.Debug("GraphQL query handling of contruction kit attributes started");
var graphQlUserContext = (GraphQLUserContext)arg.UserContext;
using var session = await graphQlUserContext.TenantContext.Repository.StartSessionAsync();
session.StartTransaction();
int?offset = arg.GetOffset();
DataQueryOperation dataQueryOperation = arg.GetDataQueryOperation();
arg.TryGetArgument(Statics.AttributeIdArg, out string key);
arg.TryGetArgument(Statics.AttributeIdsArg, new List <string>(), out IEnumerable <string> keys);
var keysList = keys.ToList();
if (!keysList.Any() && key != null)
{
keysList.Add(key);
}
var resultSet =
await graphQlUserContext.TenantContext.Repository.GetCkAttributesAsync(session, keysList, dataQueryOperation, offset, arg.First);
await session.CommitTransactionAsync();
Logger.Debug("GraphQL query handling returning data for contruction kit attributes");
return(ConnectionUtils.ToConnection(resultSet.Result.Select(CkAttributeDtoType.CreateCkAttributeDto), arg,
resultSet.TotalCount > 0 ? offset.GetValueOrDefault(0) : 0, (int)resultSet.TotalCount));
}
private async Task <object> ConnectionResolver(IResolveConnectionContext <object> connectionContext)
{
IEnumerable <TSource> list = await QueryAsync(connectionContext);
// ReSharper disable once PossibleInvalidOperationException
return(await connectionContext.GetConnectionAsync(list, _pageLimit.Value));
}
private async Task <object> ResolveRtEntitiesQuery(IResolveConnectionContext <RtEntityDto> ctx)
{
var graphQlContext = (GraphQLUserContext)ctx.UserContext;
using var session = await graphQlContext.TenantContext.Repository.StartSessionAsync();
session.StartTransaction();
var ckId = (string)ctx.FieldDefinition.Metadata[Statics.CkId];
var roleId = (string)ctx.FieldDefinition.Metadata[Statics.RoleId];
var graphDirections = (GraphDirections)ctx.FieldDefinition.Metadata[Statics.GraphDirection];
int?offset = ctx.GetOffset();
DataQueryOperation dataQueryOperation = ctx.GetDataQueryOperation();
if (ctx.Source.RtId != null)
{
var resultSet = await graphQlContext.TenantContext.Repository.GetRtAssociationTargetsAsync(session,
ctx.Source.RtId.Value.ToObjectId(), roleId, ckId,
graphDirections, dataQueryOperation, offset, ctx.First);
return(ConnectionUtils.ToConnection(resultSet.Result.Select(RtEntityDtoType.CreateRtEntityDto), ctx,
resultSet.TotalCount > 0 ? offset.GetValueOrDefault(0) : 0, (int)resultSet.TotalCount));
}
await session.CommitTransactionAsync();
return(ConnectionUtils.ToConnection(new RtEntityDto[] { }, ctx, 0, 0));
}
private async Task <object> ResolveConnectionAsync(IResolveConnectionContext <object> context)
{
var first = context.First;
var skip = Convert.ToInt32(context.After ?? 0.ToString());
var response = await _mediator.Send(new GetRecommendationsRequest
{
Skip = skip,
Take = first ?? 20,
Scenario = context.GetArgument <string>("scenario"),
ItemId = context.GetArgument <string>("itemId"),
UserId = context.GetArgument <string>("userId")
});
var result = new Connection <ProductRecommendation>()
{
Edges = response.Products.Select((x, index) =>
new Edge <ProductRecommendation>()
{
Cursor = (skip + index).ToString(),
Node = x,
})
.ToList(),
PageInfo = new PageInfo()
{
HasNextPage = response.TotalCount > (skip + first),
HasPreviousPage = skip > 0,
StartCursor = skip.ToString(),
EndCursor = Math.Min(response.TotalCount, (int)(skip + first)).ToString()
},
TotalCount = response.TotalCount,
};
return(result);
}
public static ArraySliceMetrics <TSource> Create <TSource, TParent>(
IList <TSource> slice,
IResolveConnectionContext <TParent> context,
bool strictCheck = true
)
{
return(new ArraySliceMetrics <TSource>(slice, context.First, context.After, context.Last, context.Before, strictCheck));
}
public static Connection <TSource> ToConnection <TSource, TParent>(
IEnumerable <TSource> items,
IResolveConnectionContext <TParent> context,
bool strictCheck = true
)
{
var list = items.ToList();
return(ToConnection(list, context, sliceStartIndex: 0, totalCount: list.Count, strictCheck: true));
}
public static ConnectionArguments GetConnectionArguments <T>(this IResolveConnectionContext <T> ctx)
{
return(new ConnectionArguments
{
First = ctx.First,
After = ctx.After,
Last = ctx.Last,
Before = ctx.Before,
});
}
private async Task <object> ResolveGenericRtEntitiesQuery(IResolveConnectionContext <object> arg)
{
Logger.Debug("GraphQL query handling for generic runtime entity started");
var graphQlUserContext = (GraphQLUserContext)arg.UserContext;
var ckId = arg.GetArgument <string>(Statics.CkIdArg);
using var session = await graphQlUserContext.TenantContext.Repository.StartSessionAsync();
session.StartTransaction();
int?offset = arg.GetOffset();
DataQueryOperation dataQueryOperation = arg.GetDataQueryOperation();
arg.TryGetArgument(Statics.RtIdArg, out OspObjectId? key);
arg.TryGetArgument(Statics.RtIdsArg, new List <ObjectId>(), out IEnumerable <ObjectId> keys);
var keysList = keys.ToList();
if (keysList.Any())
{
var resultSetIds =
await graphQlUserContext.TenantContext.Repository.GetRtEntitiesByIdAsync(session, ckId, keysList, dataQueryOperation,
offset, arg.First);
Logger.Debug("GraphQL query handling returning data by keys");
return(ConnectionUtils.ToConnection(resultSetIds.Result.Select(RtEntityDtoType.CreateRtEntityDto), arg,
resultSetIds.TotalCount > 0 ? offset.GetValueOrDefault(0) : 0, (int)resultSetIds.TotalCount));
}
if (key.HasValue)
{
var result = await graphQlUserContext.TenantContext.Repository.GetRtEntityAsync(session, new RtEntityId(ckId, key.Value));
var resultList = new List <RtEntityDto>();
if (result != null)
{
resultList.Add(RtEntityDtoType.CreateRtEntityDto(result));
}
Logger.Debug("GraphQL query handling returning data by key");
return(ConnectionUtils.ToConnection(resultList, arg));
}
var resultSet =
await graphQlUserContext.TenantContext.Repository.GetRtEntitiesByTypeAsync(session, ckId, dataQueryOperation, offset,
arg.First);
await session.CommitTransactionAsync();
Logger.Debug("GraphQL query handling returning data");
return(ConnectionUtils.ToConnection(resultSet.Result.Select(RtEntityDtoType.CreateRtEntityDto), arg,
resultSet.TotalCount > 0 ? offset.GetValueOrDefault(0) : 0, (int)resultSet.TotalCount));
}
internal static int?GetOffset <TEntity>(this IResolveConnectionContext <TEntity> ctx)
{
int?offset = null;
if (!string.IsNullOrEmpty(ctx.After))
{
offset = ConnectionUtils.CursorToOffset(ctx.After) + 1;
}
return(offset);
}
public static Connection <U> GetPagedResults <T, U>(this IResolveConnectionContext <T> context, StarWarsData data, List <string> ids) where U : StarWarsCharacter
{
List <string> idList;
List <U> list;
string cursor;
string endCursor;
var pageSize = context.PageSize ?? 20;
if (context.IsUnidirectional || context.After != null || context.Before == null)
{
if (context.After != null)
{
idList = ids
.SkipWhile(x => !Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(x)).Equals(context.After))
.Take(context.First ?? pageSize).ToList();
}
else
{
idList = ids
.Take(context.First ?? pageSize).ToList();
}
}
else
{
if (context.Before != null)
{
idList = ids.Reverse <string>()
.SkipWhile(x => !Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(x)).Equals(context.Before))
.Take(context.Last ?? pageSize).ToList();
}
else
{
idList = ids.Reverse <string>()
.Take(context.Last ?? pageSize).ToList();
}
}
list = data.GetCharactersAsync(idList).Result as List <U> ?? throw new InvalidOperationException($"GetCharactersAsync method should return list of '{typeof(U).Name}' items.");
cursor = list.Count > 0 ? list.Last().Cursor : null;
endCursor = ids.Count > 0 ? Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(ids.Last())) : null;
return(new Connection <U>
{
Edges = list.Select(x => new Edge <U> {
Cursor = x.Cursor, Node = x
}).ToList(),
TotalCount = list.Count,
PageInfo = new PageInfo
{
EndCursor = endCursor,
HasNextPage = endCursor != null && cursor != endCursor,
}
});
}
private async Task <object> ResolveConnectionAsync(IMediator mediator, IResolveConnectionContext <OrganizationAggregate> context)
{
var first = context.First;
var skip = Convert.ToInt32(context.After ?? 0.ToString());
var response = await mediator.Send(new SearchOrganizationMembersQuery
{
OrganizationId = context.Source.Organization.Id,
Take = first ?? 20,
Skip = skip,
SearchPhrase = context.GetArgument <string>("searchPhrase")
});
return(new PagedConnection <ContactAggregate>(response.Results.Select(x => new ContactAggregate(x as Contact)), skip, Convert.ToInt32(context.After ?? 0.ToString()), response.TotalCount));
}
/// <summary>
/// Factory method to create an <see cref="SliceMetrics{TSource}"/>
/// </summary>
public static SliceMetrics <TSource> Create <TSource>(
IQueryable <TSource> source,
IResolveConnectionContext context
)
{
var totalCount = source.Count();
var edges = context.EdgesToReturn(totalCount);
var nodes = source.Skip(edges.StartOffset).Take(edges.Count);
return(new(
source : nodes.ToList(),
edges,
totalCount
));
}
/// <summary>
/// Calculates an <see cref="EdgeRange"/> object based on the current
/// <see cref="IResolveConnectionContext"/> and the provided edge items count
/// </summary>
/// <param name="context"></param>
/// <param name="edgeCount"></param>
/// <returns></returns>
public static EdgeRange EdgesToReturn(
this IResolveConnectionContext context,
int edgeCount
)
{
var first = (!context.First.HasValue && !context.Last.HasValue)
? (context.PageSize ?? edgeCount)
: default(int?);
return(RelayPagination.CalculateEdgeRange(
edgeCount,
first ?? context.First,
context.After,
context.Last,
context.Before
));
}
/// <summary>
/// Gets Connection.
/// </summary>
/// <typeparam name="T">T item.</typeparam>
/// <param name="context">Connection context.</param>
/// <param name="enumerable">An IEnumerable of T items.</param>
/// <param name="defaultPageLimit">Default page limit.</param>
/// <returns></returns>
public static async Task <Connection <T> > GetConnectionAsync <T>(this IResolveConnectionContext <object> context, IEnumerable <T> enumerable, int defaultPageLimit = 10)
{
// Ref: https://graphql.org/learn/pagination/
var list = enumerable.ToList();
var total = list.Count;
int skip = 0;
int take = defaultPageLimit;
var edges = list.Select(TransformToEdge).ToList();
if (!string.IsNullOrEmpty(context.After))
{
skip = GetIndex(context.After) + 1;
}
if (context.First.HasValue)
{
take = context.First.Value;
}
var hasNextPage = total > skip + take;
var filtered = edges.Skip(skip).Take(take).ToList();
var first = filtered.FirstOrDefault().GetCursor();
var connection = new Connection <T>
{
TotalCount = total,
Edges = filtered,
PageInfo = new PageInfo
{
StartCursor = first,
EndCursor = filtered.LastOrDefault().GetCursor(),
HasNextPage = hasNextPage,
HasPreviousPage = GetIndex(first) > 0
}
};
return(await Task.FromResult(connection));
}
public static Connection <TSource> ToConnection <TSource, TParent>(
IEnumerable <TSource> slice,
IResolveConnectionContext <TParent> context,
int sliceStartIndex,
int totalCount,
bool strictCheck = true
)
{
var sliceList = slice as IList <TSource> ?? slice.ToList();
var metrics = ArraySliceMetrics.Create(
sliceList,
context,
sliceStartIndex,
totalCount,
strictCheck
);
var edges = metrics.Slice.Select((item, i) => new Edge <TSource>
{
Node = item,
Cursor = OffsetToCursor(metrics.StartOffset + i)
})
.ToList();
var firstEdge = edges.FirstOrDefault();
var lastEdge = edges.LastOrDefault();
return(new Connection <TSource>
{
Edges = edges,
TotalCount = totalCount,
PageInfo = new PageInfo
{
StartCursor = firstEdge?.Cursor,
EndCursor = lastEdge?.Cursor,
HasPreviousPage = metrics.HasPrevious,
HasNextPage = metrics.HasNext,
}
});
}
private async Task <object> ResolveOrdersConnectionAsync(IMediator mediator, IResolveConnectionContext <object> context)
{
var first = context.First;
var skip = Convert.ToInt32(context.After ?? 0.ToString());
var request = new SearchOrderQuery
{
Skip = skip,
Take = first ?? context.PageSize ?? 10,
Filter = context.GetArgument <string>("filter"),
Sort = context.GetArgument <string>("sort"),
CultureName = context.GetArgument <string>(nameof(Currency.CultureName).ToCamelCase()),
CustomerId = context.GetArgumentOrValue <string>("userId")
};
context.CopyArgumentsToUserContext();
var allCurrencies = await _currencyService.GetAllCurrenciesAsync();
//Store all currencies in the user context for future resolve in the schema types
context.SetCurrencies(allCurrencies, request.CultureName);
var authorizationResult = await _authorizationService.AuthorizeAsync(context.GetCurrentPrincipal(), request, new CanAccessOrderAuthorizationRequirement());
if (!authorizationResult.Succeeded)
{
throw new ExecutionError($"Access denied");
}
var response = await mediator.Send(request);
foreach (var customerOrderAggregate in response.Results)
{
context.SetExpandedObjectGraph(customerOrderAggregate);
}
return(new PagedConnection <CustomerOrderAggregate>(response.Results, skip, Convert.ToInt32(context.After ?? 0.ToString()), response.TotalCount));
}
private object ResolveAttributes(IResolveConnectionContext <CkEntityDto> ctx)
{
var graphQlContext = (GraphQLUserContext)ctx.UserContext;
ctx.TryGetArgument(Statics.AttributeNamesFilterArg, out IEnumerable <string> filterAttributeNames);
var entityCacheItem = graphQlContext.TenantContext.CkCache.GetEntityCacheItem(ctx.Source.CkId);
IEnumerable <AttributeCacheItem> resultList;
if (filterAttributeNames == null)
{
resultList = entityCacheItem.Attributes.Values;
}
else
{
resultList =
entityCacheItem.Attributes.Values.Where(a =>
filterAttributeNames.Contains(StringExtensions.ToCamelCase(a.AttributeName)));
}
return(ConnectionUtils.ToConnection(resultList.Select(CreateCkEntityAttributeDto), ctx));
}
public IResult <IQueryable <Brewery> > ResolveNearbyBreweries(IResolveConnectionContext context)
{
var latitude = GetLatitude(context);
var longitude = GetLongitude(context);
if (latitude.HasValue && longitude.HasValue)
{
var id = GetBreweryId(context);
var within = context.GetArgument("within", 25);
return(_breweryConductor
.FindAllByLocation(
latitude.Value,
longitude.Value,
within)
.Filter(b => id == null || b.Id != id.Value)
.Include(
nameof(Brewery.BreweryTags),
context.ContainsField("tag_list")));
}
return(new Result <IQueryable <Brewery> >(Enumerable.Empty <Brewery>().AsQueryable()));
}
private object ResolveAttributes(IResolveConnectionContext <RtEntityDto> ctx)
{
var graphQlContext = (GraphQLUserContext)ctx.UserContext;
var filterAttributeNames = ctx.GetArgument <IEnumerable <string> >(Statics.AttributeNamesFilterArg);
var entityCacheItem = graphQlContext.TenantContext.CkCache.GetEntityCacheItem(ctx.Source.CkId);
IEnumerable <AttributeCacheItem> resultList;
if (filterAttributeNames == null)
{
resultList = entityCacheItem.Attributes.Values;
}
else
{
resultList =
entityCacheItem.Attributes.Values.Where(a =>
filterAttributeNames.Contains(a.AttributeName.ToCamelCase()));
}
return(ConnectionUtils.ToConnection(resultList.Select(item => CreateRtEntityAttributeDto((RtEntity)ctx.Source.UserContext, item)),
ctx));
}
/// <summary>
/// From the connection context, <see cref="IResolveConnectionContext"/>,
/// it creates a <see cref="Connection{TSource}"/> based on the given <see cref="IEnumerable{TSource}"/>
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <param name="context"></param>
/// <param name="items"></param>
/// <param name="totalCount"></param>
/// <returns></returns>
public static Connection <TSource> ToConnection <TSource>(
this IResolveConnectionContext context,
IEnumerable <TSource> items,
int?totalCount = null
)
{
var metrics = SliceMetrics.Create(
items,
context,
totalCount
);
var edges = metrics.Slice
.Select((item, i) => new Edge <TSource>
{
Node = item,
Cursor = ConnectionUtils.OffsetToCursor(metrics.StartIndex + i)
})
.ToList();
var firstEdge = edges.FirstOrDefault();
var lastEdge = edges.LastOrDefault();
return(new Connection <TSource>
{
Edges = edges,
TotalCount = metrics.TotalCount,
PageInfo = new PageInfo
{
StartCursor = firstEdge?.Cursor,
EndCursor = lastEdge?.Cursor,
HasPreviousPage = metrics.HasPrevious,
HasNextPage = metrics.HasNext,
}
});
}
private static async Task <object> ResolvePropertiesConnectionAsync(IMediator mediator, IResolveConnectionContext <object> context)
{
var first = context.First;
var skip = Convert.ToInt32(context.After ?? 0.ToString());
var query = new SearchPropertiesQuery
{
Skip = skip,
Take = first ?? context.PageSize ?? 10,
CatalogId = (string)context.UserContext["catalog"],
Types = context.GetArgument <object[]>("types"),
Filter = context.GetArgument <string>("filter")
};
var response = await mediator.Send(query);
return(new PagedConnection <Property>(response.Result.Results, query.Skip, query.Take, response.Result.TotalCount));
}
private static async Task <object> ResolveConnectionAsync(IMediator madiator, IResolveConnectionContext <ExpProduct> context)
{
var first = context.First;
var skip = Convert.ToInt32(context.After ?? 0.ToString());
var criteria = new ProductAssociationSearchCriteria
{
Skip = skip,
Take = first ?? context.PageSize ?? 10,
// We control the resulting product structure by passing IncludeFields, and to prevent forced reduction of already loaded fields, you need to pass ItemResponseGroup.Full
// in any case, the object will be loaded from the index, and the response group will not affect overall performance
ResponseGroup = ItemResponseGroup.Full.ToString(),
Keyword = context.GetArgument <string>("query"),
Group = context.GetArgument <string>("group"),
ObjectIds = new[] { context.Source.CatalogProduct.Id }
};
var response = await madiator.Send(new SearchProductAssociationsRequest { Criteria = criteria });
return(new Connection <ProductAssociation>()
{
Edges = response.Result.Results
.Select((x, index) =>
new Edge <ProductAssociation>()
{
Cursor = (skip + index).ToString(),
Node = x,
})
.ToList(),
PageInfo = new PageInfo()
{
HasNextPage = response.Result.TotalCount > (skip + first),
HasPreviousPage = skip > 0,
StartCursor = skip.ToString(),
EndCursor = Math.Min(response.Result.TotalCount, (int)(skip + first)).ToString()
},
TotalCount = response.Result.TotalCount,
});
}
public ScopedResolveConnectionContextAdapter(IResolveConnectionContext <TSource> baseContext, IServiceProvider serviceProvider)
{
_baseContext = baseContext ?? throw new ArgumentNullException(nameof(baseContext));
RequestServices = serviceProvider;
}
private static async Task <object> ResolveConnectionAsync(IMediator mediator, IResolveConnectionContext <DynamicProperty> context)
{
int.TryParse(context.After, out var skip);
var query = context.GetDynamicPropertiesQuery <SearchDynamicPropertyDictionaryItemQuery>();
query.PropertyId = context.Source.Id;
query.Skip = skip;
query.Take = context.First ?? context.PageSize ?? 10;
query.Sort = context.GetArgument <string>("sort");
query.Filter = context.GetArgument <string>("filter");
context.CopyArgumentsToUserContext();
var response = await mediator.Send(query);
return(new PagedConnection <DynamicPropertyDictionaryItem>(response.Results, query.Skip, query.Take, response.TotalCount));
}
private static async Task <object> ResolveConnectionAsync(IMediator mediator, IResolveConnectionContext <object> context)
{
var first = context.First;
var skip = Convert.ToInt32(context.After ?? 0.ToString());
var includeFields = context.SubFields.Values.GetAllNodesPaths().Select(x => x.TrimStart("items.")).ToArray();
var request = new SearchProductRequest
{
Skip = skip,
Take = first ?? context.PageSize ?? 10,
Query = context.GetArgument <string>("query"),
Filter = context.GetArgument <string>("filter"),
Facet = context.GetArgument <string>("facet"),
Fuzzy = context.GetArgument <bool>("fuzzy"),
Sort = context.GetArgument <string>("sort"),
IncludeFields = includeFields.ToArray(),
};
var response = await mediator.Send(request);
return(new ProductsConnection <ExpProduct>()
{
Edges = response.Results
.Select((x, index) =>
new Edge <ExpProduct>()
{
Cursor = (skip + index).ToString(),
Node = x,
})
.ToList(),
PageInfo = new PageInfo()
{
HasNextPage = response.TotalCount > (skip + first),
HasPreviousPage = skip > 0,
StartCursor = skip.ToString(),
EndCursor = Math.Min(response.TotalCount, (int)(skip + first)).ToString()
},
TotalCount = response.TotalCount,
Facets = response.Facets
});
}
private static async Task <object> ResolveConnectionAsync(IMediator mediator, IResolveConnectionContext <Property> context)
{
var first = context.First;
int.TryParse(context.After, out var skip);
var query = new SearchPropertyDictionaryItemQuery
{
Skip = skip,
Take = first ?? context.PageSize ?? 10,
PropertyIds = new[] { context.Source.Id }
};
var response = await mediator.Send(query);
return(new PagedConnection <PropertyDictionaryItem>(response.Result.Results, query.Skip, query.Take, response.Result.TotalCount));
}
private static async Task <object> ResolveProductsConnectionAsync(IMediator mediator, IResolveConnectionContext <object> context)
{
var first = context.First;
var skip = Convert.ToInt32(context.After ?? 0.ToString());
var includeFields = context.SubFields.Values.GetAllNodesPaths();
//PT-5371: Need to be able get entire query from context and read all arguments to the query properties
var query = context.GetCatalogQuery <SearchProductQuery>();
query.IncludeFields = includeFields;
var productIds = context.GetArgument <List <string> >("productIds");
if (productIds.IsNullOrEmpty())
{
query.Skip = skip;
query.Take = first ?? context.PageSize ?? 10;
query.Query = context.GetArgument <string>("query");
query.Filter = context.GetArgument <string>("filter");
query.Facet = context.GetArgument <string>("facet");
query.Fuzzy = context.GetArgument <bool>("fuzzy");
query.FuzzyLevel = context.GetArgument <int?>("fuzzyLevel");
query.Sort = context.GetArgument <string>("sort");
}
else
{
query.ObjectIds = productIds.ToArray();
query.Take = productIds.Count;
}
var response = await mediator.Send(query);
var currencyCode = context.GetArgumentOrValue <string>("currencyCode");
if (string.IsNullOrWhiteSpace(currencyCode))
{
context.SetCurrency(response.Currency);
}
return(new ProductsConnection <ExpProduct>(response.Results, query.Skip, query.Take, response.TotalCount)
{
Facets = response.Facets
});
}
private static async Task <object> ResolveCategoriesConnectionAsync(IMediator mediator, IResolveConnectionContext <object> context)
{
var first = context.First;
var skip = Convert.ToInt32(context.After ?? 0.ToString());
var includeFields = context.SubFields.Values.GetAllNodesPaths().Select(x => x.Replace("items.", "")).ToArray();
var query = context.GetCatalogQuery <SearchCategoryQuery>();
var categoryIds = context.GetArgument <List <string> >("categoryIds");
query.IncludeFields = includeFields;
if (categoryIds.IsNullOrEmpty())
{
query.Skip = skip;
query.Take = first ?? context.PageSize ?? 10;
query.Query = context.GetArgument <string>("query");
query.Filter = context.GetArgument <string>("filter");
query.Facet = context.GetArgument <string>("facet");
query.Fuzzy = context.GetArgument <bool>("fuzzy");
query.FuzzyLevel = context.GetArgument <int?>("fuzzyLevel");
query.Sort = context.GetArgument <string>("sort");
}
else
{
query.ObjectIds = categoryIds.ToArray();
query.Take = categoryIds.Count;
}
var response = await mediator.Send(query);
return(new PagedConnection <ExpCategory>(response.Results, query.Skip, query.Take, response.TotalCount));
}
