internal async Task <IList <RecordItem> > GetAllItemsAsync(CancellationToken cancelToken, ItemQuery query)
{
var itemsFound = new List <RecordItem>();
while (true)
{
ItemQueryResult[] results = await ExecuteQueriesAsync(cancelToken, new[] { query });
if (results.IsNullOrEmpty())
{
break;
}
ItemQueryResult result = results[0];
if (result.HasItems)
{
itemsFound.AddRange(result.Items);
}
if (!result.HasPending)
{
break;
}
//
// Issue a fresh query for pending items
//
ItemQuery pendingQuery = ItemQuery.QueryForPending(result.PendingItems);
pendingQuery.View = query.View;
query = pendingQuery;
}
return(itemsFound);
}
public IAsyncOperation <RecordItem> GetItemAsync(
ItemKey key,
string versionType,
ItemSectionType sections)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
ItemQuery query = ItemQuery.QueryForKey(key);
query.View = new ItemView(sections);
if (!String.IsNullOrEmpty(versionType))
{
query.View.TypeVersions.Add(versionType);
}
return(AsyncInfo.Run(
async cancelToken =>
{
ItemQueryResult result = await GetItemsAsync(query).AsTask(cancelToken);
return result.FirstItem;
}
));
}
public IAsyncOperation <IList <ItemKey> > GetKeysAsync(IList <ItemFilter> filters, int maxResults)
{
filters.ValidateRequired("filters");
ItemQuery query = ItemQuery.QueryForKeys(filters, maxResults);
return(AsyncInfo.Run <IList <ItemKey> >(
async cancelToken =>
{
ItemQueryResult result = await GetItemsAsync(query);
return result.AllKeys.ToArray();
}));
}
public static ViewKeyCollection FromQueryResult(ItemQueryResult queryResult)
{
ViewKeyCollection keys = new ViewKeyCollection();
if (queryResult != null)
{
if (queryResult.HasItems)
{
keys.AddFromItems(queryResult.Items);
}
if (queryResult.HasPending)
{
keys.AddFromPendingItems(queryResult.PendingItems);
}
}
return(keys);
}
public IAsyncOperation <IList <PendingItem> > GetKeysAndDateAsync(IList <ItemFilter> filters, int maxResults)
{
filters.ValidateRequired("filter");
ItemQuery query = ItemQuery.QueryForKeys(filters, maxResults);
return(AsyncInfo.Run <IList <PendingItem> >(
async cancelToken =>
{
ItemQueryResult result = await GetItemsAsync(query);
if (!result.HasPending)
{
return null;
}
return result.PendingItems.ToArray();
}));
}
async Task UpdateViews(IList <ISynchronizedView> views, IList <ItemQueryResult> queryResults)
{
int iResult = 0;
for (int i = 0, count = views.Count; i < count; ++i)
{
ItemQuery query = m_syncQueries[i];
if (query != null)
{
ItemQueryResult queryResult = null;
if (!queryResults.IsNullOrEmpty())
{
queryResult = queryResults[iResult++];
}
await this.UpdateKeys(views[i], queryResult);
}
}
}
async Task UpdateKeys(ISynchronizedView view, ItemQueryResult queryResult)
{
ViewKeyCollection keys = null;
if (queryResult != null)
{
keys = ViewKeyCollection.FromQueryResult(queryResult);
}
else
{
keys = new ViewKeyCollection();
}
view.UpdateKeys(keys);
SynchronizedType sType = view as SynchronizedType;
if (sType != null)
{
await sType.SaveAsync();
}
}
public IAsyncOperation <ItemDataTypedList> GetAsync(ItemQuery query)
{
query.ValidateRequired("query");
//
// Ensure the user is querying for typed information
//
if (!query.View.ReturnsTypedData)
{
throw new ArgumentException("query");
}
return(AsyncInfo.Run(
async cancelToken =>
{
ItemQueryResult[] results = await ExecuteQueriesAsync(cancelToken, new[] { query });
if (results.IsNullOrEmpty())
{
return null;
}
ItemQueryResult result = results[0];
return new ItemDataTypedList(this, query.View, result.Items, result.PendingKeys);
}));
}
