public async Task <RestCollectionData> QueryDataAsync(IRestCollectionQuery query)
{
if (query != null)
{
if (query.FilterInstructions != null && query.FilterInstructions.Any())
{
throw new NotImplementedException("Not implemented filtering in mock collection.");
}
if (query.SortInstructions != null && query.SortInstructions.Any())
{
throw new NotImplementedException("Not implemented sorting in mock collection.");
}
if (query.SelectFields != null && query.SelectFields.Any())
{
throw new NotImplementedException("Not implemented selecting in mock collection.");
}
}
IEnumerable <RestItemData> items = List.Select((s, i) => new RestItemData(new
{
Index = i,
Value = s
}));
return(new RestCollectionData(items, null));
}
public ContextQueryBuilder(IEngineContext <TItem> context, [CanBeNull] IRestCollectionQuery query)
{
_query = query;
_context = context;
_pager = new QueryablePager <TItem>(_query?.PageInstruction);
}
internal string BuildString([CanBeNull] IRestCollectionQuery query)
{
if (query == null)
{
return(null);
}
var builder = new QueryStringBuilder();
if (query.SelectFields != null)
{
AppendSelector(builder, query.SelectFields);
}
if (query.FilterInstructions != null)
{
AppendFilters(builder, query.FilterInstructions);
}
if (query.SortInstructions != null)
{
AppendSortOrder(builder, query.SortInstructions);
}
// TODO page size
return(builder.ToString());
}
internal NameSwitcherQuery([NotNull] IRestCollectionQuery underlyingQuery, [NotNull] INamingConventionSwitcher switcher)
{
Debug.Assert(underlyingQuery != null);
Debug.Assert(switcher != null);
_underlyingQuery = underlyingQuery;
_switcher = switcher;
}
public async Task <ResourceBody> GetAsync(IRestCollectionQuery query)
{
QueryValidationUtility.EnsureValidQuery(query);
RestCollectionData collectionData = await Collection.QueryDataAsync(query);
PageLinks pageLinks = Context.Services.PageLinkCalculator.Calculate(query?.PageInstruction, collectionData.PageDetails);
return(new CollectionBody(collectionData.Items, pageLinks));
}
internal static void EnsureValidQuery([CanBeNull] IRestCollectionQuery query)
{
if (query == null)
{
return;
}
if (query.PageInstruction != null && query.PageInstruction.Size <= 0)
{
throw new InvalidOperationException("Page size must be set to a value above 0.");
}
}
private IEnumerable <RestItemData> QueryData(IRestCollectionQuery query)
{
if (query?.SelectFields != null)
{
throw new NotImplementedException("Test collection not implemented selecting specific fields.");
}
foreach (TEntity entity in Entities)
{
yield return(new RestItemData(entity));
}
}
public async Task <RestCollectionData> QueryDataAsync(IRestCollectionQuery query)
{
using (HttpClient client = HttpClientCreator.Create())
{
var queryStringBuilder = new CollectionQueryStringBuilder(new CollectionQueryStringConfiguration());
string fullUrl = UriUtilities.AppendQueryString(Path, queryStringBuilder.BuildString(query));
HttpResponseMessage response = await client.GetAsync(fullUrl);
var queriedData = await Serializer.DeserializeAsync <IEnumerable <RestItemData> >(response);
return(new RestCollectionData(queriedData, null)); // TODO: fill page details
}
}
public async Task <Acknowledgment> DeleteAllAsync(IRestCollectionQuery query)
{
using (HttpClient client = HttpClientCreator.Create())
{
var queryStringBuilder = new CollectionQueryStringBuilder(new CollectionQueryStringConfiguration());
string fullUrl = UriUtilities.AppendQueryString(Path, queryStringBuilder.BuildString(query));
HttpResponseMessage response = await client.DeleteAsync(fullUrl);
Acknowledgment acknowledgment = await EnsureSuccessAsync(response);
return(acknowledgment);
}
}
public static IRestCollectionQuery TryWrapQuery([NotNull] IRestCollectionQuery underlyingQuery, [CanBeNull] INamingConventionSwitcher nameSwitcher)
{
if (underlyingQuery == null)
{
throw new ArgumentNullException(nameof(underlyingQuery));
}
if (nameSwitcher != null)
{
return(new NameSwitcherQuery(underlyingQuery, nameSwitcher));
}
return(underlyingQuery);
}
public async Task <RestCollectionData> QueryDataAsync(IRestCollectionQuery query)
{
await _context.Repository.InitializeAsync();
var fieldAuth = new FieldAuthChecker <TItem>(_context.Fields, _context.AuthorizationChecker, null);
IEnumerable <string> fields = fieldAuth.GetOrEnsureFields(query?.SelectFields, 1);
var selector = new QueryableFieldSelector <TItem>(_context.Fields.GetReaders(fields));
var queryBuilder = new ContextQueryBuilder <TItem>(_context, query);
IQueryable <TItem> items = queryBuilder.BuildQueryable();
QueriedDataIterator queriedData = await selector.SelectFieldsOnlyAsync(items, _context.Repository.ForEachAsync);
PageDetails pageDetails = queryBuilder.GetPageDetails(queriedData);
return(new RestCollectionData(queriedData, pageDetails));
}
public async Task <RestDictionaryData> QueryDataAsync(IRestCollectionQuery query)
{
await _context.Repository.InitializeAsync();
var queryBuilder = new ContextQueryBuilder <TItem>(_context, query);
IQueryable <TItem> items = queryBuilder.BuildQueryable();
var fieldAuth = new FieldAuthChecker <TItem>(_context.Fields, _context.AuthorizationChecker, null);
IEnumerable <string> fields = fieldAuth.GetOrEnsureFields(query?.SelectFields, 1);
var readers = _context.Fields.GetReaders(fields);
readers.Add(IDENTIFIER_FIELD_NAME, new IdentifierFieldReader <TItem>(_namedReferenceInfo));
var selector = new QueryableFieldSelector <TItem>(readers);
QueriedDataIterator queriedData = await selector.SelectFieldsOnlyAsync(items, _context.Repository.ForEachAsync);
PageDetails pageDetails = queryBuilder.GetPageDetails(queriedData);
var dictionaryData = GetKeys(queriedData).ToDictionary(k => k.Key, v => (object)v.Value);
return(new RestDictionaryData(dictionaryData, pageDetails));
}
public async Task <Acknowledgment> DeleteAllAsync(IRestCollectionQuery query)
{
_context.Transaction.StartTransaction();
await _context.Repository.InitializeAsync();
var queryBuilder = new ContextQueryBuilder <TItem>(_context, query);
IQueryable <TItem> items = queryBuilder.BuildQueryable();
foreach (TItem item in items.ToList())
{
var loadedItem = new AlreadyLoadedItem <TItem>(item, string.Empty);
if (!_context.AuthorizationChecker.CanDeleteItem(loadedItem))
{
throw new NotAuthorizedForItemException(AuthorizableVerb.Delete);
}
_context.Repository.MarkDeleted(item);
}
await _context.Transaction.SaveChangesAsync();
return(new Acknowledgment());
}
public async Task <ResourceBody> GetAsync(IRestCollectionQuery query)
{
RestItemData item = await Item.GetDataAsync(query?.SelectFields);
return(new ItemBody(item));
}
public Task <Acknowledgment> DeleteAllAsync(IRestCollectionQuery query)
{
throw new NotImplementedException();
}
public Task <Acknowledgment> DeleteAllAsync(IRestCollectionQuery query)
{
throw new NotImplementedException("Test collection not implemented deleting.");
}
public async Task <RestCollectionData> QueryDataAsync(IRestCollectionQuery query)
{
return(new RestCollectionData(QueryData(query), null));
}
public async Task <ResourceBody> GetAsync(IRestCollectionQuery query)
{
object value = await Scalar.GetAsync();
return(new ScalarBody(value));
}
public async Task <RestDictionaryData> QueryDataAsync(IRestCollectionQuery query)
{
RestCollectionData items = await _memoryRestCollection.QueryDataAsync(query);
return(new RestDictionaryData(items.Items.Select(GetIdentifiedPair), items.PageDetails));
}
public async Task <ResourceBody> GetAsync(IRestCollectionQuery query)
{
RestDirectoryInfo directory = await Directory.GetInfoAsync();
return(new DirectoryBody(directory, Context.Services.NameSwitcher.ConvertCodedToDefault));
}
