diff --git a/NuGet.Services.Metadata.sln b/NuGet.Services.Metadata.sln index 71ac542df..464d5e1d3 100644 --- a/NuGet.Services.Metadata.sln +++ b/NuGet.Services.Metadata.sln @@ -40,6 +40,10 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CatalogMetadataTests", "tes EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "V3PerPackage", "src\V3PerPackage\V3PerPackage.csproj", "{E76E73FA-4462-4F07-94C0-8B9CC413F696}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NuGet.Protocol.Catalog", "src\NuGet.Protocol.Catalog\NuGet.Protocol.Catalog.csproj", "{D44C2E89-2D98-44BD-8712-8CCBE4E67C9C}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "NuGet.Protocol.Catalog.Tests", "tests\NuGet.Protocol.Catalog.Tests\NuGet.Protocol.Catalog.Tests.csproj", "{1F3BC053-796C-4A35-88F4-955A0F142197}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -190,6 +194,30 @@ Global {E76E73FA-4462-4F07-94C0-8B9CC413F696}.Release|Mixed Platforms.Build.0 = Release|Any CPU {E76E73FA-4462-4F07-94C0-8B9CC413F696}.Release|x64.ActiveCfg = Release|Any CPU {E76E73FA-4462-4F07-94C0-8B9CC413F696}.Release|x64.Build.0 = Release|Any CPU + {D44C2E89-2D98-44BD-8712-8CCBE4E67C9C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D44C2E89-2D98-44BD-8712-8CCBE4E67C9C}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D44C2E89-2D98-44BD-8712-8CCBE4E67C9C}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {D44C2E89-2D98-44BD-8712-8CCBE4E67C9C}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {D44C2E89-2D98-44BD-8712-8CCBE4E67C9C}.Debug|x64.ActiveCfg = Debug|Any CPU + {D44C2E89-2D98-44BD-8712-8CCBE4E67C9C}.Debug|x64.Build.0 = Debug|Any CPU + {D44C2E89-2D98-44BD-8712-8CCBE4E67C9C}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D44C2E89-2D98-44BD-8712-8CCBE4E67C9C}.Release|Any CPU.Build.0 = Release|Any CPU + {D44C2E89-2D98-44BD-8712-8CCBE4E67C9C}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {D44C2E89-2D98-44BD-8712-8CCBE4E67C9C}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {D44C2E89-2D98-44BD-8712-8CCBE4E67C9C}.Release|x64.ActiveCfg = Release|Any CPU + {D44C2E89-2D98-44BD-8712-8CCBE4E67C9C}.Release|x64.Build.0 = Release|Any CPU + {1F3BC053-796C-4A35-88F4-955A0F142197}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {1F3BC053-796C-4A35-88F4-955A0F142197}.Debug|Any CPU.Build.0 = Debug|Any CPU + {1F3BC053-796C-4A35-88F4-955A0F142197}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {1F3BC053-796C-4A35-88F4-955A0F142197}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {1F3BC053-796C-4A35-88F4-955A0F142197}.Debug|x64.ActiveCfg = Debug|Any CPU + {1F3BC053-796C-4A35-88F4-955A0F142197}.Debug|x64.Build.0 = Debug|Any CPU + {1F3BC053-796C-4A35-88F4-955A0F142197}.Release|Any CPU.ActiveCfg = Release|Any CPU + {1F3BC053-796C-4A35-88F4-955A0F142197}.Release|Any CPU.Build.0 = Release|Any CPU + {1F3BC053-796C-4A35-88F4-955A0F142197}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {1F3BC053-796C-4A35-88F4-955A0F142197}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {1F3BC053-796C-4A35-88F4-955A0F142197}.Release|x64.ActiveCfg = Release|Any CPU + {1F3BC053-796C-4A35-88F4-955A0F142197}.Release|x64.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -207,6 +235,8 @@ Global {1745A383-D0BE-484B-81EB-27B20F6AC6C5} = {5DE01C58-D5F7-482F-8256-A8333064384C} {34AABA7F-1FF7-4F4B-B1DB-D07AD4505DA4} = {F1C83FD9-A498-483E-ADFA-B55D82A14965} {E76E73FA-4462-4F07-94C0-8B9CC413F696} = {C86C6DEE-84E1-4E4E-8868-6755D7A8E0E4} + {D44C2E89-2D98-44BD-8712-8CCBE4E67C9C} = {5DE01C58-D5F7-482F-8256-A8333064384C} + {1F3BC053-796C-4A35-88F4-955A0F142197} = {F1C83FD9-A498-483E-ADFA-B55D82A14965} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution SolutionGuid = {D3AB83E9-02B4-4FFA-A2D0-637F0B97E626} diff --git a/build.ps1 b/build.ps1 index ddc8ff97c..999cf7700 100644 --- a/build.ps1 +++ b/build.ps1 @@ -9,7 +9,7 @@ param ( [string]$SemanticVersion = '1.0.0-zlocal', [string]$Branch, [string]$CommitSHA, - [string]$BuildBranch = '5fd8377a9abf3ff411918dbb973948a6677432db' + [string]$BuildBranch = 'b5f9d1c89da96c462935e2195ceb00e69287b93e' ) # For TeamCity - If any issue occurs, this script fails the build. - By default, TeamCity returns an exit code of 0 for all powershell scripts, even if they fail @@ -79,7 +79,8 @@ Invoke-BuildStep 'Set version metadata in AssemblyInfo.cs' { "src\Catalog\Properties\AssemblyInfo.g.cs", ` "src\NuGet.ApplicationInsights.Owin\Properties\AssemblyInfo.g.cs", ` "src\Ng\Properties\AssemblyInfo.g.cs", ` - "src\NuGet.Services.Metadata.Catalog.Monitoring\Properties\AssemblyInfo.g.cs" + "src\NuGet.Services.Metadata.Catalog.Monitoring\Properties\AssemblyInfo.g.cs", ` + "src\NuGet.Protocol.Catalog\Properties\AssemblyInfo.g.cs" Foreach ($assemblyInfo in $assemblyInfos) { Set-VersionInfo -Path (Join-Path $PSScriptRoot $assemblyInfo) -Version $SimpleVersion -Branch $Branch -Commit $CommitSHA diff --git a/src/Catalog/BatchProcessingException.cs b/src/Catalog/BatchProcessingException.cs index 23a587b63..cdc135cf1 100644 --- a/src/Catalog/BatchProcessingException.cs +++ b/src/Catalog/BatchProcessingException.cs @@ -8,7 +8,7 @@ namespace NuGet.Services.Metadata.Catalog public sealed class BatchProcessingException : Exception { public BatchProcessingException(Exception inner) - : base(Strings.BatchProcessingFailure) + : base(Strings.BatchProcessingFailure, inner ?? throw new ArgumentNullException(nameof(inner))) { } } diff --git a/src/Catalog/CatalogCommit.cs b/src/Catalog/CatalogCommit.cs new file mode 100644 index 000000000..366eefd98 --- /dev/null +++ b/src/Catalog/CatalogCommit.cs @@ -0,0 +1,51 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using System.Globalization; +using Newtonsoft.Json.Linq; + +namespace NuGet.Services.Metadata.Catalog +{ + /// + /// Represents a single catalog commit. + /// + public sealed class CatalogCommit : IComparable + { + private CatalogCommit(DateTime commitTimeStamp, Uri uri) + { + CommitTimeStamp = commitTimeStamp; + Uri = uri; + } + + public DateTime CommitTimeStamp { get; } + public Uri Uri { get; } + + public int CompareTo(object obj) + { + var other = obj as CatalogCommit; + + if (ReferenceEquals(other, null)) + { + throw new ArgumentException( + string.Format(CultureInfo.InvariantCulture, Strings.ArgumentMustBeInstanceOfType, nameof(CatalogCommit)), + nameof(obj)); + } + + return CommitTimeStamp.CompareTo(other.CommitTimeStamp); + } + + public static CatalogCommit Create(JObject commit) + { + if (commit == null) + { + throw new ArgumentNullException(nameof(commit)); + } + + var commitTimeStamp = Utils.Deserialize(commit, "commitTimeStamp"); + var uri = Utils.Deserialize(commit, "@id"); + + return new CatalogCommit(commitTimeStamp, uri); + } + } +} \ No newline at end of file diff --git a/src/Catalog/CatalogCommitItem.cs b/src/Catalog/CatalogCommitItem.cs new file mode 100644 index 000000000..a240f8e5f --- /dev/null +++ b/src/Catalog/CatalogCommitItem.cs @@ -0,0 +1,108 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using System.Collections.Generic; +using System.Globalization; +using System.Linq; +using Newtonsoft.Json.Linq; +using NuGet.Packaging.Core; +using NuGet.Versioning; + +namespace NuGet.Services.Metadata.Catalog +{ + /// + /// Represents a single item in a catalog commit. + /// + public sealed class CatalogCommitItem : IComparable + { + private const string _typeKeyword = "@type"; + + private CatalogCommitItem( + Uri uri, + string commitId, + DateTime commitTimeStamp, + IReadOnlyList types, + IReadOnlyList typeUris, + PackageIdentity packageIdentity) + { + Uri = uri; + CommitId = commitId; + CommitTimeStamp = commitTimeStamp; + PackageIdentity = packageIdentity; + Types = types; + TypeUris = typeUris; + } + + public Uri Uri { get; } + public DateTime CommitTimeStamp { get; } + public string CommitId { get; } + public PackageIdentity PackageIdentity { get; } + public IReadOnlyList Types { get; } + public IReadOnlyList TypeUris { get; } + + public int CompareTo(object obj) + { + var other = obj as CatalogCommitItem; + + if (ReferenceEquals(other, null)) + { + throw new ArgumentException( + string.Format(CultureInfo.InvariantCulture, Strings.ArgumentMustBeInstanceOfType, nameof(CatalogCommitItem)), + nameof(obj)); + } + + return CommitTimeStamp.CompareTo(other.CommitTimeStamp); + } + + public static CatalogCommitItem Create(JObject context, JObject commitItem) + { + if (context == null) + { + throw new ArgumentNullException(nameof(context)); + } + + if (commitItem == null) + { + throw new ArgumentNullException(nameof(commitItem)); + } + + var commitTimeStamp = Utils.Deserialize(commitItem, "commitTimeStamp"); + var commitId = Utils.Deserialize(commitItem, "commitId"); + var idUri = Utils.Deserialize(commitItem, "@id"); + var packageId = Utils.Deserialize(commitItem, "nuget:id"); + var packageVersion = Utils.Deserialize(commitItem, "nuget:version"); + var packageIdentity = new PackageIdentity(packageId, new NuGetVersion(packageVersion)); + var types = GetTypes(commitItem).ToArray(); + + if (!types.Any()) + { + throw new ArgumentException( + string.Format(CultureInfo.InvariantCulture, Strings.NonEmptyPropertyValueRequired, _typeKeyword), + nameof(commitItem)); + } + + var typeUris = types.Select(type => Utils.Expand(context, type)).ToArray(); + + return new CatalogCommitItem(idUri, commitId, commitTimeStamp, types, typeUris, packageIdentity); + } + + private static IEnumerable GetTypes(JObject commitItem) + { + if (commitItem.TryGetValue(_typeKeyword, out var value)) + { + if (value is JArray) + { + foreach (JToken typeToken in ((JArray)value).Values()) + { + yield return typeToken.ToString(); + } + } + else + { + yield return value.ToString(); + } + } + } + } +} \ No newline at end of file diff --git a/src/Catalog/CatalogCommitItemBatch.cs b/src/Catalog/CatalogCommitItemBatch.cs new file mode 100644 index 000000000..4abbbcbb8 --- /dev/null +++ b/src/Catalog/CatalogCommitItemBatch.cs @@ -0,0 +1,44 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using System.Collections.Generic; +using System.Linq; + +namespace NuGet.Services.Metadata.Catalog +{ + /// + /// Represents a group of . + /// Items may span multiple commits but are grouped on common criteria (e.g.: lower-cased package ID). + /// + public sealed class CatalogCommitItemBatch + { + /// + /// Initializes a instance. + /// + /// An enumerable of . Items may span multiple commits. + /// A unique key for all items in a batch. This is used for parallelization and may be + /// null if parallelization is not used. + /// Thrown if is either null or empty. + public CatalogCommitItemBatch(IEnumerable items, string key = null) + { + if (items == null || !items.Any()) + { + throw new ArgumentException(Strings.ArgumentMustNotBeNullOrEmpty, nameof(items)); + } + + var list = items.ToList(); + + CommitTimeStamp = list.Min(item => item.CommitTimeStamp); + Key = key; + + list.Sort(); + + Items = list; + } + + public DateTime CommitTimeStamp { get; } + public IReadOnlyList Items { get; } + public string Key { get; } + } +} \ No newline at end of file diff --git a/src/Catalog/CatalogCommitItemBatchTask.cs b/src/Catalog/CatalogCommitItemBatchTask.cs new file mode 100644 index 000000000..3d8e58401 --- /dev/null +++ b/src/Catalog/CatalogCommitItemBatchTask.cs @@ -0,0 +1,68 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using System.Threading.Tasks; + +namespace NuGet.Services.Metadata.Catalog +{ + /// + /// Represents an asynchrononous task associated with catalog changes for a specific + /// and potentially spanning multiple commits. + /// + public sealed class CatalogCommitItemBatchTask : IEquatable + { + /// + /// Initializes a instance. + /// + /// A . + /// A tracking completion of + /// processing. + /// Thrown if is null. + /// Thrown if is null. + /// Thrown if is null. + public CatalogCommitItemBatchTask(CatalogCommitItemBatch batch, Task task) + { + if (batch == null) + { + throw new ArgumentNullException(nameof(batch)); + } + + if (batch.Key == null) + { + throw new ArgumentException(Strings.ArgumentMustNotBeNull, $"{nameof(batch)}.{nameof(batch.Key)}"); + } + + if (task == null) + { + throw new ArgumentNullException(nameof(task)); + } + + Batch = batch; + Task = task; + } + + public CatalogCommitItemBatch Batch { get; } + public Task Task { get; } + + public override int GetHashCode() + { + return Batch.Key.GetHashCode(); + } + + public override bool Equals(object obj) + { + return Equals(obj as CatalogCommitItemBatchTask); + } + + public bool Equals(CatalogCommitItemBatchTask other) + { + if (ReferenceEquals(other, null)) + { + return false; + } + + return string.Equals(Batch.Key, other.Batch.Key); + } + } +} \ No newline at end of file diff --git a/src/Catalog/CatalogCommitUtilities.cs b/src/Catalog/CatalogCommitUtilities.cs new file mode 100644 index 000000000..a4b0cc449 --- /dev/null +++ b/src/Catalog/CatalogCommitUtilities.cs @@ -0,0 +1,323 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Globalization; +using System.Linq; +using System.Threading; +using System.Threading.Tasks; +using Microsoft.Extensions.Logging; +using Newtonsoft.Json.Linq; +using ExceptionUtilities = NuGet.Common.ExceptionUtilities; + +namespace NuGet.Services.Metadata.Catalog +{ + public static class CatalogCommitUtilities + { + private static readonly EventId _eventId = new EventId(id: 0); + + /// + /// Creates an enumerable of instances. + /// + /// + /// A instance contains only the latest commit for each package identity. + /// + /// An enumerable of . + /// A function that returns a key for a . + /// An enumerable of with no ordering guarantee. + /// Thrown if is null. + /// Thrown if is null. + public static IEnumerable CreateCommitItemBatches( + IEnumerable catalogItems, + GetCatalogCommitItemKey getCatalogCommitItemKey) + { + if (catalogItems == null) + { + throw new ArgumentNullException(nameof(catalogItems)); + } + + if (getCatalogCommitItemKey == null) + { + throw new ArgumentNullException(nameof(getCatalogCommitItemKey)); + } + + var catalogItemsGroups = catalogItems + .GroupBy(catalogItem => getCatalogCommitItemKey(catalogItem)); + + var batches = new List(); + + foreach (var catalogItemsGroup in catalogItemsGroups) + { + var catalogItemsWithOnlyLatestCommitForEachPackageIdentity = catalogItemsGroup + .GroupBy(commitItem => new + { + PackageId = commitItem.PackageIdentity.Id.ToLowerInvariant(), + PackageVersion = commitItem.PackageIdentity.Version.ToNormalizedString().ToLowerInvariant() + }) + .Select(group => group.OrderBy(item => item.CommitTimeStamp).Last()) + .ToArray(); + var minCommitTimeStamp = catalogItemsWithOnlyLatestCommitForEachPackageIdentity + .Select(catalogItem => catalogItem.CommitTimeStamp) + .Min(); + + batches.Add( + new CatalogCommitItemBatch( + catalogItemsWithOnlyLatestCommitForEachPackageIdentity, + catalogItemsGroup.Key)); + } + + // Assert only after skipping older commits for each package identity to reduce the likelihood + // of unnecessary failures. + AssertNotMoreThanOneCommitIdPerCommitTimeStamp(batches, nameof(catalogItems)); + + return batches; + } + + public static void StartProcessingBatchesIfNoFailures( + CollectorHttpClient client, + JToken context, + List unprocessedBatches, + List processingBatches, + int maxConcurrentBatches, + ProcessCommitItemBatchAsync processCommitItemBatchAsync, + CancellationToken cancellationToken) + { + if (client == null) + { + throw new ArgumentNullException(nameof(client)); + } + + if (context == null) + { + throw new ArgumentNullException(nameof(context)); + } + + if (unprocessedBatches == null) + { + throw new ArgumentNullException(nameof(unprocessedBatches)); + } + + if (processingBatches == null) + { + throw new ArgumentNullException(nameof(processingBatches)); + } + + if (maxConcurrentBatches < 1) + { + throw new ArgumentOutOfRangeException( + nameof(maxConcurrentBatches), + maxConcurrentBatches, + string.Format(Strings.ArgumentOutOfRange, 1, int.MaxValue)); + } + + if (processCommitItemBatchAsync == null) + { + throw new ArgumentNullException(nameof(processCommitItemBatchAsync)); + } + + var hasAnyBatchFailed = processingBatches.Any(batch => batch.Task.IsFaulted || batch.Task.IsCanceled); + + if (hasAnyBatchFailed) + { + return; + } + + var batchesToEnqueue = Math.Min( + maxConcurrentBatches - processingBatches.Count(batch => !batch.Task.IsCompleted), + unprocessedBatches.Count); + + for (var i = 0; i < batchesToEnqueue; ++i) + { + var batch = unprocessedBatches[0]; + + unprocessedBatches.RemoveAt(0); + + var task = processCommitItemBatchAsync( + client, + context, + batch.Key, + batch, + lastBatch: null, + cancellationToken: cancellationToken); + var batchTask = new CatalogCommitItemBatchTask(batch, task); + + processingBatches.Add(batchTask); + } + } + + internal static async Task ProcessCatalogCommitsAsync( + CollectorHttpClient client, + ReadWriteCursor front, + ReadCursor back, + FetchCatalogCommitsAsync fetchCatalogCommitsAsync, + CreateCommitItemBatchesAsync createCommitItemBatchesAsync, + ProcessCommitItemBatchAsync processCommitItemBatchAsync, + int maxConcurrentBatches, + ILogger logger, + CancellationToken cancellationToken) + { + IEnumerable rootItems = await fetchCatalogCommitsAsync(client, front, cancellationToken); + + var hasAnyBatchFailed = false; + var hasAnyBatchBeenProcessed = false; + + foreach (CatalogCommit rootItem in rootItems) + { + JObject page = await client.GetJObjectAsync(rootItem.Uri, cancellationToken); + var context = (JObject)page["@context"]; + CatalogCommitItemBatch[] batches = await CreateBatchesForAllAvailableItemsInPageAsync( + front, + back, + page, + context, + createCommitItemBatchesAsync); + + if (!batches.Any()) + { + continue; + } + + hasAnyBatchBeenProcessed = true; + + DateTime maxCommitTimeStamp = GetMaxCommitTimeStamp(batches); + var unprocessedBatches = batches.ToList(); + var processingBatches = new List(); + var exceptions = new List(); + + StartProcessingBatchesIfNoFailures( + client, + context, + unprocessedBatches, + processingBatches, + maxConcurrentBatches, + processCommitItemBatchAsync, + cancellationToken); + + while (processingBatches.Any()) + { + var activeTasks = processingBatches.Where(batch => !batch.Task.IsCompleted) + .Select(batch => batch.Task) + .DefaultIfEmpty(Task.CompletedTask); + + await Task.WhenAny(activeTasks); + + for (var i = 0; i < processingBatches.Count; ++i) + { + var batch = processingBatches[i]; + + if (batch.Task.IsFaulted || batch.Task.IsCanceled) + { + hasAnyBatchFailed = true; + + if (batch.Task.Exception != null) + { + var exception = ExceptionUtilities.Unwrap(batch.Task.Exception); + + exceptions.Add(exception); + } + } + + if (batch.Task.IsCompleted) + { + processingBatches.RemoveAt(i); + --i; + } + } + + if (!hasAnyBatchFailed) + { + StartProcessingBatchesIfNoFailures( + client, + context, + unprocessedBatches, + processingBatches, + maxConcurrentBatches, + processCommitItemBatchAsync, + cancellationToken); + } + } + + if (hasAnyBatchFailed) + { + foreach (var exception in exceptions) + { + logger.LogError(_eventId, exception, Strings.BatchProcessingFailure); + } + + var innerException = exceptions.Count == 1 ? exceptions.Single() : new AggregateException(exceptions); + + throw new BatchProcessingException(innerException); + } + + front.Value = maxCommitTimeStamp; + + await front.SaveAsync(cancellationToken); + + Trace.TraceInformation($"{nameof(CatalogCommitUtilities)}.{nameof(ProcessCatalogCommitsAsync)} " + + $"{nameof(front)}.{nameof(front.Value)} saved since timestamp changed from previous: {{0}}", front); + } + + return hasAnyBatchBeenProcessed; + } + + public static string GetPackageIdKey(CatalogCommitItem item) + { + if (item == null) + { + throw new ArgumentNullException(nameof(item)); + } + + return item.PackageIdentity.Id.ToLowerInvariant(); + } + + private static async Task CreateBatchesForAllAvailableItemsInPageAsync( + ReadWriteCursor front, + ReadCursor back, + JObject page, + JObject context, + CreateCommitItemBatchesAsync createCommitItemBatchesAsync) + { + IEnumerable commitItems = page["items"] + .Select(item => CatalogCommitItem.Create(context, (JObject)item)) + .Where(item => item.CommitTimeStamp > front.Value && item.CommitTimeStamp <= back.Value); + + IEnumerable batches = await createCommitItemBatchesAsync(commitItems); + + return batches + .OrderBy(batch => batch.CommitTimeStamp) + .ToArray(); + } + + private static DateTime GetMaxCommitTimeStamp(CatalogCommitItemBatch[] batches) + { + return batches.SelectMany(batch => batch.Items) + .Select(item => item.CommitTimeStamp) + .Max(); + } + + private static void AssertNotMoreThanOneCommitIdPerCommitTimeStamp( + IEnumerable batches, + string parameterName) + { + var commitsWithSameTimeStampButDifferentCommitIds = batches + .SelectMany(batch => batch.Items) + .GroupBy(commitItem => commitItem.CommitTimeStamp) + .Where(group => group.Select(item => item.CommitId).Distinct().Count() > 1); + + if (commitsWithSameTimeStampButDifferentCommitIds.Any()) + { + var commits = commitsWithSameTimeStampButDifferentCommitIds.SelectMany(group => group) + .Select(commit => $"{{ CommitId = {commit.CommitId}, CommitTimeStamp = {commit.CommitTimeStamp.ToString("O")} }}"); + + throw new ArgumentException( + string.Format( + CultureInfo.InvariantCulture, + Strings.MultipleCommitIdsForSameCommitTimeStamp, + string.Join(", ", commits)), + parameterName); + } + } + } +} \ No newline at end of file diff --git a/src/Catalog/CatalogIndexEntry.cs b/src/Catalog/CatalogIndexEntry.cs index 3ece5ce4a..48112b8dc 100644 --- a/src/Catalog/CatalogIndexEntry.cs +++ b/src/Catalog/CatalogIndexEntry.cs @@ -3,51 +3,44 @@ using System; using System.Collections.Generic; -using System.Globalization; using System.Linq; using Newtonsoft.Json; -using Newtonsoft.Json.Linq; +using NuGet.Packaging.Core; using NuGet.Versioning; namespace NuGet.Services.Metadata.Catalog { public sealed class CatalogIndexEntry : IComparable { - private static readonly CatalogIndexEntryDateComparer _commitTimeStampComparer = new CatalogIndexEntryDateComparer(); - [JsonConstructor] private CatalogIndexEntry() { Types = Enumerable.Empty(); } - public CatalogIndexEntry(Uri uri, string type, string commitId, DateTime commitTs, string id, NuGetVersion version) + public CatalogIndexEntry( + Uri uri, + string type, + string commitId, + DateTime commitTs, + PackageIdentity packageIdentity) { - Uri = uri ?? throw new ArgumentNullException(nameof(uri)); - if (string.IsNullOrWhiteSpace(type)) { - throw new ArgumentException(Strings.ArgumentMustNotBeNullOrEmpty, nameof(type)); + throw new ArgumentException(Strings.ArgumentMustNotBeNullEmptyOrWhitespace, nameof(type)); } - Types = new[] { type }; - IsDelete = type == "nuget:PackageDelete"; - - if (string.IsNullOrWhiteSpace(commitId)) - { - throw new ArgumentException(Strings.ArgumentMustNotBeNullOrEmpty, nameof(commitId)); - } - - CommitId = commitId; - CommitTimeStamp = commitTs; - - if (string.IsNullOrWhiteSpace(id)) - { - throw new ArgumentException(Strings.ArgumentMustNotBeNullOrEmpty, nameof(id)); - } + Initialize(uri, new[] { type }, commitId, commitTs, packageIdentity); + } - Id = id; - Version = version ?? throw new ArgumentNullException(nameof(version)); + public CatalogIndexEntry( + Uri uri, + IReadOnlyList types, + string commitId, + DateTime commitTs, + PackageIdentity packageIdentity) + { + Initialize(uri, types, commitId, commitTs, packageIdentity); } [JsonProperty("@id")] @@ -76,7 +69,13 @@ public CatalogIndexEntry(Uri uri, string type, string commitId, DateTime commitT public NuGetVersion Version { get; private set; } [JsonIgnore] - public bool IsDelete { get; } + public bool IsDelete + { + get + { + return Types.Any(type => type == "nuget:PackageDelete"); + } + } public int CompareTo(CatalogIndexEntry other) { @@ -85,37 +84,60 @@ public int CompareTo(CatalogIndexEntry other) throw new ArgumentNullException(nameof(other)); } - return _commitTimeStampComparer.Compare(this, other); + return CommitTimeStamp.CompareTo(other.CommitTimeStamp); } - public static CatalogIndexEntry Create(JToken token) + public static CatalogIndexEntry Create(CatalogCommitItem commitItem) { - if (token == null) + if (commitItem == null) { - throw new ArgumentNullException(nameof(token)); + throw new ArgumentNullException(nameof(commitItem)); } - var uri = new Uri(token["@id"].ToString()); - var type = token["@type"].ToString(); - var commitId = token["commitId"].ToString(); - var commitTimeStamp = DateTime.ParseExact( - token["commitTimeStamp"].ToString(), - "yyyy-MM-ddTHH:mm:ss.FFFFFFFZ", - DateTimeFormatInfo.CurrentInfo, - DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal); - - var packageId = token["nuget:id"].ToString(); - var packageVersion = NuGetVersion.Parse(token["nuget:version"].ToString()); - - return new CatalogIndexEntry(uri, type, commitId, commitTimeStamp, packageId, packageVersion); + return new CatalogIndexEntry( + commitItem.Uri, + commitItem.Types, + commitItem.CommitId, + commitItem.CommitTimeStamp, + commitItem.PackageIdentity); } - } - public class CatalogIndexEntryDateComparer : IComparer - { - public int Compare(CatalogIndexEntry x, CatalogIndexEntry y) + private void Initialize( + Uri uri, + IReadOnlyList types, + string commitId, + DateTime commitTs, + PackageIdentity packageIdentity) { - return x.CommitTimeStamp.CompareTo(y.CommitTimeStamp); + Uri = uri ?? throw new ArgumentNullException(nameof(uri)); + + if (types == null || !types.Any()) + { + throw new ArgumentException(Strings.ArgumentMustNotBeNullOrEmpty, nameof(types)); + } + + if (types.Any(type => string.IsNullOrWhiteSpace(type))) + { + throw new ArgumentException(Strings.ArgumentMustNotBeNullEmptyOrWhitespace, nameof(types)); + } + + Types = types; + + if (string.IsNullOrWhiteSpace(commitId)) + { + throw new ArgumentException(Strings.ArgumentMustNotBeNullOrEmpty, nameof(commitId)); + } + + CommitId = commitId; + CommitTimeStamp = commitTs; + + if (packageIdentity == null) + { + throw new ArgumentNullException(nameof(packageIdentity)); + } + + Id = packageIdentity.Id; + Version = packageIdentity.Version; } } } \ No newline at end of file diff --git a/src/Catalog/CatalogIndexReader.cs b/src/Catalog/CatalogIndexReader.cs index 0aaa60d02..e33b5a4a9 100644 --- a/src/Catalog/CatalogIndexReader.cs +++ b/src/Catalog/CatalogIndexReader.cs @@ -9,6 +9,7 @@ using System.Net; using System.Threading.Tasks; using Newtonsoft.Json.Linq; +using NuGet.Packaging.Core; using NuGet.Versioning; namespace NuGet.Services.Metadata.Catalog @@ -84,6 +85,7 @@ private async Task ProcessPageUris(ConcurrentBag pageUriBag, ConcurrentBag< var commitId = interner.Intern(item["commitId"].ToString()); var nugetId = interner.Intern(item["nuget:id"].ToString()); var nugetVersion = interner.Intern(item["nuget:version"].ToString()); + var packageIdentity = new PackageIdentity(nugetId, NuGetVersion.Parse(nugetVersion)); // No string is directly operated on here. var commitTimeStamp = item["commitTimeStamp"].ToObject(); @@ -93,12 +95,11 @@ private async Task ProcessPageUris(ConcurrentBag pageUriBag, ConcurrentBag< type, commitId, commitTimeStamp, - nugetId, - NuGetVersion.Parse(nugetVersion)); + packageIdentity); entries.Add(entry); } } } } -} +} \ No newline at end of file diff --git a/src/Catalog/CollectorBase.cs b/src/Catalog/CollectorBase.cs index ea49ee7fb..952431a81 100644 --- a/src/Catalog/CollectorBase.cs +++ b/src/Catalog/CollectorBase.cs @@ -13,17 +13,20 @@ public abstract class CollectorBase { protected readonly ITelemetryService _telemetryService; private readonly Func _handlerFunc; + private readonly IHttpRetryStrategy _httpRetryStrategy; private readonly TimeSpan? _httpClientTimeout; public CollectorBase( Uri index, ITelemetryService telemetryService, Func handlerFunc = null, - TimeSpan? httpClientTimeout = null) + TimeSpan? httpClientTimeout = null, + IHttpRetryStrategy httpRetryStrategy = null) { _telemetryService = telemetryService ?? throw new ArgumentNullException(nameof(telemetryService)); _handlerFunc = handlerFunc; _httpClientTimeout = httpClientTimeout; + _httpRetryStrategy = httpRetryStrategy; Index = index ?? throw new ArgumentNullException(nameof(index)); } @@ -54,7 +57,7 @@ public async Task RunAsync(ReadWriteCursor front, ReadCursor back, Cancell handler = _handlerFunc(); } - using (CollectorHttpClient client = new CollectorHttpClient(handler)) + using (CollectorHttpClient client = new CollectorHttpClient(handler, _httpRetryStrategy)) { if (_httpClientTimeout.HasValue) { diff --git a/src/Catalog/CollectorHttpClient.cs b/src/Catalog/CollectorHttpClient.cs index b820e1ef2..ead8a14e8 100644 --- a/src/Catalog/CollectorHttpClient.cs +++ b/src/Catalog/CollectorHttpClient.cs @@ -15,18 +15,18 @@ namespace NuGet.Services.Metadata.Catalog public class CollectorHttpClient : HttpClient { private int _requestCount; - private readonly RetryWithExponentialBackoff _retryStrategy; + private readonly IHttpRetryStrategy _retryStrategy; public CollectorHttpClient() : this(new WebRequestHandler { AllowPipelining = true }) { } - public CollectorHttpClient(HttpMessageHandler handler) + public CollectorHttpClient(HttpMessageHandler handler, IHttpRetryStrategy retryStrategy = null) : base(handler ?? new WebRequestHandler { AllowPipelining = true }) { _requestCount = 0; - _retryStrategy = new RetryWithExponentialBackoff(); + _retryStrategy = retryStrategy ?? new RetryWithExponentialBackoff(); } public int RequestCount diff --git a/src/Catalog/CommitCollector.cs b/src/Catalog/CommitCollector.cs index d483d7d1f..0418e070d 100644 --- a/src/Catalog/CommitCollector.cs +++ b/src/Catalog/CommitCollector.cs @@ -18,8 +18,9 @@ public CommitCollector( Uri index, ITelemetryService telemetryService, Func handlerFunc = null, - TimeSpan? httpClientTimeout = null) - : base(index, telemetryService, handlerFunc, httpClientTimeout) + TimeSpan? httpClientTimeout = null, + IHttpRetryStrategy httpRetryStrategy = null) + : base(index, telemetryService, handlerFunc, httpClientTimeout, httpRetryStrategy) { } @@ -29,19 +30,19 @@ protected override async Task FetchAsync( ReadCursor back, CancellationToken cancellationToken) { - IEnumerable catalogItems = await FetchCatalogItemsAsync(client, front, cancellationToken); + IEnumerable commits = await FetchCatalogCommitsAsync(client, front, cancellationToken); bool acceptNextBatch = false; - foreach (CatalogItem catalogItem in catalogItems) + foreach (CatalogCommit commit in commits) { - JObject page = await client.GetJObjectAsync(catalogItem.Uri, cancellationToken); + JObject page = await client.GetJObjectAsync(commit.Uri, cancellationToken); JToken context = null; page.TryGetValue("@context", out context); var batches = await CreateBatchesAsync(page["items"] - .Select(item => new CatalogItem((JObject)item)) + .Select(item => CatalogCommitItem.Create((JObject)context, (JObject)item)) .Where(item => item.CommitTimeStamp > front.Value && item.CommitTimeStamp <= back.Value)); var orderedBatches = batches @@ -70,7 +71,7 @@ protected override async Task FetchAsync( { acceptNextBatch = await OnProcessBatchAsync( client, - batch.Items.Select(item => item.Value), + batch.Items, context, batch.CommitTimeStamp, batch.CommitTimeStamp == lastBatch.CommitTimeStamp, @@ -104,7 +105,7 @@ protected override async Task FetchAsync( return acceptNextBatch; } - protected async Task> FetchCatalogItemsAsync( + protected async Task> FetchCatalogCommitsAsync( CollectorHttpClient client, ReadWriteCursor front, CancellationToken cancellationToken) @@ -118,67 +119,30 @@ protected async Task> FetchCatalogItemsAsync( root = await client.GetJObjectAsync(Index, cancellationToken); } - IEnumerable rootItems = root["items"] - .Select(item => new CatalogItem((JObject)item)) + IEnumerable commits = root["items"] + .Select(item => CatalogCommit.Create((JObject)item)) .Where(item => item.CommitTimeStamp > front.Value) .OrderBy(item => item.CommitTimeStamp); - return rootItems; + return commits; } - protected virtual Task> CreateBatchesAsync(IEnumerable catalogItems) + protected virtual Task> CreateBatchesAsync(IEnumerable catalogItems) { var batches = catalogItems .GroupBy(item => item.CommitTimeStamp) .OrderBy(group => group.Key) - .Select(group => new CatalogItemBatch(group.Key, group)); + .Select(group => new CatalogCommitItemBatch(group)); return Task.FromResult(batches); } protected abstract Task OnProcessBatchAsync( CollectorHttpClient client, - IEnumerable items, + IEnumerable items, JToken context, DateTime commitTimeStamp, bool isLastBatch, CancellationToken cancellationToken); - - protected class CatalogItemBatch : IComparable - { - public CatalogItemBatch(DateTime commitTimeStamp, IEnumerable items) - { - CommitTimeStamp = commitTimeStamp; - Items = items.ToList(); - Items.Sort(); - } - - public DateTime CommitTimeStamp { get; } - public List Items { get; } - - public int CompareTo(object obj) - { - return CommitTimeStamp.CompareTo(((CatalogItem)obj).CommitTimeStamp); - } - } - - protected class CatalogItem : IComparable - { - public CatalogItem(JObject value) - { - CommitTimeStamp = value["commitTimeStamp"].ToObject(); - Uri = value["@id"].ToObject(); - Value = value; - } - - public DateTime CommitTimeStamp { get; } - public Uri Uri { get; } - public JObject Value { get; } - - public int CompareTo(object obj) - { - return CommitTimeStamp.CompareTo(((CatalogItem)obj).CommitTimeStamp); - } - } } } \ No newline at end of file diff --git a/src/Catalog/CreateCommitItemBatchesAsync.cs b/src/Catalog/CreateCommitItemBatchesAsync.cs new file mode 100644 index 000000000..d95efee77 --- /dev/null +++ b/src/Catalog/CreateCommitItemBatchesAsync.cs @@ -0,0 +1,11 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System.Collections.Generic; +using System.Threading.Tasks; + +namespace NuGet.Services.Metadata.Catalog +{ + internal delegate Task> CreateCommitItemBatchesAsync( + IEnumerable catalogItems); +} \ No newline at end of file diff --git a/src/Catalog/Dnx/DnxCatalogCollector.cs b/src/Catalog/Dnx/DnxCatalogCollector.cs index 3af28b824..c3448287d 100644 --- a/src/Catalog/Dnx/DnxCatalogCollector.cs +++ b/src/Catalog/Dnx/DnxCatalogCollector.cs @@ -7,6 +7,7 @@ using System.IO; using System.IO.Compression; using System.Linq; +using System.Net; using System.Net.Http; using System.Threading; using System.Threading.Tasks; @@ -24,7 +25,8 @@ public class DnxCatalogCollector : CommitCollector private readonly IAzureStorage _sourceStorage; private readonly DnxMaker _dnxMaker; private readonly ILogger _logger; - private readonly int _maxDegreeOfParallelism; + private readonly int _maxConcurrentBatches; + private readonly int _maxConcurrentCommitItemsWithinBatch; private readonly Uri _contentBaseAddress; public DnxCatalogCollector( @@ -52,26 +54,57 @@ public DnxCatalogCollector( string.Format(Strings.ArgumentOutOfRange, 1, int.MaxValue)); } - _maxDegreeOfParallelism = maxDegreeOfParallelism; + // Find two factors which are close or equal to each other. + var squareRoot = Math.Sqrt(maxDegreeOfParallelism); + + // If the max degree of parallelism is a perfect square, great. + // Otherwise, prefer a greater degree of parallelism in batches than commit items within a batch. + _maxConcurrentBatches = Convert.ToInt32(Math.Ceiling(squareRoot)); + _maxConcurrentCommitItemsWithinBatch = Convert.ToInt32(maxDegreeOfParallelism / _maxConcurrentBatches); + + ServicePointManager.DefaultConnectionLimit = _maxConcurrentBatches * _maxConcurrentCommitItemsWithinBatch; + } + + protected override Task> CreateBatchesAsync( + IEnumerable catalogItems) + { + var batches = CatalogCommitUtilities.CreateCommitItemBatches( + catalogItems, + CatalogCommitUtilities.GetPackageIdKey); + + return Task.FromResult(batches); + } + + protected override Task FetchAsync( + CollectorHttpClient client, + ReadWriteCursor front, + ReadCursor back, + CancellationToken cancellationToken) + { + return CatalogCommitUtilities.ProcessCatalogCommitsAsync( + client, + front, + back, + FetchCatalogCommitsAsync, + CreateBatchesAsync, + ProcessBatchAsync, + _maxConcurrentBatches, + _logger, + cancellationToken); } protected override async Task OnProcessBatchAsync( CollectorHttpClient client, - IEnumerable items, + IEnumerable items, JToken context, DateTime commitTimeStamp, bool isLastBatch, CancellationToken cancellationToken) { - var catalogEntries = items.Select( - item => new CatalogEntry( - item["nuget:id"].ToString().ToLowerInvariant(), - NuGetVersionUtility.NormalizeVersion(item["nuget:version"].ToString()).ToLowerInvariant(), - item["@type"].ToString().Replace("nuget:", Schema.Prefixes.NuGet), - item)) + var catalogEntries = items.Select(item => CatalogEntry.Create(item)) .ToList(); - // Sanity check: a single catalog batch should not contain multiple entries for the same package ID and version. + // Sanity check: a single catalog batch should not contain multiple entries for the same package identity. AssertNoMultipleEntriesForSamePackageIdentity(commitTimeStamp, catalogEntries); // Process .nupkg/.nuspec adds and deletes. @@ -90,16 +123,16 @@ private async Task> ProcessCatalogEntriesAsync( { var processedCatalogEntries = new ConcurrentBag(); - await catalogEntries.ForEachAsync(_maxDegreeOfParallelism, async catalogEntry => + await catalogEntries.ForEachAsync(_maxConcurrentCommitItemsWithinBatch, async catalogEntry => { var packageId = catalogEntry.PackageId; var normalizedPackageVersion = catalogEntry.NormalizedPackageVersion; - if (catalogEntry.EntryType == Schema.DataTypes.PackageDetails.ToString()) + if (catalogEntry.Type.AbsoluteUri == Schema.DataTypes.PackageDetails.AbsoluteUri) { - var properties = GetTelemetryProperties(catalogEntry); + var telemetryProperties = GetTelemetryProperties(catalogEntry); - using (_telemetryService.TrackDuration(TelemetryConstants.ProcessPackageDetailsSeconds, properties)) + using (_telemetryService.TrackDuration(TelemetryConstants.ProcessPackageDetailsSeconds, telemetryProperties)) { var packageFileName = PackageUtility.GetPackageFileName( packageId, @@ -132,13 +165,14 @@ await catalogEntries.ForEachAsync(_maxDegreeOfParallelism, async catalogEntry => packageId, normalizedPackageVersion, sourceUri, + telemetryProperties, cancellationToken)) { processedCatalogEntries.Add(catalogEntry); } } } - else if (catalogEntry.EntryType == Schema.DataTypes.PackageDelete.ToString()) + else if (catalogEntry.Type.AbsoluteUri == Schema.DataTypes.PackageDelete.AbsoluteUri) { var properties = GetTelemetryProperties(catalogEntry); @@ -175,7 +209,7 @@ private async Task UpdatePackageVersionIndexAsync( { var catalogEntryGroups = catalogEntries.GroupBy(catalogEntry => catalogEntry.PackageId); - await catalogEntryGroups.ForEachAsync(_maxDegreeOfParallelism, async catalogEntryGroup => + await catalogEntryGroups.ForEachAsync(_maxConcurrentCommitItemsWithinBatch, async catalogEntryGroup => { var packageId = catalogEntryGroup.Key; var properties = new Dictionary() @@ -190,11 +224,11 @@ await _dnxMaker.UpdatePackageVersionIndexAsync(packageId, versions => { foreach (var catalogEntry in catalogEntryGroup) { - if (catalogEntry.EntryType == Schema.DataTypes.PackageDetails.ToString()) + if (catalogEntry.Type.AbsoluteUri == Schema.DataTypes.PackageDetails.AbsoluteUri) { versions.Add(NuGetVersion.Parse(catalogEntry.NormalizedPackageVersion)); } - else if (catalogEntry.EntryType == Schema.DataTypes.PackageDelete.ToString()) + else if (catalogEntry.Type.AbsoluteUri == Schema.DataTypes.PackageDelete.AbsoluteUri) { versions.Remove(NuGetVersion.Parse(catalogEntry.NormalizedPackageVersion)); } @@ -214,11 +248,13 @@ private async Task ProcessPackageDetailsAsync( string packageId, string normalizedPackageVersion, Uri sourceUri, + Dictionary telemetryProperties, CancellationToken cancellationToken) { if (await ProcessPackageDetailsViaStorageAsync( packageId, normalizedPackageVersion, + telemetryProperties, cancellationToken)) { return true; @@ -234,12 +270,14 @@ private async Task ProcessPackageDetailsAsync( packageId, normalizedPackageVersion, sourceUri, + telemetryProperties, cancellationToken); } private async Task ProcessPackageDetailsViaStorageAsync( string packageId, string normalizedPackageVersion, + Dictionary telemetryProperties, CancellationToken cancellationToken) { if (_sourceStorage == null) @@ -260,6 +298,8 @@ private async Task ProcessPackageDetailsViaStorageAsync( // If the ETag's differ, we'll fall back to using a single HTTP GET request. var token1 = await _sourceStorage.GetOptimisticConcurrencyControlTokenAsync(sourceUri, cancellationToken); + telemetryProperties[TelemetryConstants.SizeInBytes] = sourceBlob.Length.ToString(); + var nuspec = await GetNuspecAsync(sourceBlob, packageId, cancellationToken); if (string.IsNullOrEmpty(nuspec)) @@ -311,6 +351,7 @@ private async Task ProcessPackageDetailsViaHttpAsync( string id, string version, Uri sourceUri, + Dictionary telemetryProperties, CancellationToken cancellationToken) { var packageDownloader = new PackageDownloader(client, _logger); @@ -325,6 +366,8 @@ private async Task ProcessPackageDetailsViaHttpAsync( return false; } + telemetryProperties[TelemetryConstants.SizeInBytes] = stream.Length.ToString(); + var nuspec = GetNuspec(stream, id); if (nuspec == null) @@ -385,7 +428,7 @@ private static void AssertNoMultipleEntriesForSamePackageIdentity( } } - private static async Task GetNuspecAsync( + private async Task GetNuspecAsync( ICloudBlockBlob sourceBlob, string packageId, CancellationToken cancellationToken) @@ -443,19 +486,60 @@ private static Dictionary GetTelemetryProperties(string packageI }; } + private async Task ProcessBatchAsync( + CollectorHttpClient client, + JToken context, + string packageId, + CatalogCommitItemBatch batch, + CatalogCommitItemBatch lastBatch, + CancellationToken cancellationToken) + { + await Task.Yield(); + + using (_telemetryService.TrackDuration( + TelemetryConstants.ProcessBatchSeconds, + new Dictionary() + { + { TelemetryConstants.Id, packageId }, + { TelemetryConstants.BatchItemCount, batch.Items.Count.ToString() } + })) + { + await OnProcessBatchAsync( + client, + batch.Items, + context, + batch.CommitTimeStamp, + isLastBatch: false, + cancellationToken: cancellationToken); + } + } + private sealed class CatalogEntry { + internal DateTime CommitTimeStamp { get; } internal string PackageId { get; } internal string NormalizedPackageVersion { get; } - internal string EntryType { get; } - internal JToken Entry { get; } + internal Uri Type { get; } - internal CatalogEntry(string packageId, string normalizedPackageVersion, string entryType, JToken entry) + private CatalogEntry(DateTime commitTimeStamp, string packageId, string normalizedPackageVersion, Uri type) { + CommitTimeStamp = commitTimeStamp; PackageId = packageId; NormalizedPackageVersion = normalizedPackageVersion; - EntryType = entryType; - Entry = entry; + Type = type; + } + + internal static CatalogEntry Create(CatalogCommitItem item) + { + var typeUri = item.TypeUris.Single(uri => + uri.AbsoluteUri == Schema.DataTypes.PackageDetails.AbsoluteUri || + uri.AbsoluteUri == Schema.DataTypes.PackageDelete.AbsoluteUri); + + return new CatalogEntry( + item.CommitTimeStamp, + item.PackageIdentity.Id.ToLowerInvariant(), + item.PackageIdentity.Version.ToNormalizedString().ToLowerInvariant(), + typeUri); } } } diff --git a/src/Catalog/Dnx/DnxMaker.cs b/src/Catalog/Dnx/DnxMaker.cs index 478d7a509..732b19e71 100644 --- a/src/Catalog/Dnx/DnxMaker.cs +++ b/src/Catalog/Dnx/DnxMaker.cs @@ -173,7 +173,7 @@ public async Task UpdatePackageVersionIndexAsync(string id, Action result = new List(versions); + var result = new List(versions); if (result.Any()) { diff --git a/src/Catalog/FetchCatalogCommitsAsync.cs b/src/Catalog/FetchCatalogCommitsAsync.cs new file mode 100644 index 000000000..cde21651b --- /dev/null +++ b/src/Catalog/FetchCatalogCommitsAsync.cs @@ -0,0 +1,14 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System.Collections.Generic; +using System.Threading; +using System.Threading.Tasks; + +namespace NuGet.Services.Metadata.Catalog +{ + internal delegate Task> FetchCatalogCommitsAsync( + CollectorHttpClient client, + ReadWriteCursor front, + CancellationToken cancellationToken); +} \ No newline at end of file diff --git a/src/Catalog/GetCatalogCommitItemKey.cs b/src/Catalog/GetCatalogCommitItemKey.cs new file mode 100644 index 000000000..d28bf0659 --- /dev/null +++ b/src/Catalog/GetCatalogCommitItemKey.cs @@ -0,0 +1,7 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +namespace NuGet.Services.Metadata.Catalog +{ + public delegate string GetCatalogCommitItemKey(CatalogCommitItem item); +} \ No newline at end of file diff --git a/src/Catalog/Helpers/CatalogProperties.cs b/src/Catalog/Helpers/CatalogProperties.cs index 9a9fecafc..acef7ed86 100644 --- a/src/Catalog/Helpers/CatalogProperties.cs +++ b/src/Catalog/Helpers/CatalogProperties.cs @@ -2,6 +2,11 @@ // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. using System; +using System.Diagnostics; +using System.Threading; +using System.Threading.Tasks; +using Newtonsoft.Json.Linq; +using NuGet.Services.Metadata.Catalog.Persistence; namespace NuGet.Services.Metadata.Catalog.Helpers { @@ -17,5 +22,68 @@ public CatalogProperties(DateTime? lastCreated, DateTime? lastDeleted, DateTime? LastDeleted = lastDeleted; LastEdited = lastEdited; } + + /// + /// Asynchronously reads and returns top-level metadata from the catalog's index.json. + /// + /// The metadata values include "nuget:lastCreated", "nuget:lastDeleted", and "nuget:lastEdited", + /// which are the timestamps of the catalog cursor. + /// + /// + /// + /// A task that represents the asynchronous operation. + /// The task result () returns a . + /// Thrown if is null. + /// Thrown if + /// is cancelled. + public static async Task ReadAsync( + IStorage storage, + ITelemetryService telemetryService, + CancellationToken cancellationToken) + { + if (storage == null) + { + throw new ArgumentNullException(nameof(storage)); + } + + if (telemetryService == null) + { + throw new ArgumentNullException(nameof(telemetryService)); + } + + cancellationToken.ThrowIfCancellationRequested(); + + DateTime? lastCreated = null; + DateTime? lastDeleted = null; + DateTime? lastEdited = null; + + var stopwatch = Stopwatch.StartNew(); + var indexUri = storage.ResolveUri("index.json"); + var json = await storage.LoadStringAsync(indexUri, cancellationToken); + + if (json != null) + { + var obj = JObject.Parse(json); + telemetryService.TrackCatalogIndexReadDuration(stopwatch.Elapsed, indexUri); + JToken token; + + if (obj.TryGetValue("nuget:lastCreated", out token)) + { + lastCreated = token.ToObject().ToUniversalTime(); + } + + if (obj.TryGetValue("nuget:lastDeleted", out token)) + { + lastDeleted = token.ToObject().ToUniversalTime(); + } + + if (obj.TryGetValue("nuget:lastEdited", out token)) + { + lastEdited = token.ToObject().ToUniversalTime(); + } + } + + return new CatalogProperties(lastCreated, lastDeleted, lastEdited); + } } } \ No newline at end of file diff --git a/src/Catalog/Helpers/FeedHelpers.cs b/src/Catalog/Helpers/FeedHelpers.cs index f8d67fb97..e4162cbea 100644 --- a/src/Catalog/Helpers/FeedHelpers.cs +++ b/src/Catalog/Helpers/FeedHelpers.cs @@ -3,7 +3,6 @@ using System; using System.Collections.Generic; -using System.Diagnostics; using System.Linq; using System.Net.Http; using System.Threading; @@ -11,7 +10,6 @@ using System.Web; using System.Xml.Linq; using Microsoft.Extensions.Logging; -using Newtonsoft.Json.Linq; using NuGet.Services.Metadata.Catalog.Persistence; namespace NuGet.Services.Metadata.Catalog.Helpers @@ -30,69 +28,6 @@ public static HttpClient CreateHttpClient(Func handlerFunc) return new HttpClient(handler); } - /// - /// Asynchronously reads and returns top-level metadata from the catalog's index.json. - /// - /// The metadata values include "nuget:lastCreated", "nuget:lastDeleted", and "nuget:lastEdited", - /// which are the timestamps of the catalog cursor. - /// - /// - /// - /// A task that represents the asynchronous operation. - /// The task result () returns a . - /// Thrown if is null. - /// Thrown if - /// is cancelled. - public static async Task GetCatalogPropertiesAsync( - IStorage storage, - ITelemetryService telemetryService, - CancellationToken cancellationToken) - { - if (storage == null) - { - throw new ArgumentNullException(nameof(storage)); - } - - if (telemetryService == null) - { - throw new ArgumentNullException(nameof(telemetryService)); - } - - cancellationToken.ThrowIfCancellationRequested(); - - DateTime? lastCreated = null; - DateTime? lastDeleted = null; - DateTime? lastEdited = null; - - var stopwatch = Stopwatch.StartNew(); - var indexUri = storage.ResolveUri("index.json"); - var json = await storage.LoadStringAsync(indexUri, cancellationToken); - - if (json != null) - { - var obj = JObject.Parse(json); - telemetryService.TrackCatalogIndexReadDuration(stopwatch.Elapsed, indexUri); - JToken token; - - if (obj.TryGetValue("nuget:lastCreated", out token)) - { - lastCreated = token.ToObject().ToUniversalTime(); - } - - if (obj.TryGetValue("nuget:lastDeleted", out token)) - { - lastDeleted = token.ToObject().ToUniversalTime(); - } - - if (obj.TryGetValue("nuget:lastEdited", out token)) - { - lastEdited = token.ToObject().ToUniversalTime(); - } - } - - return new CatalogProperties(lastCreated, lastDeleted, lastEdited); - } - /// /// Builds a for accessing the metadata of a specific package on the feed. /// diff --git a/src/Catalog/Helpers/Utils.cs b/src/Catalog/Helpers/Utils.cs index 795cd4941..3bbcdb01d 100644 --- a/src/Catalog/Helpers/Utils.cs +++ b/src/Catalog/Helpers/Utils.cs @@ -6,6 +6,7 @@ using System.Collections.Generic; using System.Collections.ObjectModel; using System.Diagnostics; +using System.Globalization; using System.IO; using System.IO.Compression; using System.Linq; @@ -346,21 +347,13 @@ public static bool IsType(JToken context, JToken obj, Uri type) return false; } - public static bool IsType(JToken context, JObject obj, Uri[] types) + public static Uri Expand(JToken context, JToken token) { - foreach (Uri type in types) - { - if (IsType(context, obj, type)) - { - return true; - } - } - return false; + return Expand(context, token.ToString()); } - public static Uri Expand(JToken context, JToken token) + public static Uri Expand(JToken context, string term) { - string term = token.ToString(); if (term.StartsWith("http:", StringComparison.OrdinalIgnoreCase)) { return new Uri(term); @@ -563,5 +556,25 @@ public static void TraceException(Exception e) } } } + + internal static T Deserialize(JObject jObject, string propertyName) + { + if (jObject == null) + { + throw new ArgumentNullException(nameof(jObject)); + } + + if (string.IsNullOrEmpty(propertyName)) + { + throw new ArgumentException(Strings.ArgumentMustNotBeNullOrEmpty, nameof(propertyName)); + } + + if (!jObject.TryGetValue(propertyName, out var value) || value == null) + { + throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, Strings.PropertyRequired, propertyName)); + } + + return value.ToObject(); + } } } \ No newline at end of file diff --git a/src/Catalog/IHttpRetryStrategy.cs b/src/Catalog/IHttpRetryStrategy.cs new file mode 100644 index 000000000..ea03c3858 --- /dev/null +++ b/src/Catalog/IHttpRetryStrategy.cs @@ -0,0 +1,15 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using System.Net.Http; +using System.Threading; +using System.Threading.Tasks; + +namespace NuGet.Services.Metadata.Catalog +{ + public interface IHttpRetryStrategy + { + Task SendAsync(HttpClient client, Uri address, CancellationToken cancellationToken); + } +} \ No newline at end of file diff --git a/src/Catalog/NuGet.Services.Metadata.Catalog.csproj b/src/Catalog/NuGet.Services.Metadata.Catalog.csproj index c346b91b9..1da06185f 100644 --- a/src/Catalog/NuGet.Services.Metadata.Catalog.csproj +++ b/src/Catalog/NuGet.Services.Metadata.Catalog.csproj @@ -82,21 +82,30 @@ + + + + + + + + + @@ -114,6 +123,7 @@ + diff --git a/src/Catalog/Persistence/AzureCloudBlockBlob.cs b/src/Catalog/Persistence/AzureCloudBlockBlob.cs index 0071e29ad..4e0a431df 100644 --- a/src/Catalog/Persistence/AzureCloudBlockBlob.cs +++ b/src/Catalog/Persistence/AzureCloudBlockBlob.cs @@ -26,6 +26,7 @@ public string ContentMD5 } public string ETag => _blob.Properties.ETag; + public long Length => _blob.Properties.Length; public Uri Uri => _blob.Uri; public AzureCloudBlockBlob(CloudBlockBlob blob) diff --git a/src/Catalog/Persistence/AzureStorage.cs b/src/Catalog/Persistence/AzureStorage.cs index 714b8705d..444143df4 100644 --- a/src/Catalog/Persistence/AzureStorage.cs +++ b/src/Catalog/Persistence/AzureStorage.cs @@ -20,7 +20,6 @@ public class AzureStorage : Storage, IAzureStorage { private readonly bool _compressContent; private readonly CloudBlobDirectory _directory; - private readonly BlobRequestOptions _blobRequestOptions; private readonly bool _useServerSideCopy; public static readonly TimeSpan DefaultServerTimeout = TimeSpan.FromSeconds(30); @@ -72,22 +71,24 @@ private AzureStorage(CloudBlobDirectory directory, Uri baseAddress, TimeSpan max { _directory = directory; + // Unless overridden at the level of a single API call, these options will apply to all service calls that + // use BlobRequestOptions. + _directory.ServiceClient.DefaultRequestOptions = new BlobRequestOptions() + { + ServerTimeout = serverTimeout, + MaximumExecutionTime = maxExecutionTime, + RetryPolicy = new ExponentialRetry() + }; + if (_directory.Container.CreateIfNotExists()) { _directory.Container.SetPermissions(new BlobContainerPermissions { PublicAccess = BlobContainerPublicAccessType.Blob }); if (Verbose) { - Trace.WriteLine(String.Format("Created '{0}' publish container", _directory.Container.Name)); + Trace.WriteLine(string.Format("Created '{0}' publish container", _directory.Container.Name)); } } - - _blobRequestOptions = new BlobRequestOptions() - { - ServerTimeout = serverTimeout, - MaximumExecutionTime = maxExecutionTime, - RetryPolicy = new ExponentialRetry() - }; } public override async Task GetOptimisticConcurrencyControlTokenAsync( @@ -134,7 +135,7 @@ public override bool Exists(string fileName) } if (Verbose) { - Trace.WriteLine(String.Format("The blob {0} does not exist.", packageRegistrationUri)); + Trace.WriteLine(string.Format("The blob {0} does not exist.", packageRegistrationUri)); } return false; } @@ -230,11 +231,7 @@ protected override async Task OnSaveAsync(Uri resourceUri, StorageContent conten destinationStream.Seek(0, SeekOrigin.Begin); - await blob.UploadFromStreamAsync(destinationStream, - accessCondition: null, - options: _blobRequestOptions, - operationContext: null, - cancellationToken: cancellationToken); + await blob.UploadFromStreamAsync(destinationStream, cancellationToken); Trace.WriteLine(string.Format("Saved compressed blob {0} to container {1}", blob.Uri.ToString(), _directory.Container.Name)); } @@ -243,11 +240,7 @@ await blob.UploadFromStreamAsync(destinationStream, { using (Stream stream = content.GetContentStream()) { - await blob.UploadFromStreamAsync(stream, - accessCondition: null, - options: _blobRequestOptions, - operationContext: null, - cancellationToken: cancellationToken); + await blob.UploadFromStreamAsync(stream, cancellationToken); } Trace.WriteLine(string.Format("Saved uncompressed blob {0} to container {1}", blob.Uri.ToString(), _directory.Container.Name)); @@ -306,32 +299,30 @@ protected override async Task OnLoadAsync(Uri resourceUri, Cance if (blob.Exists()) { - MemoryStream originalStream = new MemoryStream(); - await blob.DownloadToStreamAsync(originalStream, - accessCondition: null, - options: _blobRequestOptions, - operationContext: null, - cancellationToken: cancellationToken); - - originalStream.Seek(0, SeekOrigin.Begin); - string content; - if (blob.Properties.ContentEncoding == "gzip") + using (var originalStream = new MemoryStream()) { - using (var uncompressedStream = new GZipStream(originalStream, CompressionMode.Decompress)) + await blob.DownloadToStreamAsync(originalStream, cancellationToken); + + originalStream.Seek(0, SeekOrigin.Begin); + + if (blob.Properties.ContentEncoding == "gzip") { - using (var reader = new StreamReader(uncompressedStream)) + using (var uncompressedStream = new GZipStream(originalStream, CompressionMode.Decompress)) { - content = await reader.ReadToEndAsync(); + using (var reader = new StreamReader(uncompressedStream)) + { + content = await reader.ReadToEndAsync(); + } } } - } - else - { - using (var reader = new StreamReader(originalStream)) + else { - content = await reader.ReadToEndAsync(); + using (var reader = new StreamReader(originalStream)) + { + content = await reader.ReadToEndAsync(); + } } } @@ -340,7 +331,7 @@ await blob.DownloadToStreamAsync(originalStream, if (Verbose) { - Trace.WriteLine(String.Format("Can't load '{0}'. Blob doesn't exist", resourceUri)); + Trace.WriteLine(string.Format("Can't load '{0}'. Blob doesn't exist", resourceUri)); } return null; @@ -353,7 +344,7 @@ protected override async Task OnDeleteAsync(Uri resourceUri, CancellationToken c CloudBlockBlob blob = _directory.GetBlockBlobReference(name); await blob.DeleteAsync(deleteSnapshotsOption: DeleteSnapshotsOption.IncludeSnapshots, accessCondition: null, - options: _blobRequestOptions, + options: null, operationContext: null, cancellationToken: cancellationToken); } diff --git a/src/Catalog/Persistence/ICloudBlockBlob.cs b/src/Catalog/Persistence/ICloudBlockBlob.cs index 1ec994b14..1e17a7b0d 100644 --- a/src/Catalog/Persistence/ICloudBlockBlob.cs +++ b/src/Catalog/Persistence/ICloudBlockBlob.cs @@ -15,6 +15,7 @@ public interface ICloudBlockBlob { string ContentMD5 { get; set; } string ETag { get; } + long Length { get; } Uri Uri { get; } Task ExistsAsync(CancellationToken cancellationToken); diff --git a/src/Catalog/ProcessCommitItemBatchAsync.cs b/src/Catalog/ProcessCommitItemBatchAsync.cs new file mode 100644 index 000000000..71664dc0e --- /dev/null +++ b/src/Catalog/ProcessCommitItemBatchAsync.cs @@ -0,0 +1,17 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System.Threading; +using System.Threading.Tasks; +using Newtonsoft.Json.Linq; + +namespace NuGet.Services.Metadata.Catalog +{ + public delegate Task ProcessCommitItemBatchAsync( + CollectorHttpClient client, + JToken context, + string packageId, + CatalogCommitItemBatch batch, + CatalogCommitItemBatch lastBatch, + CancellationToken cancellationToken); +} \ No newline at end of file diff --git a/src/Catalog/Registration/RegistrationCollector.cs b/src/Catalog/Registration/RegistrationCollector.cs index 7a318af27..983edc8c7 100644 --- a/src/Catalog/Registration/RegistrationCollector.cs +++ b/src/Catalog/Registration/RegistrationCollector.cs @@ -3,11 +3,10 @@ using System; using System.Collections.Generic; -using System.Diagnostics; -using System.Linq; using System.Net.Http; using System.Threading; using System.Threading.Tasks; +using Microsoft.Extensions.Logging; using Newtonsoft.Json.Linq; using NuGet.Services.Metadata.Catalog.Helpers; using NuGet.Services.Metadata.Catalog.Persistence; @@ -27,9 +26,7 @@ public class RegistrationCollector : SortingGraphCollector private readonly StorageFactory _semVer2StorageFactory; private readonly ShouldIncludeRegistrationPackage _shouldIncludeSemVer2; private readonly int _maxConcurrentBatches; - - // Doesn't exist until .NET 4.6 - private static readonly Task CompletedTask = Task.FromResult(0); + private readonly ILogger _logger; public RegistrationCollector( Uri index, @@ -37,11 +34,19 @@ public RegistrationCollector( StorageFactory semVer2StorageFactory, Uri contentBaseAddress, ITelemetryService telemetryService, + ILogger logger, Func handlerFunc = null, + IHttpRetryStrategy httpRetryStrategy = null, int maxConcurrentBatches = DefaultMaxConcurrentBatches) - : base(index, new Uri[] { Schema.DataTypes.PackageDetails, Schema.DataTypes.PackageDelete }, telemetryService, handlerFunc) + : base( + index, + new Uri[] { Schema.DataTypes.PackageDetails, Schema.DataTypes.PackageDelete }, + telemetryService, + handlerFunc, + httpRetryStrategy) { _legacyStorageFactory = legacyStorageFactory ?? throw new ArgumentNullException(nameof(legacyStorageFactory)); + _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _semVer2StorageFactory = semVer2StorageFactory; _shouldIncludeSemVer2 = GetShouldIncludeRegistrationPackage(_semVer2StorageFactory); ContentBaseAddress = contentBaseAddress; @@ -59,7 +64,8 @@ public RegistrationCollector( public Uri ContentBaseAddress { get; } - protected override Task> CreateBatchesAsync(IEnumerable catalogItems) + protected override Task> CreateBatchesAsync( + IEnumerable catalogItems) { // Grouping batches by commit is slow if it contains // the same package registration id over and over again. @@ -80,31 +86,14 @@ protected override Task> CreateBatchesAsync(IEnume // from the correct location (even though we may have // a little rework). - var batches = catalogItems - .GroupBy(item => GetKey(item.Value)) - .Select(group => new CatalogItemBatch( - group.Min(item => item.CommitTimeStamp), - group)); + var batches = CatalogCommitUtilities.CreateCommitItemBatches(catalogItems, GetKey); return Task.FromResult(batches); } - private async Task CreateBatchesAsync(ReadWriteCursor front, ReadCursor back, JObject page) + protected override string GetKey(CatalogCommitItem item) { - IEnumerable pageItems = page["items"] - .Select(item => new CatalogItem((JObject)item)) - .Where(item => item.CommitTimeStamp > front.Value && item.CommitTimeStamp <= back.Value); - - IEnumerable batches = await CreateBatchesAsync(pageItems); - - return batches - .OrderBy(batch => batch.CommitTimeStamp) - .ToArray(); - } - - protected override string GetKey(JObject item) - { - return item["nuget:id"].ToString().ToLowerInvariant(); + return CatalogCommitUtilities.GetPackageIdKey(item); } // Summary: @@ -120,111 +109,22 @@ protected override string GetKey(JObject item) // been transactional. Actively cancelling tasks would make an inconsistent registration more likely. // 6. Update the cursor if and only if all preceding commits and the current (oldest) commit have been // fully and successfully processed. - protected override async Task FetchAsync( + protected override Task FetchAsync( CollectorHttpClient client, ReadWriteCursor front, ReadCursor back, CancellationToken cancellationToken) { - IEnumerable catalogItems = await FetchCatalogItemsAsync(client, front, cancellationToken); - - var hasAnyBatchFailed = false; - var hasAnyBatchBeenProcessed = false; - - foreach (CatalogItem catalogItem in catalogItems) - { - JObject page = await client.GetJObjectAsync(catalogItem.Uri, cancellationToken); - JToken context = page["@context"]; - CatalogItemBatch[] batches = await CreateBatchesAsync(front, back, page); - SortedDictionary commitBatchTasksMap = CreateCommitBatchTasksMap(batches); - - var unprocessedBatches = new Queue(batches); - var processingBatches = new Queue(); - - CatalogItemBatch lastBatch = unprocessedBatches.LastOrDefault(); - var exceptions = new List(); - - EnqueueBatchesIfNoFailures( - client, - context, - commitBatchTasksMap, - unprocessedBatches, - processingBatches, - lastBatch, - cancellationToken); - - while (processingBatches.Any()) - { - var activeTasks = processingBatches.Where(batch => !batch.Task.IsCompleted) - .Select(batch => batch.Task) - .DefaultIfEmpty(CompletedTask); - - await Task.WhenAny(activeTasks); - - while (!hasAnyBatchFailed && commitBatchTasksMap.Any()) - { - var commitBatchTasks = commitBatchTasksMap.First().Value; - var isCommitFullyProcessed = commitBatchTasks.BatchTasks.All(batch => batch.Task != null && batch.Task.IsCompleted); - - if (!isCommitFullyProcessed) - { - break; - } - - var isCommitSuccessfullyProcessed = commitBatchTasks.BatchTasks.All(batch => batch.Task.Status == TaskStatus.RanToCompletion); - - if (isCommitSuccessfullyProcessed) - { - var commitTimeStamp = commitBatchTasks.CommitTimeStamp; - - front.Value = commitTimeStamp; - - await front.SaveAsync(cancellationToken); - - Trace.TraceInformation($"{nameof(RegistrationCollector)}.{nameof(FetchAsync)} {nameof(front)}.{nameof(front.Value)} saved since timestamp changed from previous: {{0}}", front); - - DequeueBatchesWhileMatches(processingBatches, batch => batch.CommitTimeStamp == commitTimeStamp); - - commitBatchTasksMap.Remove(commitTimeStamp); - } - else // Canceled or Failed - { - hasAnyBatchFailed = true; - - exceptions.AddRange( - commitBatchTasks.BatchTasks - .Select(batch => batch.Task) - .Where(task => (task.IsFaulted || task.IsCanceled) && task.Exception != null) - .Select(task => task.Exception)); - } - } - - if (hasAnyBatchFailed) - { - DequeueBatchesWhileMatches(processingBatches, batch => batch.Task.IsCompleted); - } - - hasAnyBatchBeenProcessed = true; - - EnqueueBatchesIfNoFailures( - client, - context, - commitBatchTasksMap, - unprocessedBatches, - processingBatches, - lastBatch, - cancellationToken); - } - - if (hasAnyBatchFailed) - { - var innerException = exceptions.Count == 1 ? exceptions.Single() : new AggregateException(exceptions); - - throw new BatchProcessingException(innerException); - } - } - - return hasAnyBatchBeenProcessed; + return CatalogCommitUtilities.ProcessCatalogCommitsAsync( + client, + front, + back, + FetchCatalogCommitsAsync, + CreateBatchesAsync, + ProcessBatchAsync, + _maxConcurrentBatches, + _logger, + cancellationToken); } protected override async Task ProcessGraphsAsync( @@ -282,64 +182,12 @@ public static ShouldIncludeRegistrationPackage GetShouldIncludeRegistrationPacka return (k, u, g) => !NuGetVersionUtility.IsGraphSemVer2(k.Version, u, g); } - private static void DequeueBatchesWhileMatches(Queue batches, Func isMatch) - { - BatchTask batch; - - while ((batch = batches.FirstOrDefault()) != null) - { - if (isMatch(batch)) - { - batches.Dequeue(); - } - else - { - break; - } - } - } - - private void EnqueueBatchesIfNoFailures( - CollectorHttpClient client, - JToken context, - SortedDictionary commitBatchTasksMap, - Queue unprocessedBatches, - Queue processingBatches, - CatalogItemBatch lastBatch, - CancellationToken cancellationToken) - { - var hasAnyBatchFailed = processingBatches.Any(batch => batch.Task.IsFaulted || batch.Task.IsCanceled); - - if (hasAnyBatchFailed) - { - return; - } - - var batchesToEnqueue = Math.Min( - _maxConcurrentBatches - processingBatches.Count(batch => !batch.Task.IsCompleted), - unprocessedBatches.Count); - - for (var i = 0; i < batchesToEnqueue; ++i) - { - var batch = unprocessedBatches.Dequeue(); - var batchItem = batch.Items.First(); - var packageId = GetKey(batchItem.Value); - - var batchTask = commitBatchTasksMap[batchItem.CommitTimeStamp].BatchTasks - .Single(bt => bt.PackageId == packageId); - - batchTask.Task = ProcessBatchAsync(client, context, packageId, batch, lastBatch, cancellationToken); - - processingBatches.Enqueue(batchTask); - } - } - private async Task ProcessBatchAsync( CollectorHttpClient client, JToken context, string packageId, - CatalogItemBatch batch, - CatalogItemBatch lastBatch, + CatalogCommitItemBatch batch, + CatalogCommitItemBatch lastBatch, CancellationToken cancellationToken) { await Task.Yield(); @@ -354,82 +202,12 @@ private async Task ProcessBatchAsync( { await OnProcessBatchAsync( client, - batch.Items.Select(item => item.Value), + batch.Items, context, batch.CommitTimeStamp, - batch.CommitTimeStamp == lastBatch.CommitTimeStamp, - cancellationToken); - } - } - - private SortedDictionary CreateCommitBatchTasksMap(CatalogItemBatch[] batches) - { - var map = new SortedDictionary(); - - foreach (var batch in batches) - { - var jObject = batch.Items.First().Value; - var packageId = GetKey(jObject); - var batchTask = new BatchTask(batch.CommitTimeStamp, packageId); - - foreach (var commitTimeStamp in batch.Items.Select(item => item.CommitTimeStamp)) - { - CommitBatchTasks commitBatchTasks; - - if (!map.TryGetValue(commitTimeStamp, out commitBatchTasks)) - { - commitBatchTasks = new CommitBatchTasks(commitTimeStamp); - - map[commitTimeStamp] = commitBatchTasks; - } - - commitBatchTasks.BatchTasks.Add(batchTask); - } - } - - return map; - } - - private sealed class BatchTask - { - internal BatchTask(DateTime commitTimeStamp, string packageId) - { - CommitTimeStamp = commitTimeStamp; - PackageId = packageId; - } - - internal DateTime CommitTimeStamp { get; } - internal string PackageId { get; } - internal Task Task { get; set; } - - public override int GetHashCode() - { - return PackageId.GetHashCode(); - } - - public override bool Equals(object obj) - { - var other = obj as BatchTask; - - if (ReferenceEquals(other, null)) - { - return false; - } - - return GetHashCode() == other.GetHashCode(); - } - } - - private sealed class CommitBatchTasks - { - internal CommitBatchTasks(DateTime commitTimeStamp) - { - BatchTasks = new HashSet(); - CommitTimeStamp = commitTimeStamp; + isLastBatch: false, + cancellationToken: cancellationToken); } - - internal HashSet BatchTasks { get; } - internal DateTime CommitTimeStamp { get; } } } } \ No newline at end of file diff --git a/src/Catalog/RetryWithExponentialBackoff.cs b/src/Catalog/RetryWithExponentialBackoff.cs index 0cf7acc8c..56505e27f 100644 --- a/src/Catalog/RetryWithExponentialBackoff.cs +++ b/src/Catalog/RetryWithExponentialBackoff.cs @@ -10,7 +10,7 @@ namespace NuGet.Services.Metadata.Catalog { // See https://docs.microsoft.com/en-us/dotnet/standard/microservices-architecture/implement-resilient-applications/implement-custom-http-call-retries-exponential-backoff - internal sealed class RetryWithExponentialBackoff + internal sealed class RetryWithExponentialBackoff : IHttpRetryStrategy { private readonly ushort _maximumRetries; private readonly TimeSpan _delay; @@ -23,7 +23,7 @@ internal RetryWithExponentialBackoff() _maximumDelay = TimeSpan.FromSeconds(10); } - internal async Task SendAsync(HttpClient client, Uri address, CancellationToken cancellationToken) + public async Task SendAsync(HttpClient client, Uri address, CancellationToken cancellationToken) { var backoff = new ExponentialBackoff(_maximumRetries, _delay, _maximumDelay); @@ -56,9 +56,10 @@ internal async Task SendAsync(HttpClient client, Uri addres private static bool IsTransientError(HttpResponseMessage response) { - return (int)response.StatusCode >= 500 && - response.StatusCode != HttpStatusCode.NotImplemented && - response.StatusCode != HttpStatusCode.HttpVersionNotSupported; + return response == null + || ((int)response.StatusCode >= 500 && + response.StatusCode != HttpStatusCode.NotImplemented && + response.StatusCode != HttpStatusCode.HttpVersionNotSupported); } private sealed class ExponentialBackoff diff --git a/src/Catalog/SortingCollector.cs b/src/Catalog/SortingCollector.cs index 7524c18b4..bc06124cd 100644 --- a/src/Catalog/SortingCollector.cs +++ b/src/Catalog/SortingCollector.cs @@ -13,29 +13,33 @@ namespace NuGet.Services.Metadata.Catalog { public abstract class SortingCollector : CommitCollector where T : IEquatable { - public SortingCollector(Uri index, ITelemetryService telemetryService, Func handlerFunc = null) - : base(index, telemetryService, handlerFunc) + public SortingCollector( + Uri index, + ITelemetryService telemetryService, + Func handlerFunc = null, + IHttpRetryStrategy httpRetryStrategy = null) + : base(index, telemetryService, handlerFunc, httpRetryStrategy: httpRetryStrategy) { } protected override async Task OnProcessBatchAsync( CollectorHttpClient client, - IEnumerable items, + IEnumerable items, JToken context, DateTime commitTimeStamp, bool isLastBatch, CancellationToken cancellationToken) { - IDictionary> sortedItems = new Dictionary>(); + var sortedItems = new Dictionary>(); - foreach (JObject item in items) + foreach (CatalogCommitItem item in items) { T key = GetKey(item); - IList itemList; + IList itemList; if (!sortedItems.TryGetValue(key, out itemList)) { - itemList = new List(); + itemList = new List(); sortedItems.Add(key, itemList); } @@ -44,7 +48,7 @@ protected override async Task OnProcessBatchAsync( IList tasks = new List(); - foreach (KeyValuePair> sortedBatch in sortedItems) + foreach (KeyValuePair> sortedBatch in sortedItems) { Task task = ProcessSortedBatchAsync(client, sortedBatch, context, cancellationToken); @@ -56,11 +60,11 @@ protected override async Task OnProcessBatchAsync( return true; } - protected abstract T GetKey(JObject item); + protected abstract T GetKey(CatalogCommitItem item); protected abstract Task ProcessSortedBatchAsync( CollectorHttpClient client, - KeyValuePair> sortedBatch, + KeyValuePair> sortedBatch, JToken context, CancellationToken cancellationToken); } diff --git a/src/Catalog/SortingGraphCollector.cs b/src/Catalog/SortingGraphCollector.cs index af1034fa1..75e70ae65 100644 --- a/src/Catalog/SortingGraphCollector.cs +++ b/src/Catalog/SortingGraphCollector.cs @@ -20,15 +20,16 @@ public SortingGraphCollector( Uri index, Uri[] types, ITelemetryService telemetryService, - Func handlerFunc = null) - : base(index, telemetryService, handlerFunc) + Func handlerFunc = null, + IHttpRetryStrategy httpRetryStrategy = null) + : base(index, telemetryService, handlerFunc, httpRetryStrategy) { _types = types; } protected override async Task ProcessSortedBatchAsync( CollectorHttpClient client, - KeyValuePair> sortedBatch, + KeyValuePair> sortedBatch, JToken context, CancellationToken cancellationToken) { @@ -37,16 +38,25 @@ protected override async Task ProcessSortedBatchAsync( foreach (var item in sortedBatch.Value) { - if (Utils.IsType((JObject)context, item, _types)) + var isMatch = false; + + foreach (Uri type in _types) { - var itemUri = item["@id"].ToString(); + if (item.TypeUris.Any(typeUri => typeUri.AbsoluteUri == type.AbsoluteUri)) + { + isMatch = true; + break; + } + } + if (isMatch) + { // Load package details from catalog. // Download the graph to a read-only container. This allows operations on each graph to be safely // parallelized. - var task = client.GetGraphAsync(new Uri(itemUri), readOnly: true, token: cancellationToken); + var task = client.GetGraphAsync(item.Uri, readOnly: true, token: cancellationToken); - graphTasks.Add(itemUri, task); + graphTasks.Add(item.Uri.AbsoluteUri, task); } } diff --git a/src/Catalog/SortingIdCollector.cs b/src/Catalog/SortingIdCollector.cs index b39ba1ac6..ea45ed787 100644 --- a/src/Catalog/SortingIdCollector.cs +++ b/src/Catalog/SortingIdCollector.cs @@ -3,19 +3,23 @@ using System; using System.Net.Http; -using Newtonsoft.Json.Linq; namespace NuGet.Services.Metadata.Catalog { public abstract class SortingIdCollector : SortingCollector { - public SortingIdCollector(Uri index, ITelemetryService telemetryService, Func handlerFunc = null) : base(index, telemetryService, handlerFunc) + public SortingIdCollector( + Uri index, + ITelemetryService telemetryService, + Func handlerFunc = null, + IHttpRetryStrategy retryStrategy = null) + : base(index, telemetryService, handlerFunc, retryStrategy) { } - protected override string GetKey(JObject item) + protected override string GetKey(CatalogCommitItem item) { - return item["nuget:id"].ToString(); + return item.PackageIdentity.Id; } } -} +} \ No newline at end of file diff --git a/src/Catalog/SortingIdVersionCollector.cs b/src/Catalog/SortingIdVersionCollector.cs index 8911e7221..b21fd0354 100644 --- a/src/Catalog/SortingIdVersionCollector.cs +++ b/src/Catalog/SortingIdVersionCollector.cs @@ -3,7 +3,6 @@ using System; using System.Net.Http; -using Newtonsoft.Json.Linq; using NuGet.Services.Metadata.Catalog.Helpers; namespace NuGet.Services.Metadata.Catalog @@ -15,9 +14,9 @@ public SortingIdVersionCollector(Uri index, ITelemetryService telemetryService, { } - protected override FeedPackageIdentity GetKey(JObject item) + protected override FeedPackageIdentity GetKey(CatalogCommitItem item) { - return new FeedPackageIdentity(item["nuget:id"].ToString(), item["nuget:version"].ToString()); + return new FeedPackageIdentity(item.PackageIdentity); } } -} +} \ No newline at end of file diff --git a/src/Catalog/Strings.Designer.cs b/src/Catalog/Strings.Designer.cs index 3a222b5de..0a51f5ae6 100644 --- a/src/Catalog/Strings.Designer.cs +++ b/src/Catalog/Strings.Designer.cs @@ -60,6 +60,24 @@ internal Strings() { } } + /// + /// Looks up a localized string similar to The argument must be an instance of type {0}.. + /// + internal static string ArgumentMustBeInstanceOfType { + get { + return ResourceManager.GetString("ArgumentMustBeInstanceOfType", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The argument must not be null.. + /// + internal static string ArgumentMustNotBeNull { + get { + return ResourceManager.GetString("ArgumentMustNotBeNull", resourceCulture); + } + } + /// /// Looks up a localized string similar to The argument must not be null, empty, or whitespace.. /// @@ -95,5 +113,32 @@ internal static string BatchProcessingFailure { return ResourceManager.GetString("BatchProcessingFailure", resourceCulture); } } + + /// + /// Looks up a localized string similar to Multiple commits exist with the same commit timestamp but different commit ID's: {0}.. + /// + internal static string MultipleCommitIdsForSameCommitTimeStamp { + get { + return ResourceManager.GetString("MultipleCommitIdsForSameCommitTimeStamp", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The value of property '{0}' must be non-null and non-empty.. + /// + internal static string NonEmptyPropertyValueRequired { + get { + return ResourceManager.GetString("NonEmptyPropertyValueRequired", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to The property '{0}' is required and is value must not be null.. + /// + internal static string PropertyRequired { + get { + return ResourceManager.GetString("PropertyRequired", resourceCulture); + } + } } } diff --git a/src/Catalog/Strings.resx b/src/Catalog/Strings.resx index 81e1cc1ad..08c278616 100644 --- a/src/Catalog/Strings.resx +++ b/src/Catalog/Strings.resx @@ -117,6 +117,12 @@ System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + The argument must be an instance of type {0}. + + + The argument must not be null. + The argument must not be null, empty, or whitespace. @@ -129,4 +135,13 @@ A failure occurred while processing a catalog batch. + + Multiple commits exist with the same commit timestamp but different commit ID's: {0}. + + + The value of property '{0}' must be non-null and non-empty. + + + The property '{0}' is required and is value must not be null. + \ No newline at end of file diff --git a/src/Catalog/Telemetry/TelemetryConstants.cs b/src/Catalog/Telemetry/TelemetryConstants.cs index 3ba1be6b0..ed0a64de7 100644 --- a/src/Catalog/Telemetry/TelemetryConstants.cs +++ b/src/Catalog/Telemetry/TelemetryConstants.cs @@ -39,6 +39,7 @@ public static class TelemetryConstants public const string ProcessPackageDetailsSeconds = "ProcessPackageDetailsSeconds"; public const string ProcessPackageVersionIndexSeconds = "ProcessPackageVersionIndexSeconds"; public const string RegistrationDeltaCount = "RegistrationDeltaCount"; + public const string SizeInBytes = "SizeInBytes"; public const string StatusCode = "StatusCode"; public const string Success = "Success"; public const string Uri = "Uri"; diff --git a/src/Ng/Jobs/Catalog2DnxJob.cs b/src/Ng/Jobs/Catalog2DnxJob.cs index 996951b63..6f9e7ac90 100644 --- a/src/Ng/Jobs/Catalog2DnxJob.cs +++ b/src/Ng/Jobs/Catalog2DnxJob.cs @@ -79,6 +79,8 @@ protected override void Init(IDictionary arguments, Cancellation preferredPackageSourceStorageFactory); Logger.LogInformation("HTTP client timeout: {Timeout}", httpClientTimeout); + MaxDegreeOfParallelism = 256; + _collector = new DnxCatalogCollector( new Uri(source), storageFactory, diff --git a/src/Ng/Jobs/Catalog2RegistrationJob.cs b/src/Ng/Jobs/Catalog2RegistrationJob.cs index 65e9e47ae..6ac270905 100644 --- a/src/Ng/Jobs/Catalog2RegistrationJob.cs +++ b/src/Ng/Jobs/Catalog2RegistrationJob.cs @@ -104,6 +104,7 @@ protected override void Init(IDictionary arguments, Cancellation storageFactories.SemVer2StorageFactory, contentBaseAddress == null ? null : new Uri(contentBaseAddress), TelemetryService, + Logger, CommandHelpers.GetHttpMessageHandlerFactory(TelemetryService, verbose)); var cursorStorage = storageFactories.LegacyStorageFactory.Create(); diff --git a/src/Ng/Jobs/Feed2CatalogJob.cs b/src/Ng/Jobs/Feed2CatalogJob.cs index d76a72be4..adfe0d759 100644 --- a/src/Ng/Jobs/Feed2CatalogJob.cs +++ b/src/Ng/Jobs/Feed2CatalogJob.cs @@ -134,7 +134,7 @@ protected override async Task RunInternalAsync(CancellationToken cancellationTok packagesEdited = 0; // baseline timestamps - var catalogProperties = await FeedHelpers.GetCatalogPropertiesAsync(CatalogStorage, TelemetryService, cancellationToken); + var catalogProperties = await CatalogProperties.ReadAsync(CatalogStorage, TelemetryService, cancellationToken); var lastCreated = catalogProperties.LastCreated ?? (StartDate ?? Constants.DateTimeMinValueUtc); var lastEdited = catalogProperties.LastEdited ?? lastCreated; var lastDeleted = catalogProperties.LastDeleted ?? lastCreated; diff --git a/src/Ng/Jobs/MonitoringProcessorJob.cs b/src/Ng/Jobs/MonitoringProcessorJob.cs index 815e62169..167b50dd1 100644 --- a/src/Ng/Jobs/MonitoringProcessorJob.cs +++ b/src/Ng/Jobs/MonitoringProcessorJob.cs @@ -129,15 +129,31 @@ private async Task HandleQueueMessageAsync( // We can remove the message from the queue because it was processed. messageWasProcessed = true; } - catch (Exception e) + catch (Exception validationFailedToRunException) { - // Validations failed to run! Save this failed status to storage. - await SaveFailedPackageMonitoringStatusAsync(queuedContext, e, token); - // We can then remove the message from the queue because this failed status can be used to requeue the message. - messageWasProcessed = true; + try + { + // Validations failed to run! Save this failed status to storage. + await SaveFailedPackageMonitoringStatusAsync(queuedContext, validationFailedToRunException, token); + // We can then remove the message from the queue because this failed status can be used to requeue the message. + messageWasProcessed = true; + } + catch (Exception failedValidationSaveFailureException) + { + // We failed to run validations and failed to save the failed validation! + // We were not able to process this message. We need to log the exceptions so we can debug the issue. + var aggregateException = new AggregateException( + "Validations failed to run and saving unsuccessful validation failed!", + new[] { validationFailedToRunException, failedValidationSaveFailureException }); + + Logger.LogCritical( + NuGet.Services.Metadata.Catalog.Monitoring.LogEvents.QueueMessageFatalFailure, + aggregateException, + "Failed to process queue message"); + } } - // Note that if both validations fail and saving the failure status fail, we cannot remove the message from the queue. + // If we failed to run validations and failed to save the failed validation, we cannot remove the message from the queue. if (messageWasProcessed) { await _queue.RemoveAsync(queueMessage, token); @@ -207,6 +223,7 @@ private async Task> FetchCatalogIndexEntriesFromR var catalogPageUri = new Uri(leafBlob["@id"].ToString()); var catalogPage = await _client.GetJObjectAsync(catalogPageUri, token); + return new CatalogIndexEntry[] { new CatalogIndexEntry( @@ -214,8 +231,7 @@ private async Task> FetchCatalogIndexEntriesFromR Schema.DataTypes.PackageDetails.ToString(), catalogPage["catalog:commitId"].ToString(), DateTime.Parse(catalogPage["catalog:commitTimeStamp"].ToString()), - id, - version) + new PackageIdentity(id, version)) }; } diff --git a/src/Ng/Jobs/NgJob.cs b/src/Ng/Jobs/NgJob.cs index 973c2069b..9d65c0a5d 100644 --- a/src/Ng/Jobs/NgJob.cs +++ b/src/Ng/Jobs/NgJob.cs @@ -17,7 +17,7 @@ public abstract class NgJob protected ILoggerFactory LoggerFactory; protected ILogger Logger; - protected int MaxDegreeOfParallelism { get; } + protected int MaxDegreeOfParallelism { get; set; } protected NgJob(ITelemetryService telemetryService, ILoggerFactory loggerFactory) { diff --git a/src/Ng/Jobs/Package2CatalogJob.cs b/src/Ng/Jobs/Package2CatalogJob.cs index 357099d05..561f8ad7f 100644 --- a/src/Ng/Jobs/Package2CatalogJob.cs +++ b/src/Ng/Jobs/Package2CatalogJob.cs @@ -91,7 +91,7 @@ protected override async Task RunInternalAsync(CancellationToken cancellationTok Logger.LogInformation($"Downloading {packages.Select(t => t.Value.Count).Sum()} packages"); // the idea here is to leave the lastCreated, lastEdited and lastDeleted values exactly as they were - var catalogProperties = await FeedHelpers.GetCatalogPropertiesAsync(_storage, TelemetryService, cancellationToken); + var catalogProperties = await CatalogProperties.ReadAsync(_storage, TelemetryService, cancellationToken); var lastCreated = catalogProperties.LastCreated ?? DateTime.MinValue.ToUniversalTime(); var lastEdited = catalogProperties.LastEdited ?? DateTime.MinValue.ToUniversalTime(); var lastDeleted = catalogProperties.LastDeleted ?? DateTime.MinValue.ToUniversalTime(); diff --git a/src/Ng/SearchIndexFromCatalogCollector.cs b/src/Ng/SearchIndexFromCatalogCollector.cs index 2fa33ff1c..e53477afd 100644 --- a/src/Ng/SearchIndexFromCatalogCollector.cs +++ b/src/Ng/SearchIndexFromCatalogCollector.cs @@ -40,8 +40,9 @@ public SearchIndexFromCatalogCollector( string baseAddress, ITelemetryService telemetryService, ILogger logger, - Func handlerFunc = null) - : base(index, telemetryService, handlerFunc) + Func handlerFunc = null, + IHttpRetryStrategy httpRetryStrategy = null) + : base(index, telemetryService, handlerFunc, httpRetryStrategy: httpRetryStrategy) { _indexWriter = indexWriter; _commitEachBatch = commitEachBatch; @@ -50,7 +51,13 @@ public SearchIndexFromCatalogCollector( _logger = logger; } - protected override async Task OnProcessBatchAsync(CollectorHttpClient client, IEnumerable items, JToken context, DateTime commitTimeStamp, bool isLastBatch, CancellationToken cancellationToken) + protected override async Task OnProcessBatchAsync( + CollectorHttpClient client, + IEnumerable items, + JToken context, + DateTime commitTimeStamp, + bool isLastBatch, + CancellationToken cancellationToken) { JObject catalogIndex = null; if (_baseAddress != null) @@ -152,16 +159,14 @@ private async Task CommitIndexAsync() private static async Task> FetchCatalogItemsAsync( CollectorHttpClient client, - IEnumerable items, + IEnumerable items, CancellationToken cancellationToken) { - IList> tasks = new List>(); + var tasks = new List>(); - foreach (JToken item in items) + foreach (var item in items) { - Uri catalogItemUri = item["@id"].ToObject(); - - tasks.Add(client.GetJObjectAsync(catalogItemUri, cancellationToken)); + tasks.Add(client.GetJObjectAsync(item.Uri, cancellationToken)); } await Task.WhenAll(tasks); diff --git a/src/NuGet.Protocol.Catalog/CatalogClient.cs b/src/NuGet.Protocol.Catalog/CatalogClient.cs new file mode 100644 index 000000000..b03686ed9 --- /dev/null +++ b/src/NuGet.Protocol.Catalog/CatalogClient.cs @@ -0,0 +1,113 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using System.IO; +using System.Net.Http; +using System.Threading.Tasks; +using Microsoft.Extensions.Logging; +using Newtonsoft.Json; + +namespace NuGet.Protocol.Catalog +{ + public class CatalogClient : ICatalogClient + { + private static readonly JsonSerializer JsonSerializer = CatalogJsonSerialization.Serializer; + private readonly HttpClient _httpClient; + private readonly ILogger _logger; + + public CatalogClient(HttpClient httpClient, ILogger logger) + { + _httpClient = httpClient ?? throw new ArgumentNullException(nameof(httpClient)); + _logger = logger ?? throw new ArgumentNullException(nameof(logger)); + } + + public Task GetIndexAsync(string indexUrl) + { + return DeserializeUrlAsync(indexUrl); + } + + public Task GetPageAsync(string pageUrl) + { + return DeserializeUrlAsync(pageUrl); + } + + public async Task GetLeafAsync(string leafUrl) + { + // Buffer all of the JSON so we can parse twice. Once to determine the leaf type and once to deserialize + // the entire thing to the proper leaf type. + _logger.LogDebug("Downloading {leafUrl} as a byte array.", leafUrl); + var jsonBytes = await _httpClient.GetByteArrayAsync(leafUrl); + var untypedLeaf = DeserializeBytes(jsonBytes); + + switch (untypedLeaf.Type) + { + case CatalogLeafType.PackageDetails: + return DeserializeBytes(jsonBytes); + case CatalogLeafType.PackageDelete: + return DeserializeBytes(jsonBytes); + default: + throw new NotSupportedException($"The catalog leaf type '{untypedLeaf.Type}' is not supported."); + } + } + + private async Task GetLeafAsync(CatalogLeafType type, string leafUrl) + { + switch (type) + { + case CatalogLeafType.PackageDetails: + return await GetPackageDetailsLeafAsync(leafUrl); + case CatalogLeafType.PackageDelete: + return await GetPackageDeleteLeafAsync(leafUrl); + default: + throw new NotSupportedException($"The catalog leaf type '{type}' is not supported."); + } + } + + public Task GetPackageDeleteLeafAsync(string leafUrl) + { + return GetAndValidateLeafAsync(CatalogLeafType.PackageDelete, leafUrl); + } + + public Task GetPackageDetailsLeafAsync(string leafUrl) + { + return GetAndValidateLeafAsync(CatalogLeafType.PackageDetails, leafUrl); + } + + private async Task GetAndValidateLeafAsync(CatalogLeafType type, string leafUrl) where T : CatalogLeaf + { + var leaf = await DeserializeUrlAsync(leafUrl); + + if (leaf.Type != type) + { + throw new ArgumentException( + $"The leaf type found in the document does not match the expected '{type}' type.", + nameof(type)); + } + + return leaf; + } + + private T DeserializeBytes(byte[] jsonBytes) + { + using (var stream = new MemoryStream(jsonBytes)) + using (var textReader = new StreamReader(stream)) + using (var jsonReader = new JsonTextReader(textReader)) + { + return JsonSerializer.Deserialize(jsonReader); + } + } + + private async Task DeserializeUrlAsync(string documentUrl) + { + _logger.LogDebug("Downloading {documentUrl} as a stream.", documentUrl); + + using (var stream = await _httpClient.GetStreamAsync(documentUrl)) + using (var textReader = new StreamReader(stream)) + using (var jsonReader = new JsonTextReader(textReader)) + { + return JsonSerializer.Deserialize(jsonReader); + } + } + } +} diff --git a/src/NuGet.Protocol.Catalog/CatalogProcessor.cs b/src/NuGet.Protocol.Catalog/CatalogProcessor.cs new file mode 100644 index 000000000..e798f969a --- /dev/null +++ b/src/NuGet.Protocol.Catalog/CatalogProcessor.cs @@ -0,0 +1,218 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using System.Threading.Tasks; +using Microsoft.Extensions.Logging; +using NuGet.Protocol.Core.Types; + +namespace NuGet.Protocol.Catalog +{ + public class CatalogProcessor + { + private const string CatalogResourceType = "Catalog/3.0.0"; + private readonly ICatalogLeafProcessor _leafProcessor; + private readonly ICatalogClient _client; + private readonly ICursor _cursor; + private readonly ILogger _logger; + private readonly CatalogProcessorSettings _settings; + + public CatalogProcessor( + ICursor cursor, + ICatalogClient client, + ICatalogLeafProcessor leafProcessor, + CatalogProcessorSettings settings, + ILogger logger) + { + _leafProcessor = leafProcessor ?? throw new ArgumentNullException(nameof(leafProcessor)); + _client = client ?? throw new ArgumentNullException(nameof(client)); + _cursor = cursor ?? throw new ArgumentNullException(nameof(cursor)); + _logger = logger ?? throw new ArgumentNullException(nameof(logger)); + + if (settings == null) + { + throw new ArgumentNullException(nameof(settings)); + } + + if (settings.ServiceIndexUrl == null) + { + throw new ArgumentException( + $"The {nameof(CatalogProcessorSettings.ServiceIndexUrl)} property of the " + + $"{nameof(CatalogProcessorSettings)} must not be null.", + nameof(settings)); + } + + // Clone the settings to avoid mutability issues. + _settings = settings.Clone(); + } + + /// + /// Discovers and downloads all of the catalog leafs after the current cursor value and before the maximum + /// commit timestamp found in the settings. Each catalog leaf is passed to the catalog leaf processor in + /// chronological order. After a commit is completed, its commit timestamp is written to the cursor, i.e. when + /// transitioning from commit timestamp A to B, A is written to the cursor so that it never is processed again. + /// + /// True if all of the catalog leaves found were processed successfully. + public async Task ProcessAsync() + { + var catalogIndexUrl = await GetCatalogIndexUrlAsync(); + + var minCommitTimestamp = await GetMinCommitTimestamp(); + _logger.LogInformation( + "Using time bounds {min:O} (exclusive) to {max:O} (inclusive).", + minCommitTimestamp, + _settings.MaxCommitTimestamp); + + return await ProcessIndexAsync(catalogIndexUrl, minCommitTimestamp); + } + + private async Task ProcessIndexAsync(string catalogIndexUrl, DateTimeOffset minCommitTimestamp) + { + var index = await _client.GetIndexAsync(catalogIndexUrl); + + var pageItems = index.GetPagesInBounds( + minCommitTimestamp, + _settings.MaxCommitTimestamp); + _logger.LogInformation( + "{pages} pages were in the time bounds, out of {totalPages}.", + pageItems.Count, + index.Items.Count); + + var success = true; + for (var i = 0; i < pageItems.Count; i++) + { + success = await ProcessPageAsync(minCommitTimestamp, pageItems[i]); + if (!success) + { + _logger.LogWarning( + "{unprocessedPages} out of {pages} pages were left incomplete due to a processing failure.", + pageItems.Count - i, + pageItems.Count); + break; + } + } + + return success; + } + + private async Task ProcessPageAsync(DateTimeOffset minCommitTimestamp, CatalogPageItem pageItem) + { + var page = await _client.GetPageAsync(pageItem.Url); + + var leafItems = page.GetLeavesInBounds( + minCommitTimestamp, + _settings.MaxCommitTimestamp, + _settings.ExcludeRedundantLeaves); + _logger.LogInformation( + "On page {page}, {leaves} out of {totalLeaves} were in the time bounds.", + pageItem.Url, + leafItems.Count, + page.Items.Count); + + DateTimeOffset? newCursor = null; + var success = true; + for (var i = 0; i < leafItems.Count; i++) + { + var leafItem = leafItems[i]; + + if (newCursor.HasValue && newCursor.Value != leafItem.CommitTimestamp) + { + await _cursor.SetAsync(newCursor.Value); + } + + newCursor = leafItem.CommitTimestamp; + + success = await ProcessLeafAsync(leafItem); + if (!success) + { + _logger.LogWarning( + "{unprocessedLeaves} out of {leaves} leaves were left incomplete due to a processing failure.", + leafItems.Count - i, + leafItems.Count); + break; + } + } + + if (newCursor.HasValue && success) + { + await _cursor.SetAsync(newCursor.Value); + } + + return success; + } + + private async Task ProcessLeafAsync(CatalogLeafItem leafItem) + { + bool success; + try + { + switch (leafItem.Type) + { + case CatalogLeafType.PackageDelete: + var packageDelete = await _client.GetPackageDeleteLeafAsync(leafItem.Url); + success = await _leafProcessor.ProcessPackageDeleteAsync(packageDelete); + break; + case CatalogLeafType.PackageDetails: + var packageDetails = await _client.GetPackageDetailsLeafAsync(leafItem.Url); + success = await _leafProcessor.ProcessPackageDetailsAsync(packageDetails); + break; + default: + throw new NotSupportedException($"The catalog leaf type '{leafItem.Type}' is not supported."); + } + } + catch (Exception exception) + { + _logger.LogError( + 0, + exception, + "An exception was thrown while processing leaf {leafUrl}.", + leafItem.Url); + success = false; + } + + if (!success) + { + _logger.LogWarning( + "Failed to process leaf {leafUrl} ({packageId} {packageVersion}, {leafType}).", + leafItem.Url, + leafItem.PackageId, + leafItem.PackageVersion, + leafItem.Type); + } + + return success; + } + + private async Task GetMinCommitTimestamp() + { + var minCommitTimestamp = await _cursor.GetAsync(); + + minCommitTimestamp = minCommitTimestamp + ?? _settings.DefaultMinCommitTimestamp + ?? _settings.MinCommitTimestamp; + + if (minCommitTimestamp.Value < _settings.MinCommitTimestamp) + { + minCommitTimestamp = _settings.MinCommitTimestamp; + } + + return minCommitTimestamp.Value; + } + + private async Task GetCatalogIndexUrlAsync() + { + _logger.LogInformation("Getting catalog index URL from {serviceIndexUrl}.", _settings.ServiceIndexUrl); + string catalogIndexUrl; + var sourceRepository = Repository.Factory.GetCoreV3(_settings.ServiceIndexUrl, FeedType.HttpV3); + var serviceIndexResource = await sourceRepository.GetResourceAsync(); + catalogIndexUrl = serviceIndexResource.GetServiceEntryUri(CatalogResourceType)?.AbsoluteUri; + if (catalogIndexUrl == null) + { + throw new InvalidOperationException( + $"The service index does not contain resource '{CatalogResourceType}'."); + } + + return catalogIndexUrl; + } + } +} diff --git a/src/NuGet.Protocol.Catalog/CatalogProcessorSettings.cs b/src/NuGet.Protocol.Catalog/CatalogProcessorSettings.cs new file mode 100644 index 000000000..7c61a1836 --- /dev/null +++ b/src/NuGet.Protocol.Catalog/CatalogProcessorSettings.cs @@ -0,0 +1,61 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; + +namespace NuGet.Protocol.Catalog +{ + /// + /// Settings for how should behave. Defaults to processing all catalog items on + /// . + /// + public class CatalogProcessorSettings + { + public CatalogProcessorSettings() + { + ServiceIndexUrl = "https://api.nuget.org/v3/index.json"; + DefaultMinCommitTimestamp = null; + MinCommitTimestamp = DateTimeOffset.MinValue; + MaxCommitTimestamp = DateTimeOffset.MaxValue; + ExcludeRedundantLeaves = true; + } + + internal CatalogProcessorSettings Clone() + { + return new CatalogProcessorSettings + { + ServiceIndexUrl = ServiceIndexUrl, + DefaultMinCommitTimestamp = DefaultMinCommitTimestamp, + MinCommitTimestamp = MinCommitTimestamp, + MaxCommitTimestamp = MaxCommitTimestamp, + ExcludeRedundantLeaves = ExcludeRedundantLeaves, + }; + } + + /// + /// The service index to discover the catalog index URL. + /// + public string ServiceIndexUrl { get; set; } + + /// + /// The minimum commit timestamp to use when no cursor value has been saved. + /// + public DateTimeOffset? DefaultMinCommitTimestamp { get; set; } + + /// + /// The absolute minimum (exclusive) commit timestamp to process in the catalog. + /// + public DateTimeOffset MinCommitTimestamp { get; set; } + + /// + /// The absolute maximum (inclusive) commit timestamp to process in the catalog. + /// + public DateTimeOffset MaxCommitTimestamp { get; set; } + + /// + /// If multiple catalog leaves are found in a page concerning the same package ID and version, only the latest + /// is processed. + /// + public bool ExcludeRedundantLeaves { get; set; } + } +} diff --git a/src/NuGet.Protocol.Catalog/FileCursor.cs b/src/NuGet.Protocol.Catalog/FileCursor.cs new file mode 100644 index 000000000..75284fed7 --- /dev/null +++ b/src/NuGet.Protocol.Catalog/FileCursor.cs @@ -0,0 +1,58 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using System.IO; +using System.Threading.Tasks; +using Microsoft.Extensions.Logging; +using Newtonsoft.Json; + +namespace NuGet.Protocol.Catalog +{ + /// + /// A cursor implementation which stores the cursor in local file. The cursor value is written to the file as + /// a JSON object. + /// + public class FileCursor : ICursor + { + private static readonly JsonSerializerSettings Settings = CatalogJsonSerialization.Settings; + private readonly string _path; + private readonly ILogger _logger; + + public FileCursor(string path, ILogger logger) + { + _path = path ?? throw new ArgumentNullException(nameof(path)); + _logger = logger ?? throw new ArgumentNullException(nameof(logger)); + } + + public Task GetAsync() + { + try + { + var jsonString = File.ReadAllText(_path); + var data = JsonConvert.DeserializeObject(jsonString, Settings); + _logger.LogDebug("Read cursor value {cursor:O} from {path}.", data.Value, _path); + return Task.FromResult(data.Value); + } + catch (Exception e) when (e is FileNotFoundException || e is JsonException) + { + return Task.FromResult(null); + } + } + + public Task SetAsync(DateTimeOffset value) + { + var data = new Data { Value = value }; + var jsonString = JsonConvert.SerializeObject(data); + File.WriteAllText(_path, jsonString); + _logger.LogDebug("Wrote cursor value {cursor:O} to {path}.", data.Value, _path); + return Task.CompletedTask; + } + + private class Data + { + [JsonProperty("value")] + public DateTimeOffset Value { get; set; } + } + } +} diff --git a/src/NuGet.Protocol.Catalog/ICatalogClient.cs b/src/NuGet.Protocol.Catalog/ICatalogClient.cs new file mode 100644 index 000000000..4ecbee386 --- /dev/null +++ b/src/NuGet.Protocol.Catalog/ICatalogClient.cs @@ -0,0 +1,54 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System.Threading.Tasks; + +namespace NuGet.Protocol.Catalog +{ + public interface ICatalogClient + { + /// + /// Get the catalog index at the provided URL. The catalog index URL should be discovered from the + /// service index. + /// + /// The catalog index URL. + /// The catalog index. + Task GetIndexAsync(string indexUrl); + + /// + /// Get the catalog page at the provided URL. The catalog page URL should be discovered from the catalog + /// index. + /// + /// The catalog page URL. + /// The catalog page. + Task GetPageAsync(string pageUrl); + + /// + /// Gets the catalog leaf at the provided URL. The catalog leaf URL should be discovered from a catalog page. + /// The type of the catalog leaf is automatically determined from the fetched document. + /// + /// The catalog leaf URL. + /// The catalog leaf. + Task GetLeafAsync(string leafUrl); + + /// + /// Gets the catalog leaf at the provided URL. The catalog leaf URL should be discovered from a catalog page. + /// The type of the catalog leaf must be a package delete. If the actual document is not a package delete, an + /// exception is thrown. + /// + /// The catalog leaf URL. + /// Thrown if the actual document is not a package delete. + /// The catalog leaf. + Task GetPackageDeleteLeafAsync(string leafUrl); + + /// + /// Gets the catalog leaf at the provided URL. The catalog leaf URL should be discovered from a catalog page. + /// The type of the catalog leaf must be package details. If the actual document is not package details, an + /// exception is thrown. + /// + /// The catalog leaf URL. + /// Thrown if the actual document is not package details. + /// The catalog leaf. + Task GetPackageDetailsLeafAsync(string leafUrl); + } +} \ No newline at end of file diff --git a/src/NuGet.Protocol.Catalog/ICatalogLeafProcessor.cs b/src/NuGet.Protocol.Catalog/ICatalogLeafProcessor.cs new file mode 100644 index 000000000..74b1f9733 --- /dev/null +++ b/src/NuGet.Protocol.Catalog/ICatalogLeafProcessor.cs @@ -0,0 +1,36 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System.Threading.Tasks; + +namespace NuGet.Protocol.Catalog +{ + /// + /// An interface which allows custom processing of catalog leaves. This interface should be implemented when the + /// catalog leaf documents need to be downloaded and processed in chronological order. + /// + public interface ICatalogLeafProcessor + { + /// + /// Process a catalog leaf containing package details. This method should return false or throw an exception + /// if the catalog leaf cannot be processed. In this case, the will stop + /// processing items. Note that the same package ID/version combination can be passed to this multiple times, + /// for example due to an edit in the package metadata or due to a transient error and retry on the part of the + /// . + /// + /// The leaf document. + /// True, if the leaf was successfully processed. False, otherwise. + Task ProcessPackageDetailsAsync(PackageDetailsCatalogLeaf leaf); + + /// + /// Process a catalog leaf containing a package delete. This method should return false or throw an exception + /// if the catalog leaf cannot be processed. In this case, the will stop + /// processing items. Note that the same package ID/version combination can be passed to this multiple times, + /// for example due to a package being deleted again due to a transient error and retry on the part of the + /// . + /// + /// The leaf document. + /// True, if the leaf was successfully processed. False, otherwise. + Task ProcessPackageDeleteAsync(PackageDeleteCatalogLeaf leaf); + } +} diff --git a/src/NuGet.Protocol.Catalog/ICursor.cs b/src/NuGet.Protocol.Catalog/ICursor.cs new file mode 100644 index 000000000..241699b52 --- /dev/null +++ b/src/NuGet.Protocol.Catalog/ICursor.cs @@ -0,0 +1,27 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using System.Threading.Tasks; + +namespace NuGet.Protocol.Catalog +{ + /// + /// An interface which allows reading and writing a cursor value. The value is up to what point in the catalog + /// has been successfully processed. The value is a catalog commit timestamp. + /// + public interface ICursor + { + /// + /// Get the value of the cursor. + /// + /// The cursor value. Null if the cursor has no value yet. + Task GetAsync(); + + /// + /// Set the value of the cursor. + /// + /// The new cursor value. + Task SetAsync(DateTimeOffset value); + } +} diff --git a/src/NuGet.Protocol.Catalog/Models/CatalogIndex.cs b/src/NuGet.Protocol.Catalog/Models/CatalogIndex.cs new file mode 100644 index 000000000..eb69b380a --- /dev/null +++ b/src/NuGet.Protocol.Catalog/Models/CatalogIndex.cs @@ -0,0 +1,21 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using System.Collections.Generic; +using Newtonsoft.Json; + +namespace NuGet.Protocol.Catalog +{ + public class CatalogIndex + { + [JsonProperty("commitTimeStamp")] + public DateTimeOffset CommitTimestamp { get; set; } + + [JsonProperty("count")] + public int Count { get; set; } + + [JsonProperty("items")] + public List Items { get; set; } + } +} diff --git a/src/NuGet.Protocol.Catalog/Models/CatalogLeaf.cs b/src/NuGet.Protocol.Catalog/Models/CatalogLeaf.cs new file mode 100644 index 000000000..e85ed4c34 --- /dev/null +++ b/src/NuGet.Protocol.Catalog/Models/CatalogLeaf.cs @@ -0,0 +1,27 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using Newtonsoft.Json; + +namespace NuGet.Protocol.Catalog +{ + public class CatalogLeaf : ICatalogLeafItem + { + [JsonProperty("@type")] + [JsonConverter(typeof(CatalogLeafTypeConverter))] + public CatalogLeafType Type { get; set; } + + [JsonProperty("catalog:commitTimeStamp")] + public DateTimeOffset CommitTimestamp { get; set; } + + [JsonProperty("id")] + public string PackageId { get; set; } + + [JsonProperty("published")] + public DateTimeOffset Published { get; set; } + + [JsonProperty("version")] + public string PackageVersion { get; set; } + } +} diff --git a/src/NuGet.Protocol.Catalog/Models/CatalogLeafItem.cs b/src/NuGet.Protocol.Catalog/Models/CatalogLeafItem.cs new file mode 100644 index 000000000..1d6e42ca1 --- /dev/null +++ b/src/NuGet.Protocol.Catalog/Models/CatalogLeafItem.cs @@ -0,0 +1,27 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using Newtonsoft.Json; + +namespace NuGet.Protocol.Catalog +{ + public class CatalogLeafItem : ICatalogLeafItem + { + [JsonProperty("@id")] + public string Url { get; set; } + + [JsonProperty("@type")] + [JsonConverter(typeof(CatalogLeafItemTypeConverter))] + public CatalogLeafType Type { get; set; } + + [JsonProperty("commitTimeStamp")] + public DateTimeOffset CommitTimestamp { get; set; } + + [JsonProperty("nuget:id")] + public string PackageId { get; set; } + + [JsonProperty("nuget:version")] + public string PackageVersion { get; set; } + } +} diff --git a/src/NuGet.Protocol.Catalog/Models/CatalogLeafType.cs b/src/NuGet.Protocol.Catalog/Models/CatalogLeafType.cs new file mode 100644 index 000000000..d23ef3d20 --- /dev/null +++ b/src/NuGet.Protocol.Catalog/Models/CatalogLeafType.cs @@ -0,0 +1,12 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +namespace NuGet.Protocol.Catalog +{ + public enum CatalogLeafType + { + PackageDetails = 1, + + PackageDelete = 2, + } +} diff --git a/src/NuGet.Protocol.Catalog/Models/CatalogPage.cs b/src/NuGet.Protocol.Catalog/Models/CatalogPage.cs new file mode 100644 index 000000000..ab7538238 --- /dev/null +++ b/src/NuGet.Protocol.Catalog/Models/CatalogPage.cs @@ -0,0 +1,24 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using System.Collections.Generic; +using Newtonsoft.Json; + +namespace NuGet.Protocol.Catalog +{ + public class CatalogPage + { + [JsonProperty("commitTimeStamp")] + public DateTimeOffset CommitTimestamp { get; set; } + + [JsonProperty("count")] + public int Count { get; set; } + + [JsonProperty("items")] + public List Items { get; set; } + + [JsonProperty("parent")] + public string Parent { get; set; } + } +} diff --git a/src/NuGet.Protocol.Catalog/Models/CatalogPageItem.cs b/src/NuGet.Protocol.Catalog/Models/CatalogPageItem.cs new file mode 100644 index 000000000..4677d5682 --- /dev/null +++ b/src/NuGet.Protocol.Catalog/Models/CatalogPageItem.cs @@ -0,0 +1,20 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using Newtonsoft.Json; + +namespace NuGet.Protocol.Catalog +{ + public class CatalogPageItem + { + [JsonProperty("@id")] + public string Url { get; set; } + + [JsonProperty("commitTimeStamp")] + public DateTimeOffset CommitTimestamp { get; set; } + + [JsonProperty("count")] + public int Count { get; set; } + } +} diff --git a/src/NuGet.Protocol.Catalog/Models/ICatalogLeafItem.cs b/src/NuGet.Protocol.Catalog/Models/ICatalogLeafItem.cs new file mode 100644 index 000000000..6b80064cf --- /dev/null +++ b/src/NuGet.Protocol.Catalog/Models/ICatalogLeafItem.cs @@ -0,0 +1,15 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; + +namespace NuGet.Protocol.Catalog +{ + public interface ICatalogLeafItem + { + DateTimeOffset CommitTimestamp { get; } + string PackageId { get; } + string PackageVersion { get; } + CatalogLeafType Type { get; } + } +} \ No newline at end of file diff --git a/src/NuGet.Protocol.Catalog/Models/ModelExtensions.cs b/src/NuGet.Protocol.Catalog/Models/ModelExtensions.cs new file mode 100644 index 000000000..86a57a919 --- /dev/null +++ b/src/NuGet.Protocol.Catalog/Models/ModelExtensions.cs @@ -0,0 +1,170 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using System.Collections.Generic; +using System.Linq; +using NuGet.Frameworks; +using NuGet.Packaging.Core; +using NuGet.Versioning; + +namespace NuGet.Protocol.Catalog +{ + /// + /// These are documented interpretations of values returned by the catalog API. + /// + public static class ModelExtensions + { + /// + /// Gets the leaves that lie within the provided commit timestamp bounds. The result is sorted by commit + /// timestamp, then package ID, then package version (SemVer order). + /// + /// + /// The exclusive lower time bound on . + /// The inclusive upper time bound on . + /// Only show the latest leaf concerning each package. + public static List GetLeavesInBounds( + this CatalogPage catalogPage, + DateTimeOffset minCommitTimestamp, + DateTimeOffset maxCommitTimestamp, + bool excludeRedundantLeaves) + { + var leaves = catalogPage + .Items + .Where(x => x.CommitTimestamp > minCommitTimestamp && x.CommitTimestamp <= maxCommitTimestamp) + .OrderBy(x => x.CommitTimestamp); + + if (excludeRedundantLeaves) + { + leaves = leaves + .GroupBy(x => new PackageIdentity(x.PackageId, x.ParsePackageVersion())) + .Select(x => x.Last()) + .OrderBy(x => x.CommitTimestamp); + } + + return leaves + .ThenBy(x => x.PackageId, StringComparer.OrdinalIgnoreCase) + .ThenBy(x => x.ParsePackageVersion()) + .ToList(); + } + + /// + /// Gets the pages that may have catalog leaves within the provided commit timestamp bounds. The result is + /// sorted by commit timestamp. + /// + /// The catalog index to fetch pages from. + /// The exclusive lower time bound on . + /// The inclusive upper time bound on . + public static List GetPagesInBounds( + this CatalogIndex catalogIndex, + DateTimeOffset minCommitTimestamp, + DateTimeOffset maxCommitTimestamp) + { + return catalogIndex + .GetPagesInBoundsLazy(minCommitTimestamp, maxCommitTimestamp) + .ToList(); + } + + private static IEnumerable GetPagesInBoundsLazy( + this CatalogIndex catalogIndex, + DateTimeOffset minCommitTimestamp, + DateTimeOffset maxCommitTimestamp) + { + // Filter out pages that fall entirely before the minimum commit timestamp and sort the remaining pages by + // commit timestamp. + var upperRange = catalogIndex + .Items + .Where(x => x.CommitTimestamp > minCommitTimestamp) + .OrderBy(x => x.CommitTimestamp); + + // Take pages from the sorted list until the commit timestamp goes past the maximum commit timestamp. This + // essentially LINQ's TakeWhile plus one more element. + foreach (var page in upperRange) + { + yield return page; + + if (page.CommitTimestamp > maxCommitTimestamp) + { + break; + } + } + } + + /// + /// Parse the package version as a . + /// + /// The catalog leaf. + /// The package version. + public static NuGetVersion ParsePackageVersion(this ICatalogLeafItem leaf) + { + return NuGetVersion.Parse(leaf.PackageVersion); + } + + /// + /// Parse the target framework as a . + /// + /// The package dependency group. + /// The framework. + public static NuGetFramework ParseTargetFramework(this PackageDependencyGroup packageDependencyGroup) + { + if (string.IsNullOrEmpty(packageDependencyGroup.TargetFramework)) + { + return NuGetFramework.AnyFramework; + } + + return NuGetFramework.Parse(packageDependencyGroup.TargetFramework); + } + + /// + /// Parse the version range as a . + /// + /// The package dependency. + /// The version range. + public static VersionRange ParseRange(this PackageDependency packageDependency) + { + if (string.IsNullOrEmpty(packageDependency.Range)) + { + return VersionRange.All; + } + + return VersionRange.Parse(packageDependency.Range); + } + + /// + /// Determines if the provided catalog leaf is a package delete. + /// + /// The catalog leaf. + /// True if the catalog leaf represents a package delete. + public static bool IsPackageDelete(this ICatalogLeafItem leaf) + { + return leaf.Type == CatalogLeafType.PackageDelete; + } + + /// + /// Determines if the provided catalog leaf is contains package details. + /// + /// The catalog leaf. + /// True if the catalog leaf contains package details. + public static bool IsPackageDetails(this ICatalogLeafItem leaf) + { + return leaf.Type == CatalogLeafType.PackageDetails; + } + + /// + /// Determines if the provided package details list represents a listed package. + /// + /// The catalog leaf. + /// True if the package is listed. + public static bool IsListed(this PackageDetailsCatalogLeaf leaf) + { + if (leaf.Listed.HasValue) + { + return leaf.Listed.Value; + } + + // A published year of 1900 indicates that this package is unlisted, when the listed property itself is + // not present (legacy behavior). + return leaf.Published.Year != 1900; + } + } +} diff --git a/src/NuGet.Protocol.Catalog/Models/PackageDeleteCatalogLeaf.cs b/src/NuGet.Protocol.Catalog/Models/PackageDeleteCatalogLeaf.cs new file mode 100644 index 000000000..de8c1fae8 --- /dev/null +++ b/src/NuGet.Protocol.Catalog/Models/PackageDeleteCatalogLeaf.cs @@ -0,0 +1,9 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +namespace NuGet.Protocol.Catalog +{ + public class PackageDeleteCatalogLeaf : CatalogLeaf + { + } +} diff --git a/src/NuGet.Protocol.Catalog/Models/PackageDependency.cs b/src/NuGet.Protocol.Catalog/Models/PackageDependency.cs new file mode 100644 index 000000000..d2f91698a --- /dev/null +++ b/src/NuGet.Protocol.Catalog/Models/PackageDependency.cs @@ -0,0 +1,16 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using Newtonsoft.Json; + +namespace NuGet.Protocol.Catalog +{ + public class PackageDependency + { + [JsonProperty("id")] + public string Id { get; set; } + + [JsonProperty("range")] + public string Range { get; set; } + } +} diff --git a/src/NuGet.Protocol.Catalog/Models/PackageDependencyGroup.cs b/src/NuGet.Protocol.Catalog/Models/PackageDependencyGroup.cs new file mode 100644 index 000000000..da4608de5 --- /dev/null +++ b/src/NuGet.Protocol.Catalog/Models/PackageDependencyGroup.cs @@ -0,0 +1,17 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System.Collections.Generic; +using Newtonsoft.Json; + +namespace NuGet.Protocol.Catalog +{ + public class PackageDependencyGroup + { + [JsonProperty("targetFramework")] + public string TargetFramework { get; set; } + + [JsonProperty("dependencies")] + public List Dependencies { get; set; } + } +} diff --git a/src/NuGet.Protocol.Catalog/Models/PackageDetailsCatalogLeaf.cs b/src/NuGet.Protocol.Catalog/Models/PackageDetailsCatalogLeaf.cs new file mode 100644 index 000000000..284fe004d --- /dev/null +++ b/src/NuGet.Protocol.Catalog/Models/PackageDetailsCatalogLeaf.cs @@ -0,0 +1,75 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using System.Collections.Generic; +using Newtonsoft.Json; + +namespace NuGet.Protocol.Catalog +{ + public class PackageDetailsCatalogLeaf : CatalogLeaf + { + [JsonProperty("authors")] + public string Authors { get; set; } + + [JsonProperty("created")] + public DateTimeOffset Created { get; set; } + + [JsonProperty("lastEdited")] + public DateTimeOffset LastEdited { get; set; } + + [JsonProperty("dependencyGroups")] + public List DependencyGroups { get; set; } + + [JsonProperty("description")] + public string Description { get; set; } + + [JsonProperty("iconUrl")] + public string IconUrl { get; set; } + + [JsonProperty("isPrerelease")] + public bool IsPrerelease { get; set; } + + [JsonProperty("language")] + public string Language { get; set; } + + [JsonProperty("licenseUrl")] + public string LicenseUrl { get; set; } + + [JsonProperty("listed")] + public bool? Listed { get; set; } + + [JsonProperty("minClientVersion")] + public string MinClientVersion { get; set; } + + [JsonProperty("packageHash")] + public string PackageHash { get; set; } + + [JsonProperty("packageHashAlgorithm")] + public string PackageHashAlgorithm { get; set; } + + [JsonProperty("packageSize")] + public long PackageSize { get; set; } + + [JsonProperty("projectUrl")] + public string ProjectUrl { get; set; } + + [JsonProperty("releaseNotes")] + public string ReleaseNotes { get; set; } + + [JsonProperty("requireLicenseAgreement")] + public bool? RequireLicenseAgreement { get; set; } + + [JsonProperty("summary")] + public string Summary { get; set; } + + [JsonProperty("tags")] + public List Tags { get; set; } + + [JsonProperty("title")] + public string Title { get; set; } + + [JsonProperty("verbatimVersion")] + public string VerbatimVersion { get; set; } + } +} diff --git a/src/NuGet.Protocol.Catalog/NuGet.Protocol.Catalog.csproj b/src/NuGet.Protocol.Catalog/NuGet.Protocol.Catalog.csproj new file mode 100644 index 000000000..ece75944d --- /dev/null +++ b/src/NuGet.Protocol.Catalog/NuGet.Protocol.Catalog.csproj @@ -0,0 +1,103 @@ + + + + + Debug + AnyCPU + {D44C2E89-2D98-44BD-8712-8CCBE4E67C9C} + Library + Properties + NuGet.Protocol.Catalog + NuGet.Protocol.Catalog + v4.6.2 + 512 + true + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + NuGet.Protocol.Catalog + A .NET library for consuming the NuGet API's catalog resource. + .NET Foundation + https://github.com/NuGet/NuGet.Services.Metadata/blob/master/LICENSE + https://github.com/NuGet/NuGet.Services.Metadata + git + https://github.com/NuGet/NuGet.Services.Metadata + + + + + + + 0.3.0 + runtime; build; native; contentfiles; analyzers + all + + + 1.0.0 + + + 9.0.1 + + + 4.8.0 + runtime; build; native; contentfiles; analyzers + all + + + 4.8.0 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ..\..\build + $(BUILD_SOURCESDIRECTORY)\build + $(NuGetBuildPath) + none + + + + + \ No newline at end of file diff --git a/src/NuGet.Protocol.Catalog/Properties/AssemblyInfo.cs b/src/NuGet.Protocol.Catalog/Properties/AssemblyInfo.cs new file mode 100644 index 000000000..ace49ddfa --- /dev/null +++ b/src/NuGet.Protocol.Catalog/Properties/AssemblyInfo.cs @@ -0,0 +1,16 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +[assembly: AssemblyTitle("NuGet.Protocol.Catalog")] +[assembly: ComVisible(false)] +[assembly: Guid("d44c2e89-2d98-44bd-8712-8ccbe4e67c9c")] + +#if SIGNED_BUILD +[assembly: InternalsVisibleTo("NuGet.Protocol.Catalog.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100b5fc90e7027f67871e773a8fde8938c81dd402ba65b9201d60593e96c492651e889cc13f1415ebb53fac1131ae0bd333c5ee6021672d9718ea31a8aebd0da0072f25d87dba6fc90ffd598ed4da35e44c398c454307e8e33b8426143daec9f596836f97c8f74750e5975c64e2189f45def46b2a2b1247adc3652bf5c308055da9")] +#else +[assembly: InternalsVisibleTo("NuGet.Protocol.Catalog.Tests")] +#endif diff --git a/src/NuGet.Protocol.Catalog/Serialization/BaseCatalogLeafConverter.cs b/src/NuGet.Protocol.Catalog/Serialization/BaseCatalogLeafConverter.cs new file mode 100644 index 000000000..fa0fa8835 --- /dev/null +++ b/src/NuGet.Protocol.Catalog/Serialization/BaseCatalogLeafConverter.cs @@ -0,0 +1,35 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using System.Collections.Generic; +using Newtonsoft.Json; + +namespace NuGet.Protocol.Catalog +{ + internal abstract class BaseCatalogLeafConverter : JsonConverter + { + private readonly IReadOnlyDictionary _fromType; + + public BaseCatalogLeafConverter(IReadOnlyDictionary fromType) + { + _fromType = fromType; + } + + public override bool CanConvert(Type objectType) + { + return objectType == typeof(CatalogLeafType); + } + + public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer) + { + string output; + if (_fromType.TryGetValue((CatalogLeafType)value, out output)) + { + writer.WriteValue(output); + } + + throw new NotSupportedException($"The catalog leaf type '{value}' is not supported."); + } + } +} diff --git a/src/NuGet.Protocol.Catalog/Serialization/CatalogJsonSerialization.cs b/src/NuGet.Protocol.Catalog/Serialization/CatalogJsonSerialization.cs new file mode 100644 index 000000000..6cd1f14a5 --- /dev/null +++ b/src/NuGet.Protocol.Catalog/Serialization/CatalogJsonSerialization.cs @@ -0,0 +1,19 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using Newtonsoft.Json; + +namespace NuGet.Protocol.Catalog +{ + internal static class CatalogJsonSerialization + { + public static JsonSerializer Serializer => JsonSerializer.Create(Settings); + + public static JsonSerializerSettings Settings => new JsonSerializerSettings + { + DateTimeZoneHandling = DateTimeZoneHandling.Utc, + DateParseHandling = DateParseHandling.DateTimeOffset, + NullValueHandling = NullValueHandling.Ignore, + }; + } +} diff --git a/src/NuGet.Protocol.Catalog/Serialization/CatalogLeafItemTypeConverter.cs b/src/NuGet.Protocol.Catalog/Serialization/CatalogLeafItemTypeConverter.cs new file mode 100644 index 000000000..85dac704c --- /dev/null +++ b/src/NuGet.Protocol.Catalog/Serialization/CatalogLeafItemTypeConverter.cs @@ -0,0 +1,41 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using System.Collections.Generic; +using System.Linq; +using Newtonsoft.Json; + +namespace NuGet.Protocol.Catalog +{ + internal class CatalogLeafItemTypeConverter : BaseCatalogLeafConverter + { + private static readonly Dictionary FromType = new Dictionary + { + { CatalogLeafType.PackageDelete, "nuget:PackageDelete" }, + { CatalogLeafType.PackageDetails, "nuget:PackageDetails" }, + }; + + private static readonly Dictionary FromString = FromType + .ToDictionary(x => x.Value, x => x.Key); + + public CatalogLeafItemTypeConverter() : base(FromType) + { + } + + public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) + { + string stringValue = reader.Value as string; + if (stringValue != null) + { + CatalogLeafType output; + if (FromString.TryGetValue(stringValue, out output)) + { + return output; + } + } + + throw new JsonSerializationException($"Unexpected value for a {nameof(CatalogLeafType)}."); + } + } +} diff --git a/src/NuGet.Protocol.Catalog/Serialization/CatalogLeafTypeConverter.cs b/src/NuGet.Protocol.Catalog/Serialization/CatalogLeafTypeConverter.cs new file mode 100644 index 000000000..d8bbc576d --- /dev/null +++ b/src/NuGet.Protocol.Catalog/Serialization/CatalogLeafTypeConverter.cs @@ -0,0 +1,50 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using System.Collections.Generic; +using System.Linq; +using Newtonsoft.Json; + +namespace NuGet.Protocol.Catalog +{ + internal class CatalogLeafTypeConverter : BaseCatalogLeafConverter + { + private static readonly Dictionary FromType = new Dictionary + { + { CatalogLeafType.PackageDelete, "PackageDelete" }, + { CatalogLeafType.PackageDetails, "PackageDetails" }, + }; + + private static readonly Dictionary FromString = FromType + .ToDictionary(x => x.Value, x => x.Key); + + public CatalogLeafTypeConverter() : base(FromType) + { + } + + public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) + { + List types; + if (reader.TokenType == JsonToken.StartArray) + { + types = serializer.Deserialize>(reader); + } + else + { + types = new List { reader.Value }; + } + + foreach (var type in types.OfType()) + { + CatalogLeafType output; + if (FromString.TryGetValue(type, out output)) + { + return output; + } + } + + throw new JsonSerializationException($"Unexpected value for a {nameof(CatalogLeafType)}."); + } + } +} diff --git a/src/NuGet.Services.Metadata.Catalog.Monitoring/Model/PackageTimestampMetadata.cs b/src/NuGet.Services.Metadata.Catalog.Monitoring/Model/PackageTimestampMetadata.cs index f1943d6f9..6601e182e 100644 --- a/src/NuGet.Services.Metadata.Catalog.Monitoring/Model/PackageTimestampMetadata.cs +++ b/src/NuGet.Services.Metadata.Catalog.Monitoring/Model/PackageTimestampMetadata.cs @@ -53,24 +53,25 @@ public static PackageTimestampMetadata CreateForPackageMissingFromFeed(DateTime? }; } - public static async Task FromCatalogEntry(CollectorHttpClient client, + public static async Task FromCatalogEntry( + CollectorHttpClient client, CatalogIndexEntry catalogEntry) { - var catalogPage = await client.GetJObjectAsync(catalogEntry.Uri); + var catalogLeaf = await client.GetJObjectAsync(catalogEntry.Uri); try { if (catalogEntry.IsDelete) { // On the catalog page for a delete, the published value is the timestamp the package was deleted from the audit records. - var deleted = catalogPage.GetValue("published").Value(); + var deleted = catalogLeaf.GetValue("published").Value(); return CreateForPackageMissingFromFeed(deleted.DateTime); } else { - var created = catalogPage.GetValue("created").Value(); - var lastEdited = catalogPage.GetValue("lastEdited").Value(); + var created = catalogLeaf.GetValue("created").Value(); + var lastEdited = catalogLeaf.GetValue("lastEdited").Value(); return CreateForPackageExistingOnFeed(created.DateTime, lastEdited.DateTime); } @@ -81,7 +82,8 @@ public static async Task FromCatalogEntry(CollectorHtt } } - public static async Task FromCatalogEntries(CollectorHttpClient client, + public static async Task FromCatalogEntries( + CollectorHttpClient client, IEnumerable catalogEntries) { var packageTimestampMetadatas = @@ -90,4 +92,4 @@ public static async Task FromCatalogEntries(CollectorH return packageTimestampMetadatas.FirstOrDefault(p => p.Last == maxTimestamp); } } -} +} \ No newline at end of file diff --git a/src/NuGet.Services.Metadata.Catalog.Monitoring/Utility/LogEvents.cs b/src/NuGet.Services.Metadata.Catalog.Monitoring/Utility/LogEvents.cs index 5a4428b29..6eff3340f 100644 --- a/src/NuGet.Services.Metadata.Catalog.Monitoring/Utility/LogEvents.cs +++ b/src/NuGet.Services.Metadata.Catalog.Monitoring/Utility/LogEvents.cs @@ -13,5 +13,7 @@ public static class LogEvents public static EventId StatusDeserializationFailure = new EventId(903, "Status deserialization failed!"); public static EventId StatusDeserializationFatalFailure = new EventId(904, "Status deserialization failed, and was unable to parse id and version from filename!"); + + public static EventId QueueMessageFatalFailure = new EventId(905, "Failed to process queue message"); } } diff --git a/src/NuGet.Services.Metadata.Catalog.Monitoring/ValidationCollector.cs b/src/NuGet.Services.Metadata.Catalog.Monitoring/ValidationCollector.cs index d34692e1d..d89471ef5 100644 --- a/src/NuGet.Services.Metadata.Catalog.Monitoring/ValidationCollector.cs +++ b/src/NuGet.Services.Metadata.Catalog.Monitoring/ValidationCollector.cs @@ -35,7 +35,11 @@ public ValidationCollector( _logger = logger; } - protected override async Task ProcessSortedBatchAsync(CollectorHttpClient client, KeyValuePair> sortedBatch, JToken context, CancellationToken cancellationToken) + protected override async Task ProcessSortedBatchAsync( + CollectorHttpClient client, + KeyValuePair> sortedBatch, + JToken context, + CancellationToken cancellationToken) { var packageId = sortedBatch.Key.Id; var packageVersion = sortedBatch.Key.Version; diff --git a/src/V3PerPackage/EnqueueCollector.cs b/src/V3PerPackage/EnqueueCollector.cs index c4a91f39e..3bf2178a2 100644 --- a/src/V3PerPackage/EnqueueCollector.cs +++ b/src/V3PerPackage/EnqueueCollector.cs @@ -11,7 +11,6 @@ using Microsoft.Extensions.Options; using Newtonsoft.Json.Linq; using NuGet.Services.Metadata.Catalog; -using NuGet.Services.Metadata.Catalog.Helpers; using NuGet.Services.Storage; namespace NuGet.Services.V3PerPackage @@ -32,24 +31,24 @@ public EnqueueCollector( _queue = queue ?? throw new ArgumentNullException(nameof(queue)); } - protected override Task> CreateBatchesAsync(IEnumerable catalogItems) + protected override Task> CreateBatchesAsync(IEnumerable catalogItems) { var catalogItemList = catalogItems.ToList(); var maxCommitTimestamp = catalogItems.Max(x => x.CommitTimeStamp); - return Task.FromResult(new[] { new CatalogItemBatch(maxCommitTimestamp, catalogItemList) }.AsEnumerable()); + return Task.FromResult(new[] { new CatalogCommitItemBatch(catalogItemList) }.AsEnumerable()); } protected override async Task OnProcessBatchAsync( CollectorHttpClient client, - IEnumerable items, + IEnumerable items, JToken context, DateTime commitTimeStamp, bool isLastBatch, CancellationToken cancellationToken) { - var itemBag = new ConcurrentBag(items); + var itemBag = new ConcurrentBag(items); var tasks = Enumerable .Range(0, 16) @@ -61,19 +60,18 @@ protected override async Task OnProcessBatchAsync( return true; } - private async Task EnqueueAsync(ConcurrentBag itemBag, CancellationToken cancellationToken) + private async Task EnqueueAsync(ConcurrentBag itemBag, CancellationToken cancellationToken) { while (itemBag.TryTake(out var item)) { - var id = item["nuget:id"].ToString().ToLowerInvariant(); - var version = NuGetVersionUtility.NormalizeVersion(item["nuget:version"].ToString().ToLowerInvariant()); - var type = item["@type"].ToString().Replace("nuget:", Schema.Prefixes.NuGet); - - if (type != Schema.DataTypes.PackageDetails.ToString()) + if (!item.TypeUris.Any(itemType => itemType.AbsoluteUri != Schema.DataTypes.PackageDetails.AbsoluteUri)) { continue; } + var id = item.PackageIdentity.Id.ToLowerInvariant(); + var version = item.PackageIdentity.Version.ToNormalizedString().ToLowerInvariant(); + await _queue.AddAsync(new PackageMessage(id, version), cancellationToken); } } diff --git a/src/V3PerPackage/PerBatchProcessor.cs b/src/V3PerPackage/PerBatchProcessor.cs index beac15a4c..215571c5c 100644 --- a/src/V3PerPackage/PerBatchProcessor.cs +++ b/src/V3PerPackage/PerBatchProcessor.cs @@ -255,6 +255,7 @@ private async Task ExecuteCatalog2RegistrationAsync(PerBatchContext context, Uri registrationStorageFactories.SemVer2StorageFactory, context.Global.ContentBaseAddress, serviceProvider.GetRequiredService(), + _logger, () => serviceProvider.GetRequiredService()); await collector.RunAsync(CancellationToken.None); diff --git a/test.ps1 b/test.ps1 index 1fddcc3d3..09d142ca3 100644 --- a/test.ps1 +++ b/test.ps1 @@ -29,7 +29,8 @@ Function Run-Tests { "tests\NuGet.IndexingTests\bin\$Configuration\NuGet.IndexingTests.dll", ` "tests\NuGet.Services.BasicSearchTests\bin\$Configuration\NuGet.Services.BasicSearchTests.dll", ` "tests\CatalogTests\bin\$Configuration\CatalogTests.dll", ` - "tests\CatalogMetadataTests\bin\$Configuration\CatalogMetadataTests.dll" + "tests\CatalogMetadataTests\bin\$Configuration\CatalogMetadataTests.dll", ` + "tests\NuGet.Protocol.Catalog.Tests\bin\$Configuration\NuGet.Protocol.Catalog.Tests.dll" $TestCount = 0 diff --git a/tests/CatalogTests/BatchProcessingExceptionTests.cs b/tests/CatalogTests/BatchProcessingExceptionTests.cs new file mode 100644 index 000000000..35b5a0133 --- /dev/null +++ b/tests/CatalogTests/BatchProcessingExceptionTests.cs @@ -0,0 +1,30 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using NuGet.Services.Metadata.Catalog; +using Xunit; + +namespace CatalogTests +{ + public class BatchProcessingExceptionTests + { + [Fact] + public void Constructor_WhenExceptionIsNull_Throws() + { + var exception = Assert.Throws(() => new BatchProcessingException(inner: null)); + + Assert.Equal("inner", exception.ParamName); + } + + [Fact] + public void Constructor_WhenArgumentIsValid_ReturnsInstance() + { + var innerException = new Exception(); + var exception = new BatchProcessingException(innerException); + + Assert.Equal("A failure occurred while processing a catalog batch.", exception.Message); + Assert.Same(innerException, exception.InnerException); + } + } +} \ No newline at end of file diff --git a/tests/CatalogTests/CatalogCommitBatchTaskTests.cs b/tests/CatalogTests/CatalogCommitBatchTaskTests.cs new file mode 100644 index 000000000..2abb8db23 --- /dev/null +++ b/tests/CatalogTests/CatalogCommitBatchTaskTests.cs @@ -0,0 +1,139 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using System.Threading.Tasks; +using NgTests.Infrastructure; +using NuGet.Packaging.Core; +using NuGet.Services.Metadata.Catalog; +using NuGet.Versioning; +using Xunit; + +namespace CatalogTests +{ + public class CatalogCommitBatchTaskTests + { + private readonly DateTime _minCommitTimeStamp = DateTime.UtcNow; + private static readonly PackageIdentity _packageIdentity = new PackageIdentity(id: "a", version: new NuGetVersion("1.0.0")); + private readonly CatalogCommitItemBatch _commitItemBatch; + private readonly CatalogCommitItemBatchTask _commitItemBatchTask; + + public CatalogCommitBatchTaskTests() + { + _commitItemBatch = CreateCatalogCommitItemBatch(_packageIdentity.Id); + _commitItemBatchTask = new CatalogCommitItemBatchTask(_commitItemBatch, Task.CompletedTask); + } + + [Fact] + public void Constructor_WhenBatchIsNull_Throws() + { + const CatalogCommitItemBatch batch = null; + + var exception = Assert.Throws( + () => new CatalogCommitItemBatchTask(batch, Task.CompletedTask)); + + Assert.Equal("batch", exception.ParamName); + } + + [Fact] + public void Constructor_WhenBatchKeyIsNull_Throws() + { + var commitItemBatch = CreateCatalogCommitItemBatch(key: null); + + var exception = Assert.Throws( + () => new CatalogCommitItemBatchTask(commitItemBatch, Task.CompletedTask)); + + Assert.Equal("batch.Key", exception.ParamName); + } + + [Fact] + public void Constructor_WhenTaskIsNull_Throws() + { + var exception = Assert.Throws( + () => new CatalogCommitItemBatchTask(_commitItemBatch, task: null)); + + Assert.Equal("task", exception.ParamName); + } + + [Fact] + public void Constructor_WhenArgumentIsValid_ReturnsInstance() + { + Assert.Same(_commitItemBatch, _commitItemBatchTask.Batch); + Assert.NotNull(_commitItemBatchTask.Task); + } + + [Fact] + public void GetHashCode_Always_ReturnsBatchKeyHashCode() + { + Assert.Equal(_commitItemBatch.Key.GetHashCode(), _commitItemBatchTask.GetHashCode()); + } + + [Fact] + public void Equals_WhenObjectIsNull_ReturnsFalse() + { + Assert.False(_commitItemBatchTask.Equals(obj: null)); + Assert.False(_commitItemBatchTask.Equals(other: null)); + } + + [Fact] + public void Equals_WhenObjectIsNotCatalogCommitBatchTask_ReturnsFalse() + { + Assert.False(_commitItemBatchTask.Equals(obj: new object())); + } + + [Fact] + public void Equals_WhenObjectIsSameInstance_ReturnsTrue() + { + Assert.True(_commitItemBatchTask.Equals(obj: _commitItemBatchTask)); + Assert.True(_commitItemBatchTask.Equals(other: _commitItemBatchTask)); + } + + [Fact] + public void Equals_WhenObjectBatchHasSameKey_ReturnsTrue() + { + var commitTimeStamp0 = DateTime.UtcNow; + var commitItem0 = TestUtility.CreateCatalogCommitItem(commitTimeStamp0, _packageIdentity); + var commitItemBatch0 = new CatalogCommitItemBatch(new[] { commitItem0 }, _packageIdentity.Id); + var commitItemBatchTask0 = new CatalogCommitItemBatchTask(commitItemBatch0, Task.CompletedTask); + var commitTimeStamp1 = commitTimeStamp0.AddMinutes(1); + var commitItem1 = TestUtility.CreateCatalogCommitItem(commitTimeStamp1, _packageIdentity); + var commitItemBatch1 = new CatalogCommitItemBatch(new[] { commitItem1 }, _packageIdentity.Id); + var commitItemBatchTask1 = new CatalogCommitItemBatchTask(commitItemBatch1, Task.CompletedTask); + + Assert.True(commitItemBatchTask0.Equals(obj: commitItemBatchTask1)); + Assert.True(commitItemBatchTask1.Equals(obj: commitItemBatchTask0)); + Assert.True(commitItemBatchTask0.Equals(other: commitItemBatchTask1)); + Assert.True(commitItemBatchTask1.Equals(other: commitItemBatchTask0)); + } + + [Fact] + public void Equals_WhenObjectBatchHasDifferentKey_ReturnsFalse() + { + var commitTimeStamp0 = DateTime.UtcNow; + var commitItem0 = TestUtility.CreateCatalogCommitItem( + commitTimeStamp0, + new PackageIdentity(id: "a", version: new NuGetVersion("1.0.0"))); + var commitItemBatch0 = new CatalogCommitItemBatch(new[] { commitItem0 }, key: "a"); + var commitItemBatchTask0 = new CatalogCommitItemBatchTask(commitItemBatch0, Task.CompletedTask); + var commitTimeStamp1 = commitTimeStamp0.AddMinutes(1); + var commitItem1 = TestUtility.CreateCatalogCommitItem( + commitTimeStamp1, + new PackageIdentity(id: "b", version: new NuGetVersion("1.0.0"))); + var commitItemBatch1 = new CatalogCommitItemBatch(new[] { commitItem1 }, key: "b"); + var commitItemBatchTask1 = new CatalogCommitItemBatchTask(commitItemBatch1, Task.CompletedTask); + + Assert.False(commitItemBatchTask0.Equals(obj: commitItemBatchTask1)); + Assert.False(commitItemBatchTask1.Equals(obj: commitItemBatchTask0)); + Assert.False(commitItemBatchTask0.Equals(other: commitItemBatchTask1)); + Assert.False(commitItemBatchTask1.Equals(other: commitItemBatchTask0)); + } + + private static CatalogCommitItemBatch CreateCatalogCommitItemBatch(string key) + { + var commitTimeStamp = DateTime.UtcNow; + var commitItem = TestUtility.CreateCatalogCommitItem(commitTimeStamp, _packageIdentity); + + return new CatalogCommitItemBatch(new[] { commitItem }, key); + } + } +} \ No newline at end of file diff --git a/tests/CatalogTests/CatalogCommitItemBatchTests.cs b/tests/CatalogTests/CatalogCommitItemBatchTests.cs new file mode 100644 index 000000000..fd63fedcb --- /dev/null +++ b/tests/CatalogTests/CatalogCommitItemBatchTests.cs @@ -0,0 +1,60 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using System.Linq; +using NgTests.Infrastructure; +using NuGet.Packaging.Core; +using NuGet.Services.Metadata.Catalog; +using NuGet.Versioning; +using Xunit; + +namespace CatalogTests +{ + public class CatalogCommitItemBatchTests + { + private static readonly PackageIdentity _packageIdentity = new PackageIdentity( + id: "a", + version: new NuGetVersion("1.0.0")); + + [Fact] + public void Constructor_WhenItemsIsNull_Throws() + { + var exception = Assert.Throws( + () => new CatalogCommitItemBatch(items: null)); + + Assert.Equal("items", exception.ParamName); + } + + [Fact] + public void Constructor_WhenItemsIsEmpty_Throws() + { + var exception = Assert.Throws( + () => new CatalogCommitItemBatch(Enumerable.Empty())); + + Assert.Equal("items", exception.ParamName); + } + + [Theory] + [InlineData(null)] + [InlineData("a")] + public void Constructor_WhenCommitsAreUnordered_OrdersCommitsInChronologicallyAscendingOrder(string key) + { + var commitTimeStamp = DateTime.UtcNow; + var commitItem0 = TestUtility.CreateCatalogCommitItem(commitTimeStamp, _packageIdentity); + var commitItem1 = TestUtility.CreateCatalogCommitItem(commitTimeStamp.AddMinutes(1), _packageIdentity); + var commitItem2 = TestUtility.CreateCatalogCommitItem(commitTimeStamp.AddMinutes(2), _packageIdentity); + + var commitItemBatch = new CatalogCommitItemBatch( + new[] { commitItem1, commitItem0, commitItem2 }, + key); + + Assert.Equal(commitTimeStamp, commitItemBatch.CommitTimeStamp.ToUniversalTime()); + Assert.Equal(3, commitItemBatch.Items.Count); + Assert.Equal(key, commitItemBatch.Key); + Assert.Same(commitItem0, commitItemBatch.Items[0]); + Assert.Same(commitItem1, commitItemBatch.Items[1]); + Assert.Same(commitItem2, commitItemBatch.Items[2]); + } + } +} \ No newline at end of file diff --git a/tests/CatalogTests/CatalogCommitItemTests.cs b/tests/CatalogTests/CatalogCommitItemTests.cs new file mode 100644 index 000000000..a2e41c96f --- /dev/null +++ b/tests/CatalogTests/CatalogCommitItemTests.cs @@ -0,0 +1,104 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using System.Linq; +using Newtonsoft.Json.Linq; +using NgTests; +using NgTests.Infrastructure; +using NuGet.Packaging.Core; +using NuGet.Services.Metadata.Catalog; +using NuGet.Versioning; +using Xunit; + +namespace CatalogTests +{ + public class CatalogCommitItemTests + { + private static readonly PackageIdentity _packageIdentity = new PackageIdentity(id: "A", version: new NuGetVersion("1.0.0")); + private readonly DateTime _now = DateTime.UtcNow; + private readonly JObject _context; + private readonly JObject _commitItem; + + public CatalogCommitItemTests() + { + _context = TestUtility.CreateCatalogContextJObject(); + _commitItem = TestUtility.CreateCatalogCommitItemJObject(_now, _packageIdentity); + } + + [Fact] + public void Create_WhenContextIsNull_Throws() + { + const JObject context = null; + + var exception = Assert.Throws(() => CatalogCommitItem.Create(context, _commitItem)); + + Assert.Equal("context", exception.ParamName); + } + + [Fact] + public void Create_WhenCommitItemIsNull_Throws() + { + var exception = Assert.Throws(() => CatalogCommitItem.Create(_context, commitItem: null)); + + Assert.Equal("commitItem", exception.ParamName); + } + + [Fact] + public void Create_WhenTypeIsEmpty_Throws() + { + _commitItem[CatalogConstants.TypeKeyword] = new JArray(); + + var exception = Assert.Throws(() => CatalogCommitItem.Create(_context, _commitItem)); + + Assert.Equal("commitItem", exception.ParamName); + Assert.StartsWith($"The value of property '{CatalogConstants.TypeKeyword}' must be non-null and non-empty.", exception.Message); + } + + [Fact] + public void Create_WhenArgumentsAreValid_ReturnsInstance() + { + var commitItem = CatalogCommitItem.Create(_context, _commitItem); + + Assert.Equal($"https://nuget.test/{_packageIdentity.Id}", commitItem.Uri.AbsoluteUri); + Assert.Equal(_now, commitItem.CommitTimeStamp.ToUniversalTime()); + Assert.True(Guid.TryParse(commitItem.CommitId, out var commitId)); + Assert.Equal(_packageIdentity, commitItem.PackageIdentity); + Assert.Equal(CatalogConstants.NuGetPackageDetails, commitItem.Types.Single()); + Assert.Equal(Schema.DataTypes.PackageDetails.AbsoluteUri, commitItem.TypeUris.Single().AbsoluteUri); + } + + [Fact] + public void CompareTo_WhenObjIsNull_Throws() + { + var commitItem = CatalogCommitItem.Create(_context, _commitItem); + + var exception = Assert.Throws(() => commitItem.CompareTo(obj: null)); + + Assert.Equal("obj", exception.ParamName); + } + + [Fact] + public void CompareTo_WhenObjIsNotCatalogCommit_Throws() + { + var commitItem = CatalogCommitItem.Create(_context, _commitItem); + + var exception = Assert.Throws(() => commitItem.CompareTo(new object())); + + Assert.Equal("obj", exception.ParamName); + } + + [Fact] + public void CompareTo_WhenArgumentIsValid_ReturnsValue() + { + var commitTimeStamp1 = DateTime.UtcNow; + var commitTimeStamp2 = DateTime.UtcNow.AddMinutes(1); + var commitItem0 = TestUtility.CreateCatalogCommitItem(commitTimeStamp1, _packageIdentity); + var commitItem1 = TestUtility.CreateCatalogCommitItem(commitTimeStamp2, _packageIdentity); + + Assert.Equal(0, commitItem0.CompareTo(commitItem0)); + Assert.Equal(-1, commitItem0.CompareTo(commitItem1)); + Assert.Equal(1, commitItem1.CompareTo(commitItem0)); + } + } +} \ No newline at end of file diff --git a/tests/CatalogTests/CatalogCommitTests.cs b/tests/CatalogTests/CatalogCommitTests.cs new file mode 100644 index 000000000..8b8439507 --- /dev/null +++ b/tests/CatalogTests/CatalogCommitTests.cs @@ -0,0 +1,85 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using Newtonsoft.Json.Linq; +using NgTests; +using NuGet.Services.Metadata.Catalog; +using Xunit; + +namespace CatalogTests +{ + public class CatalogCommitTests + { + [Fact] + public void Create_WhenCommitIsNull_Throws() + { + var exception = Assert.Throws(() => CatalogCommit.Create(commit: null)); + + Assert.Equal("commit", exception.ParamName); + } + + [Fact] + public void Create_WhenArgumentIsValid_ReturnsInstance() + { + var idKeyword = "https://nuget.test/a"; + var commitTimeStamp = DateTime.UtcNow.ToString("O"); + var jObject = new JObject( + new JProperty(CatalogConstants.IdKeyword, idKeyword), + new JProperty(CatalogConstants.CommitTimeStamp, commitTimeStamp)); + + var commit = CatalogCommit.Create(jObject); + + Assert.Equal(idKeyword, commit.Uri.AbsoluteUri); + Assert.Equal(commitTimeStamp, commit.CommitTimeStamp.ToUniversalTime().ToString("O")); + } + + [Fact] + public void CompareTo_WhenObjIsNull_Throws() + { + var commit = CreateCatalogCommit(); + + var exception = Assert.Throws(() => commit.CompareTo(obj: null)); + + Assert.Equal("obj", exception.ParamName); + } + + [Fact] + public void CompareTo_WhenObjIsNotCatalogCommit_Throws() + { + var commit = CreateCatalogCommit(); + + var exception = Assert.Throws(() => commit.CompareTo(new object())); + + Assert.Equal("obj", exception.ParamName); + } + + [Fact] + public void CompareTo_WhenObjIsCatalogCommit_ReturnsValue() + { + var jObject0 = new JObject( + new JProperty(CatalogConstants.IdKeyword, "https://nuget.test/a"), + new JProperty(CatalogConstants.CommitTimeStamp, DateTime.UtcNow.ToString("O"))); + + var jObject1 = new JObject( + new JProperty(CatalogConstants.IdKeyword, "https://nuget.test/b"), + new JProperty(CatalogConstants.CommitTimeStamp, DateTime.UtcNow.AddHours(1).ToString("O"))); + + var commit0 = CatalogCommit.Create(jObject0); + var commit1 = CatalogCommit.Create(jObject1); + + Assert.Equal(-1, commit0.CompareTo(commit1)); + Assert.Equal(0, commit0.CompareTo(commit0)); + Assert.Equal(1, commit1.CompareTo(commit0)); + } + + private static CatalogCommit CreateCatalogCommit() + { + var jObject = new JObject( + new JProperty(CatalogConstants.IdKeyword, "https://nuget.test/a"), + new JProperty(CatalogConstants.CommitTimeStamp, DateTime.UtcNow.ToString("O"))); + + return CatalogCommit.Create(jObject); + } + } +} \ No newline at end of file diff --git a/tests/CatalogTests/CatalogCommitUtilitiesTests.cs b/tests/CatalogTests/CatalogCommitUtilitiesTests.cs new file mode 100644 index 000000000..8d9dfb4f7 --- /dev/null +++ b/tests/CatalogTests/CatalogCommitUtilitiesTests.cs @@ -0,0 +1,479 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading; +using System.Threading.Tasks; +using Newtonsoft.Json.Linq; +using NgTests.Infrastructure; +using NuGet.Packaging.Core; +using NuGet.Services.Metadata.Catalog; +using NuGet.Versioning; +using Xunit; + +namespace CatalogTests +{ + public class CatalogCommitUtilitiesTests + { + private const int _maxConcurrentBatches = 1; + private static readonly CatalogCommitItemBatch _lastBatch; + private static readonly Task FailedTask = Task.FromException(new Exception()); + private static readonly PackageIdentity _packageIdentitya = new PackageIdentity(id: "a", version: new NuGetVersion("1.0.0")); + private static readonly PackageIdentity _packageIdentityb = new PackageIdentity(id: "b", version: new NuGetVersion("1.0.0")); + + static CatalogCommitUtilitiesTests() + { + var commitTimeStamp = DateTime.UtcNow; + var commit = TestUtility.CreateCatalogCommitItem(commitTimeStamp, _packageIdentitya); + + _lastBatch = new CatalogCommitItemBatch(new[] { commit }, _packageIdentitya.Id); + } + + [Fact] + public void CreateCommitItemBatches_WhenCatalogItemsIsNull_Throws() + { + IEnumerable catalogItems = null; + + var exception = Assert.Throws( + () => CatalogCommitUtilities.CreateCommitItemBatches( + catalogItems, + CatalogCommitUtilities.GetPackageIdKey)); + + Assert.Equal("catalogItems", exception.ParamName); + } + + [Fact] + public void CreateCommitItemBatches_WhenGetCatalogCommitItemKeyIsNull_Throws() + { + var exception = Assert.Throws( + () => CatalogCommitUtilities.CreateCommitItemBatches( + Enumerable.Empty(), + getCatalogCommitItemKey: null)); + + Assert.Equal("getCatalogCommitItemKey", exception.ParamName); + } + + [Fact] + public void CreateCommitItemBatches_WhenMultipleCommitItemsShareCommitTimeStampButNotCommitId_Throws() + { + var commitTimeStamp = DateTime.UtcNow; + var context = TestUtility.CreateCatalogContextJObject(); + var commitItem0 = CatalogCommitItem.Create( + context, + TestUtility.CreateCatalogCommitItemJObject(commitTimeStamp, _packageIdentitya)); + var commitItem1 = CatalogCommitItem.Create( + context, + TestUtility.CreateCatalogCommitItemJObject(commitTimeStamp, _packageIdentityb)); + var commitItems = new[] { commitItem0, commitItem1 }; + + var exception = Assert.Throws( + () => CatalogCommitUtilities.CreateCommitItemBatches( + commitItems, + CatalogCommitUtilities.GetPackageIdKey)); + + Assert.Equal("catalogItems", exception.ParamName); + Assert.StartsWith("Multiple commits exist with the same commit timestamp but different commit ID's: " + + $"{{ CommitId = {commitItem0.CommitId}, CommitTimeStamp = {commitItem0.CommitTimeStamp.ToString("O")} }}, " + + $"{{ CommitId = {commitItem1.CommitId}, CommitTimeStamp = {commitItem1.CommitTimeStamp.ToString("O")} }}.", + exception.Message); + } + + [Fact] + public void CreateCommitItemBatches_WhenMultipleCommitItemsShareCommitTimeStampButNotCommitIdAndLaterCommitExists_DoesNotThrow() + { + var commitTimeStamp0 = DateTime.UtcNow; + var commitTimeStamp1 = commitTimeStamp0.AddMinutes(1); + var context = TestUtility.CreateCatalogContextJObject(); + var commitItem0 = CatalogCommitItem.Create( + context, + TestUtility.CreateCatalogCommitItemJObject(commitTimeStamp0, _packageIdentitya)); + var commitItem1 = CatalogCommitItem.Create( + context, + TestUtility.CreateCatalogCommitItemJObject(commitTimeStamp0, _packageIdentityb)); + var commitItem2 = CatalogCommitItem.Create( + context, + TestUtility.CreateCatalogCommitItemJObject(commitTimeStamp1, _packageIdentitya)); + var commitItems = new[] { commitItem0, commitItem1, commitItem2 }; + + var batches = CatalogCommitUtilities.CreateCommitItemBatches( + commitItems, + CatalogCommitUtilities.GetPackageIdKey); + + Assert.Collection( + batches, + batch => + { + Assert.Equal(commitTimeStamp1, batch.CommitTimeStamp.ToUniversalTime()); + Assert.Collection( + batch.Items, + commit => Assert.True(ReferenceEquals(commit, commitItem2))); + }, + batch => + { + Assert.Equal(commitTimeStamp0, batch.CommitTimeStamp.ToUniversalTime()); + Assert.Collection( + batch.Items, + commit => Assert.True(ReferenceEquals(commit, commitItem1))); + }); + } + + [Fact] + public void CreateCommitItemBatches_WhenPackageIdsVaryInCasing_GroupsUsingProvidedGetKeyFunction() + { + var now = DateTime.UtcNow; + var packageIdentityA0 = new PackageIdentity(id: "a", version: new NuGetVersion("1.0.0")); + var packageIdentityA1 = new PackageIdentity(id: "A", version: new NuGetVersion("2.0.0")); + var packageIdentityA2 = new PackageIdentity(id: "A", version: new NuGetVersion("3.0.0")); + var packageIdentityB0 = new PackageIdentity(id: "b", version: new NuGetVersion("1.0.0")); + var packageIdentityB1 = new PackageIdentity(id: "B", version: new NuGetVersion("2.0.0")); + var commitId0 = Guid.NewGuid().ToString(); + var commitId1 = Guid.NewGuid().ToString(); + var commitId2 = Guid.NewGuid().ToString(); + var commitItem0 = TestUtility.CreateCatalogCommitItem(now, packageIdentityA0, commitId0); + var commitItem1 = TestUtility.CreateCatalogCommitItem(now.AddMinutes(1), packageIdentityA1, commitId1); + var commitItem2 = TestUtility.CreateCatalogCommitItem(now.AddMinutes(2), packageIdentityA2, commitId2); + var commitItem3 = TestUtility.CreateCatalogCommitItem(now, packageIdentityB0, commitId0); + var commitItem4 = TestUtility.CreateCatalogCommitItem(now.AddMinutes(1), packageIdentityB1, commitId1); + + // not in alphanumeric or chronological order + var commitItems = new[] { commitItem4, commitItem2, commitItem0, commitItem3, commitItem1 }; + + var batches = CatalogCommitUtilities.CreateCommitItemBatches( + commitItems, + CatalogCommitUtilities.GetPackageIdKey); + + Assert.Collection( + batches, + batch => + { + Assert.Equal(commitItem3.CommitTimeStamp, batch.CommitTimeStamp); + Assert.Collection( + batch.Items, + commit => Assert.True(ReferenceEquals(commit, commitItem3)), + commit => Assert.True(ReferenceEquals(commit, commitItem4))); + }, + batch => + { + Assert.Equal(commitItem0.CommitTimeStamp, batch.CommitTimeStamp); + Assert.Collection( + batch.Items, + commit => Assert.True(ReferenceEquals(commit, commitItem0)), + commit => Assert.True(ReferenceEquals(commit, commitItem1)), + commit => Assert.True(ReferenceEquals(commit, commitItem2))); + }); + } + + [Fact] + public void CreateCommitItemBatches_WhenCommitItemsContainMultipleCommitsForSamePackageIdentity_ReturnsOnlyLatestCommitForEachPackageIdentity() + { + var now = DateTime.UtcNow; + var commitItem0 = TestUtility.CreateCatalogCommitItem(now, _packageIdentitya); + var commitItem1 = TestUtility.CreateCatalogCommitItem(now.AddMinutes(1), _packageIdentitya); + var commitItem2 = TestUtility.CreateCatalogCommitItem(now.AddMinutes(2), _packageIdentitya); + var commitItems = new[] { commitItem0, commitItem1, commitItem2 }; + + var batches = CatalogCommitUtilities.CreateCommitItemBatches(commitItems, CatalogCommitUtilities.GetPackageIdKey); + + Assert.Collection( + batches, + batch => + { + Assert.Equal(commitItem2.CommitTimeStamp, batch.CommitTimeStamp); + Assert.Collection( + batch.Items, + commit => Assert.True(ReferenceEquals(commit, commitItem2))); + }); + } + + [Fact] + public void StartProcessingBatchesIfNoFailures_WhenClientIsNull_Throws() + { + const CollectorHttpClient client = null; + + var exception = Assert.Throws( + () => CatalogCommitUtilities.StartProcessingBatchesIfNoFailures( + client, + new JObject(), + new List(), + new List(), + _maxConcurrentBatches, + NoOpProcessBatchAsync, + CancellationToken.None)); + + Assert.Equal("client", exception.ParamName); + } + + [Fact] + public void StartProcessingBatchesIfNoFailures_WhenContextIsNull_Throws() + { + const JToken context = null; + + var exception = Assert.Throws( + () => CatalogCommitUtilities.StartProcessingBatchesIfNoFailures( + new CollectorHttpClient(), + context, + new List(), + new List(), + _maxConcurrentBatches, + NoOpProcessBatchAsync, + CancellationToken.None)); + + Assert.Equal("context", exception.ParamName); + } + + [Fact] + public void StartProcessingBatchesIfNoFailures_WhenUnprocessedBatchesIsNull_Throws() + { + const List unprocessedBatches = null; + + var exception = Assert.Throws( + () => CatalogCommitUtilities.StartProcessingBatchesIfNoFailures( + new CollectorHttpClient(), + new JObject(), + unprocessedBatches, + new List(), + _maxConcurrentBatches, + NoOpProcessBatchAsync, + CancellationToken.None)); + + Assert.Equal("unprocessedBatches", exception.ParamName); + } + + [Fact] + public void StartProcessingBatchesIfNoFailures_WhenProcessingBatchesIsNull_Throws() + { + const List processingBatches = null; + + var exception = Assert.Throws( + () => CatalogCommitUtilities.StartProcessingBatchesIfNoFailures( + new CollectorHttpClient(), + new JObject(), + new List(), + processingBatches, + _maxConcurrentBatches, + NoOpProcessBatchAsync, + CancellationToken.None)); + + Assert.Equal("processingBatches", exception.ParamName); + } + + [Fact] + public void StartProcessingBatchesIfNoFailures_WhenMaxConcurrentBatchesIsLessThanOne_Throws() + { + const int maxConcurrentBatches = 0; + + var exception = Assert.Throws( + () => CatalogCommitUtilities.StartProcessingBatchesIfNoFailures( + new CollectorHttpClient(), + new JObject(), + new List(), + new List(), + maxConcurrentBatches, + NoOpProcessBatchAsync, + CancellationToken.None)); + + Assert.Equal("maxConcurrentBatches", exception.ParamName); + } + + [Fact] + public void StartProcessingBatchesIfNoFailures_WhenProcessCommitItemBatchAsyncIsNull_Throws() + { + const ProcessCommitItemBatchAsync processCommitItemBatchAsync = null; + + var exception = Assert.Throws( + () => CatalogCommitUtilities.StartProcessingBatchesIfNoFailures( + new CollectorHttpClient(), + new JObject(), + new List(), + new List(), + _maxConcurrentBatches, + processCommitItemBatchAsync, + CancellationToken.None)); + + Assert.Equal("processCommitItemBatchAsync", exception.ParamName); + } + + public class StartProcessingBatchesIfNoFailures + { + private PackageIdentity _packageIdentityc = new PackageIdentity(id: "c", version: new NuGetVersion("1.0.0")); + private PackageIdentity _packageIdentityd = new PackageIdentity(id: "d", version: new NuGetVersion("1.0.0")); + private readonly DateTime _now = DateTime.UtcNow; + private readonly CatalogCommitItem _commitItem0; + private readonly CatalogCommitItem _commitItem1; + private readonly CatalogCommitItem _commitItem2; + private readonly CatalogCommitItem _commitItem3; + + public StartProcessingBatchesIfNoFailures() + { + _commitItem0 = TestUtility.CreateCatalogCommitItem(_now, _packageIdentitya); + _commitItem1 = TestUtility.CreateCatalogCommitItem(_now, _packageIdentityb); + _commitItem2 = TestUtility.CreateCatalogCommitItem(_now.AddMinutes(1), _packageIdentityc); + _commitItem3 = TestUtility.CreateCatalogCommitItem(_now.AddMinutes(2), _packageIdentityd); + } + + [Fact] + public void StartProcessingBatchesIfNoFailures_WhenAnyBatchIsFailed_DoesNotStartNewBatch() + { + var commitItemBatch = new CatalogCommitItemBatch( + new[] { _commitItem0, _commitItem1 }, + _packageIdentitya.Id); + var failedBatchTask = new CatalogCommitItemBatchTask(commitItemBatch, FailedTask); + var unprocessedBatches = new List() { commitItemBatch }; + var processingBatches = new List() { failedBatchTask }; + + CatalogCommitUtilities.StartProcessingBatchesIfNoFailures( + new CollectorHttpClient(), + new JObject(), + unprocessedBatches, + processingBatches, + _maxConcurrentBatches, + NoOpProcessBatchAsync, + CancellationToken.None); + + Assert.Equal(1, unprocessedBatches.Count); + Assert.Equal(1, processingBatches.Count); + } + + [Fact] + public void StartProcessingBatchesIfNoFailures_WhenNoBatchIsCancelled_DoesNotStartNewBatch() + { + var commitItemBatch = new CatalogCommitItemBatch( + new[] { _commitItem0, _commitItem1 }, + _packageIdentitya.Id); + var cancelledBatchTask = new CatalogCommitItemBatchTask( + commitItemBatch, + Task.FromCanceled(new CancellationToken(canceled: true))); + var unprocessedBatches = new List() { commitItemBatch }; + var processingBatches = new List() { cancelledBatchTask }; + + CatalogCommitUtilities.StartProcessingBatchesIfNoFailures( + new CollectorHttpClient(), + new JObject(), + unprocessedBatches, + processingBatches, + _maxConcurrentBatches, + NoOpProcessBatchAsync, + CancellationToken.None); + + Assert.Equal(1, unprocessedBatches.Count); + Assert.Equal(1, processingBatches.Count); + } + + [Fact] + public void StartProcessingBatchesIfNoFailures_WhenMaxConcurrencyLimitHit_DoesNotStartNewBatch() + { + var commitItemBatch0 = new CatalogCommitItemBatch(new[] { _commitItem0 }, _packageIdentitya.Id); + var commitItemBatch1 = new CatalogCommitItemBatch(new[] { _commitItem2 }, _packageIdentityc.Id); + + using (var cancellationTokenSource = new CancellationTokenSource()) + { + var inProcessTask = new CatalogCommitItemBatchTask( + commitItemBatch0, + Task.Delay(TimeSpan.FromMilliseconds(-1), cancellationTokenSource.Token)); + var unprocessedBatches = new List() { commitItemBatch1 }; + var processingBatches = new List() { inProcessTask }; + + const int maxConcurrentBatches = 1; + + CatalogCommitUtilities.StartProcessingBatchesIfNoFailures( + new CollectorHttpClient(), + new JObject(), + unprocessedBatches, + processingBatches, + maxConcurrentBatches, + NoOpProcessBatchAsync, + CancellationToken.None); + + Assert.Equal(1, unprocessedBatches.Count); + Assert.Equal(1, processingBatches.Count); + } + } + + [Fact] + public void StartProcessingBatchesIfNoFailures_WhenCanStartNewBatch_StartsNewBatch() + { + var commitItemBatch = new CatalogCommitItemBatch(new[] { _commitItem0 }, _packageIdentitya.Id); + var unprocessedBatches = new List() { commitItemBatch }; + var processingBatches = new List(); + + CatalogCommitUtilities.StartProcessingBatchesIfNoFailures( + new CollectorHttpClient(), + new JObject(), + unprocessedBatches, + processingBatches, + _maxConcurrentBatches, + NoOpProcessBatchAsync, + CancellationToken.None); + + Assert.Equal(0, unprocessedBatches.Count); + Assert.Equal(1, processingBatches.Count); + } + + [Fact] + public void StartProcessingBatchesIfNoFailures_WhenProcessingQueueContainsCompletedTasks_StartsNewBatch() + { + var commitItemBatch0 = new CatalogCommitItemBatch(new[] { _commitItem0 }, _packageIdentitya.Id); + var commitItemBatch1 = new CatalogCommitItemBatch(new[] { _commitItem1 }, _packageIdentityb.Id); + var completedTask = new CatalogCommitItemBatchTask(commitItemBatch0, Task.CompletedTask); + var unprocessedBatches = new List() { commitItemBatch1 }; + var processingBatches = new List() { completedTask }; + + CatalogCommitUtilities.StartProcessingBatchesIfNoFailures( + new CollectorHttpClient(), + new JObject(), + unprocessedBatches, + processingBatches, + _maxConcurrentBatches, + NoOpProcessBatchAsync, + CancellationToken.None); + + Assert.Equal(0, unprocessedBatches.Count); + Assert.Equal(2, processingBatches.Count); + } + } + + [Fact] + public void GetPackageIdKey_WhenItemIsNull_Throws() + { + var exception = Assert.Throws( + () => CatalogCommitUtilities.GetPackageIdKey(item: null)); + + Assert.Equal("item", exception.ParamName); + } + + [Theory] + [InlineData("a")] + [InlineData("A")] + public void GetPackageIdKey_WhenPackageIdVariesInCase_ReturnsLowerCase(string packageId) + { + var commitItem = TestUtility.CreateCatalogCommitItem( + DateTime.UtcNow, + new PackageIdentity(packageId, new NuGetVersion("1.0.0"))); + var key = CatalogCommitUtilities.GetPackageIdKey(commitItem); + + Assert.Equal(packageId.ToLowerInvariant(), key); + } + + private static CatalogCommitItemBatch CreateCatalogCommitBatch( + DateTime commitTimeStamp, + PackageIdentity packageIdentity) + { + var commit = TestUtility.CreateCatalogCommitItem(commitTimeStamp, packageIdentity); + + return new CatalogCommitItemBatch(new[] { commit }, packageIdentity.Id); + } + + private static Task NoOpProcessBatchAsync( + CollectorHttpClient client, + JToken context, + string packageId, + CatalogCommitItemBatch batch, + CatalogCommitItemBatch lastBatch, + CancellationToken cancellationToken) + { + return Task.CompletedTask; + } + } +} \ No newline at end of file diff --git a/tests/CatalogTests/CatalogIndexEntryTests.cs b/tests/CatalogTests/CatalogIndexEntryTests.cs index 8890fb2cf..224098bf1 100644 --- a/tests/CatalogTests/CatalogIndexEntryTests.cs +++ b/tests/CatalogTests/CatalogIndexEntryTests.cs @@ -2,12 +2,13 @@ // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. using System; -using System.Globalization; using System.Linq; using Newtonsoft.Json; using Newtonsoft.Json.Converters; using Newtonsoft.Json.Linq; using NgTests; +using NgTests.Infrastructure; +using NuGet.Packaging.Core; using NuGet.Protocol; using NuGet.Services.Metadata.Catalog; using NuGet.Versioning; @@ -21,8 +22,9 @@ public class CatalogIndexEntryTests private readonly string _commitId; private readonly DateTime _commitTimeStamp; - private const string _packageId = "A"; + private const string _packageId = "a"; private readonly NuGetVersion _packageVersion; + private readonly PackageIdentity _packageIdentity; private readonly Uri _uri; static CatalogIndexEntryTests() @@ -39,6 +41,7 @@ public CatalogIndexEntryTests() _commitTimeStamp = DateTime.UtcNow; _packageVersion = new NuGetVersion("1.2.3"); _uri = new Uri("https://nuget.test/a"); + _packageIdentity = new PackageIdentity(_packageId, _packageVersion); } [Fact] @@ -52,8 +55,7 @@ public void Constructor_WhenUriIsNull_Throws() CatalogConstants.NuGetPackageDetails, _commitId, _commitTimeStamp, - _packageId, - _packageVersion)); + _packageIdentity)); Assert.Equal("uri", exception.ParamName); } @@ -70,61 +72,70 @@ public void Constructor_WhenTypeIsNullEmptyOrWhitespace_Throws(string type) type, _commitId, _commitTimeStamp, - _packageId, - _packageVersion)); + _packageIdentity)); Assert.Equal("type", exception.ParamName); } - [Theory] - [InlineData(null)] - [InlineData("")] - [InlineData(" ")] - public void Constructor_WhenCommitIdIsNullEmptyOrWhitespace_Throws(string commitId) + [Fact] + public void Constructor_WhenTypesIsNull_Throws() { + string[] types = null; + var exception = Assert.Throws( () => new CatalogIndexEntry( _uri, - CatalogConstants.NuGetPackageDelete, - commitId, + types, + _commitId, _commitTimeStamp, - _packageId, - _packageVersion)); + _packageIdentity)); - Assert.Equal("commitId", exception.ParamName); + Assert.Equal("types", exception.ParamName); + } + + [Fact] + public void Constructor_WhenTypesIsEmpty_Throws() + { + var exception = Assert.Throws( + () => new CatalogIndexEntry( + _uri, + Array.Empty(), + _commitId, + _commitTimeStamp, + _packageIdentity)); + + Assert.Equal("types", exception.ParamName); } [Theory] [InlineData(null)] [InlineData("")] [InlineData(" ")] - public void Constructor_WhenIdIsNullEmptyOrWhitespace_Throws(string id) + public void Constructor_WhenCommitIdIsNullEmptyOrWhitespace_Throws(string commitId) { var exception = Assert.Throws( () => new CatalogIndexEntry( _uri, CatalogConstants.NuGetPackageDelete, - _commitId, + commitId, _commitTimeStamp, - id, - _packageVersion)); + _packageIdentity)); - Assert.Equal("id", exception.ParamName); + Assert.Equal("commitId", exception.ParamName); } [Fact] - public void Constructor_WhenVersionIsNull_Throws() + public void Constructor_WhenPackageIdentityIsNull_Throws() { var exception = Assert.Throws( () => new CatalogIndexEntry( _uri, - CatalogConstants.NuGetPackageDetails, + CatalogConstants.NuGetPackageDelete, _commitId, _commitTimeStamp, - _packageId, - version: null)); + packageIdentity: null)); - Assert.Equal("version", exception.ParamName); + Assert.Equal("packageIdentity", exception.ParamName); } [Fact] @@ -135,8 +146,7 @@ public void Constructor_WhenArgumentsAreValid_ReturnsInstance() CatalogConstants.NuGetPackageDetails, _commitId, _commitTimeStamp, - _packageId, - _packageVersion); + _packageIdentity); Assert.Equal(_uri.AbsoluteUri, entry.Uri.AbsoluteUri); Assert.Equal(CatalogConstants.NuGetPackageDetails, entry.Types.Single()); @@ -147,57 +157,30 @@ public void Constructor_WhenArgumentsAreValid_ReturnsInstance() } [Fact] - public void Create_WhenTokenIsNull_Throws() + public void Create_WhenCommitItemIsNull_Throws() { - var exception = Assert.Throws(() => CatalogIndexEntry.Create(token: null)); + var exception = Assert.Throws(() => CatalogIndexEntry.Create(commitItem: null)); - Assert.Equal("token", exception.ParamName); + Assert.Equal("commitItem", exception.ParamName); } [Fact] public void Create_WhenArgumentIsValid_ReturnsInstance() { - var jObject = CreateCatalogIndexJObject(); + var contextJObject = TestUtility.CreateCatalogContextJObject(); + var commitItemJObject = TestUtility.CreateCatalogCommitItemJObject(_commitTimeStamp, _packageIdentity); + var commitItem = CatalogCommitItem.Create(contextJObject, commitItemJObject); - var entry = CatalogIndexEntry.Create(jObject); + var entry = CatalogIndexEntry.Create(commitItem); Assert.Equal(_uri.AbsoluteUri, entry.Uri.AbsoluteUri); Assert.Equal(CatalogConstants.NuGetPackageDetails, entry.Types.Single()); - Assert.Equal(_commitId, entry.CommitId); - Assert.Equal(_commitTimeStamp, entry.CommitTimeStamp); + Assert.Equal(commitItemJObject[CatalogConstants.CommitId].ToString(), entry.CommitId); + Assert.Equal(_commitTimeStamp, entry.CommitTimeStamp.ToUniversalTime()); Assert.Equal(_packageId, entry.Id); Assert.Equal(_packageVersion, entry.Version); } - [Theory] - [InlineData("2018-10-15T01:12:40.1234567Z")] - [InlineData("2018-10-15T01:12:40.123456Z")] - [InlineData("2018-10-15T01:12:40.12345Z")] - [InlineData("2018-10-15T01:12:40.1234Z")] - [InlineData("2018-10-15T01:12:40.123Z")] - [InlineData("2018-10-15T01:12:40.12Z")] - [InlineData("2018-10-15T01:12:40.1Z")] - public void Create_WhenCommitTimeStampVariesInSignificantDigits_DeserializesCorrectly(string commitTimeStamp) - { - var jObject = new JObject( - new JProperty(CatalogConstants.IdKeyword, _uri), - new JProperty(CatalogConstants.TypeKeyword, CatalogConstants.NuGetPackageDetails), - new JProperty(CatalogConstants.CommitId, _commitId), - new JProperty(CatalogConstants.CommitTimeStamp, commitTimeStamp), - new JProperty(CatalogConstants.NuGetId, _packageId), - new JProperty(CatalogConstants.NuGetVersion, _packageVersion.ToNormalizedString())); - - var entry = CatalogIndexEntry.Create(jObject); - - var expectedCommitTimeStamp = DateTime.ParseExact( - commitTimeStamp, - CatalogConstants.CommitTimeStampFormat, - DateTimeFormatInfo.CurrentInfo, - DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal); - - Assert.Equal(expectedCommitTimeStamp, entry.CommitTimeStamp); - } - [Fact] public void CompareTo_WhenOtherIsNull_Throws() { @@ -206,8 +189,7 @@ public void CompareTo_WhenOtherIsNull_Throws() CatalogConstants.NuGetPackageDetails, _commitId, _commitTimeStamp, - _packageId, - _packageVersion); + _packageIdentity); var exception = Assert.Throws(() => entry.CompareTo(other: null)); @@ -223,15 +205,13 @@ public void CompareTo_WhenCommitTimeStampsAreNotEqual_ReturnsNonZero() CatalogConstants.NuGetPackageDetails, _commitId, now.AddHours(-1), - _packageId, - _packageVersion); + _packageIdentity); var newerEntry = new CatalogIndexEntry( _uri, CatalogConstants.NuGetPackageDetails, _commitId, now, - _packageId, - _packageVersion); + _packageIdentity); Assert.Equal(-1, olderEntry.CompareTo(newerEntry)); Assert.Equal(1, newerEntry.CompareTo(olderEntry)); @@ -240,23 +220,22 @@ public void CompareTo_WhenCommitTimeStampsAreNotEqual_ReturnsNonZero() [Fact] public void CompareTo_WhenCommitTimeStampsAreEqual_ReturnsZero() { - var entry1 = new CatalogIndexEntry( - _uri, + var entry0 = new CatalogIndexEntry( + new Uri("https://nuget.test/a"), CatalogConstants.NuGetPackageDetails, _commitId, _commitTimeStamp, - _packageId, - _packageVersion); - var entry2 = new CatalogIndexEntry( - _uri, - CatalogConstants.NuGetPackageDetails, - _commitId, + _packageIdentity); + var entry1 = new CatalogIndexEntry( + new Uri("https://nuget.test/b"), + CatalogConstants.NuGetPackageDelete, + Guid.NewGuid().ToString(), _commitTimeStamp, - _packageId, - _packageVersion); + new PackageIdentity(id: "b", version: new NuGetVersion("4.5.6"))); - Assert.Equal(0, entry1.CompareTo(entry2)); - Assert.Equal(0, entry2.CompareTo(entry1)); + Assert.Equal(0, entry0.CompareTo(entry0)); + Assert.Equal(0, entry0.CompareTo(entry1)); + Assert.Equal(0, entry1.CompareTo(entry0)); } [Fact] @@ -267,8 +246,7 @@ public void IsDelete_WhenTypeIsNotPackageDelete_ReturnsFalse() CatalogConstants.NuGetPackageDetails, _commitId, _commitTimeStamp, - _packageId, - _packageVersion); + _packageIdentity); Assert.False(entry.IsDelete); } @@ -281,8 +259,7 @@ public void IsDelete_WhenTypeIsPackageDelete_ReturnsTrue() CatalogConstants.NuGetPackageDelete, _commitId, _commitTimeStamp, - _packageId, - _packageVersion); + _packageIdentity); Assert.True(entry.IsDelete); } @@ -295,10 +272,9 @@ public void JsonSerialization_ReturnsCorrectJson() CatalogConstants.NuGetPackageDetails, _commitId, _commitTimeStamp, - _packageId, - _packageVersion); + _packageIdentity); - var jObject = CreateCatalogIndexJObject(); + var jObject = CreateCatalogIndexJObject(CatalogConstants.NuGetPackageDetails); var expectedResult = jObject.ToString(Formatting.None, _settings.Converters.ToArray()); var actualResult = JsonConvert.SerializeObject(entry, Formatting.None, _settings); @@ -315,7 +291,7 @@ public void JsonSerialization_ReturnsCorrectJson() [InlineData(CatalogConstants.NuGetVersion)] public void JsonDeserialization_WhenRequiredPropertyIsMissing_Throws(string propertyToRemove) { - var jObject = CreateCatalogIndexJObject(); + var jObject = CreateCatalogIndexJObject(CatalogConstants.NuGetPackageDetails); jObject.Remove(propertyToRemove); @@ -328,28 +304,46 @@ public void JsonDeserialization_WhenRequiredPropertyIsMissing_Throws(string prop } [Fact] - public void JsonDeserialization_ReturnsCorrectObject() + public void JsonDeserialization_WhenTypeIsPackageDetails_ReturnsCorrectObject() { - var jObject = CreateCatalogIndexJObject(); + var jObject = CreateCatalogIndexJObject(CatalogConstants.NuGetPackageDetails); var json = jObject.ToString(Formatting.None, _settings.Converters.ToArray()); var entry = JsonConvert.DeserializeObject(json, _settings); Assert.Equal(_uri.AbsoluteUri, entry.Uri.AbsoluteUri); Assert.Equal(CatalogConstants.NuGetPackageDetails, entry.Types.Single()); + Assert.False(entry.IsDelete); + Assert.Equal(_commitId, entry.CommitId); + Assert.Equal(_commitTimeStamp, entry.CommitTimeStamp); + Assert.Equal(_packageId, entry.Id); + Assert.Equal(_packageVersion, entry.Version); + } + + [Fact] + public void JsonDeserialization_WhenTypeIsPackageDelete_ReturnsCorrectObject() + { + var jObject = CreateCatalogIndexJObject(CatalogConstants.NuGetPackageDelete); + var json = jObject.ToString(Formatting.None, _settings.Converters.ToArray()); + + var entry = JsonConvert.DeserializeObject(json, _settings); + + Assert.Equal(_uri.AbsoluteUri, entry.Uri.AbsoluteUri); + Assert.Equal(CatalogConstants.NuGetPackageDelete, entry.Types.Single()); + Assert.True(entry.IsDelete); Assert.Equal(_commitId, entry.CommitId); Assert.Equal(_commitTimeStamp, entry.CommitTimeStamp); Assert.Equal(_packageId, entry.Id); Assert.Equal(_packageVersion, entry.Version); } - private JObject CreateCatalogIndexJObject(string commitTimeStamp = null) + private JObject CreateCatalogIndexJObject(string type) { return new JObject( new JProperty(CatalogConstants.IdKeyword, _uri), - new JProperty(CatalogConstants.TypeKeyword, CatalogConstants.NuGetPackageDetails), + new JProperty(CatalogConstants.TypeKeyword, type), new JProperty(CatalogConstants.CommitId, _commitId), - new JProperty(CatalogConstants.CommitTimeStamp, commitTimeStamp ?? _commitTimeStamp.ToString(CatalogConstants.CommitTimeStampFormat)), + new JProperty(CatalogConstants.CommitTimeStamp, _commitTimeStamp.ToString(CatalogConstants.CommitTimeStampFormat)), new JProperty(CatalogConstants.NuGetId, _packageId), new JProperty(CatalogConstants.NuGetVersion, _packageVersion.ToNormalizedString())); } diff --git a/tests/CatalogTests/CatalogTests.csproj b/tests/CatalogTests/CatalogTests.csproj index c77efa1f3..338224a30 100644 --- a/tests/CatalogTests/CatalogTests.csproj +++ b/tests/CatalogTests/CatalogTests.csproj @@ -71,9 +71,17 @@ + + + + + + + + @@ -177,16 +185,16 @@ PreserveNewest - PreserveNewest + PreserveNewest - PreserveNewest + PreserveNewest - PreserveNewest + PreserveNewest - PreserveNewest + PreserveNewest PreserveNewest diff --git a/tests/NgTests/DnxCatalogCollectorTests.cs b/tests/CatalogTests/Dnx/DnxCatalogCollectorTests.cs similarity index 69% rename from tests/NgTests/DnxCatalogCollectorTests.cs rename to tests/CatalogTests/Dnx/DnxCatalogCollectorTests.cs index 4a03bbfec..03a97e0fc 100644 --- a/tests/NgTests/DnxCatalogCollectorTests.cs +++ b/tests/CatalogTests/Dnx/DnxCatalogCollectorTests.cs @@ -12,8 +12,12 @@ using System.Text; using System.Threading; using System.Threading.Tasks; +using CatalogTests.Helpers; using Microsoft.Extensions.Logging; using Moq; +using Newtonsoft.Json; +using Newtonsoft.Json.Linq; +using NgTests; using NgTests.Data; using NgTests.Infrastructure; using NuGet.Services.Metadata.Catalog; @@ -21,26 +25,55 @@ using NuGet.Services.Metadata.Catalog.Persistence; using Xunit; -namespace NgTests +namespace CatalogTests.Dnx { public class DnxCatalogCollectorTests { + private static readonly Uri _baseUri = new Uri("https://nuget.test"); private const string _nuspecData = "nuspec data"; private const int _maxDegreeOfParallelism = 20; private static readonly HttpContent _noContent = new ByteArrayContent(new byte[0]); private const IAzureStorage _nullPreferredPackageSourceStorage = null; private static readonly Uri _contentBaseAddress = new Uri("http://tempuri.org/packages/"); + private readonly JObject _contextKeyword = new JObject( + new JProperty(CatalogConstants.VocabKeyword, CatalogConstants.NuGetSchemaUri), + new JProperty(CatalogConstants.NuGet, CatalogConstants.NuGetSchemaUri), + new JProperty(CatalogConstants.Items, + new JObject( + new JProperty(CatalogConstants.IdKeyword, CatalogConstants.Item), + new JProperty(CatalogConstants.ContainerKeyword, CatalogConstants.SetKeyword))), + new JProperty(CatalogConstants.Parent, + new JObject( + new JProperty(CatalogConstants.TypeKeyword, CatalogConstants.IdKeyword))), + new JProperty(CatalogConstants.CommitTimeStamp, + new JObject( + new JProperty(CatalogConstants.TypeKeyword, CatalogConstants.XsdDateTime))), + new JProperty(CatalogConstants.NuGetLastCreated, + new JObject( + new JProperty(CatalogConstants.TypeKeyword, CatalogConstants.XsdDateTime))), + new JProperty(CatalogConstants.NuGetLastEdited, + new JObject( + new JProperty(CatalogConstants.TypeKeyword, CatalogConstants.XsdDateTime))), + new JProperty(CatalogConstants.NuGetLastDeleted, + new JObject( + new JProperty(CatalogConstants.TypeKeyword, CatalogConstants.XsdDateTime)))); + private readonly JsonSerializerSettings _jsonSettings = new JsonSerializerSettings() + { + DateParseHandling = DateParseHandling.None, + NullValueHandling = NullValueHandling.Ignore + }; private MemoryStorage _catalogToDnxStorage; private TestStorageFactory _catalogToDnxStorageFactory; private MockServerHttpClientHandler _mockServer; private ILogger _logger; private DnxCatalogCollector _target; + private Random _random; private Uri _cursorJsonUri; public DnxCatalogCollectorTests() { - _catalogToDnxStorage = new MemoryStorage(); + _catalogToDnxStorage = new MemoryStorage(_baseUri); _catalogToDnxStorageFactory = new TestStorageFactory(name => _catalogToDnxStorage.WithName(name)); _mockServer = new MockServerHttpClientHandler(); _mockServer.SetAction("/", request => Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK))); @@ -59,6 +92,7 @@ public DnxCatalogCollectorTests() () => _mockServer); _cursorJsonUri = _catalogToDnxStorage.ResolveUri("cursor.json"); + _random = new Random(); } [Fact] @@ -305,14 +339,13 @@ public async Task RunAsync_WithValidPackage_CreatesFlatContainer() var nupkgUri = _catalogToDnxStorage.ResolveUri("/listedpackage/1.0.0/listedpackage.1.0.0.nupkg"); var nuspecUri = _catalogToDnxStorage.ResolveUri("/listedpackage/1.0.0/listedpackage.nuspec"); var catalogStorage = Catalogs.CreateTestCatalogWithThreePackagesAndDelete(); - var nupkgStream = File.OpenRead("Packages\\ListedPackage.1.0.0.zip"); - var expectedNupkg = GetStreamBytes(nupkgStream); + var expectedNupkg = File.ReadAllBytes("Packages\\ListedPackage.1.0.0.zip"); await _mockServer.AddStorageAsync(catalogStorage); _mockServer.SetAction( "/packages/listedpackage.1.0.0.nupkg", - request => Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK) { Content = new StreamContent(nupkgStream) })); + request => Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK) { Content = new ByteArrayContent(expectedNupkg) })); var front = new DurableCursor(_cursorJsonUri, _catalogToDnxStorage, MemoryCursor.MinValue); ReadCursor back = MemoryCursor.CreateMax(); @@ -409,7 +442,6 @@ public async Task RunAsync_WithNonIAzureStorage_WhenPackageIsAlreadySynchronized var nupkgUri = _catalogToDnxStorage.ResolveUri("/listedpackage/1.0.1/listedpackage.1.0.1.nupkg"); var nuspecUri = _catalogToDnxStorage.ResolveUri("/listedpackage/1.0.1/listedpackage.nuspec"); var nupkgStream = File.OpenRead("Packages\\ListedPackage.1.0.1.zip"); - var expectedNupkg = GetStreamBytes(nupkgStream); await _catalogToDnxStorage.SaveAsync( new Uri("http://tempuri.org/listedpackage/index.json"), @@ -464,7 +496,6 @@ public async Task RunAsync_WithIAzureStorage_WhenPackageIsAlreadySynchronizedAnd var nupkgUri = _catalogToDnxStorage.ResolveUri("/listedpackage/1.0.0/listedpackage.1.0.0.nupkg"); var nuspecUri = _catalogToDnxStorage.ResolveUri("/listedpackage/1.0.0/listedpackage.nuspec"); var nupkgStream = File.OpenRead("Packages\\ListedPackage.1.0.0.zip"); - var expectedNupkg = GetStreamBytes(nupkgStream); await _catalogToDnxStorage.SaveAsync( new Uri("http://tempuri.org/listedpackage/index.json"), @@ -518,8 +549,7 @@ public async Task RunAsync_WithFakeIAzureStorage_WhenPackageIsAlreadySynchronize var indexJsonUri = _catalogToDnxStorage.ResolveUri("/listedpackage/index.json"); var nupkgUri = _catalogToDnxStorage.ResolveUri("/listedpackage/1.0.0/listedpackage.1.0.0.nupkg"); var nuspecUri = _catalogToDnxStorage.ResolveUri("/listedpackage/1.0.0/listedpackage.nuspec"); - var nupkgStream = File.OpenRead("Packages\\ListedPackage.1.0.0.zip"); - var expectedNupkg = GetStreamBytes(nupkgStream); + var expectedNupkg = File.ReadAllBytes("Packages\\ListedPackage.1.0.0.zip"); await _catalogToDnxStorage.SaveAsync( new Uri("http://tempuri.org/listedpackage/index.json"), @@ -541,7 +571,7 @@ await _catalogToDnxStorage.SaveAsync( _mockServer.SetAction( "/packages/listedpackage.1.0.0.nupkg", - request => Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK) { Content = new StreamContent(nupkgStream) })); + request => Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK) { Content = new ByteArrayContent(expectedNupkg) })); var front = new DurableCursor(_cursorJsonUri, _catalogToDnxStorage, MemoryCursor.MinValue); ReadCursor back = MemoryCursor.CreateMax(); @@ -634,11 +664,12 @@ public async Task RunAsync_WhenDownloadingPackage_RejectsUnexpectedHttpStatusCod var front = new DurableCursor(_cursorJsonUri, _catalogToDnxStorage, MemoryCursor.MinValue); ReadCursor back = MemoryCursor.CreateMax(); - var exception = await Assert.ThrowsAsync( + var exception = await Assert.ThrowsAsync( () => _target.RunAsync(front, back, CancellationToken.None)); + Assert.IsType(exception.InnerException); Assert.Equal( $"Expected status code OK for package download, actual: {statusCode}", - exception.Message); + exception.InnerException.Message); Assert.Equal(0, _catalogToDnxStorage.Content.Count); } @@ -721,7 +752,9 @@ public async Task RunAsync_WhenExceptionOccurs_DoesNotSkipPackage(string catalog ReadCursor back = MemoryCursor.CreateMax(); // Act - await Assert.ThrowsAsync(() => _target.RunAsync(front, back, CancellationToken.None)); + var exception = await Assert.ThrowsAsync( + () => _target.RunAsync(front, back, CancellationToken.None)); + Assert.IsType(exception.InnerException); var cursorBeforeRetry = front.Value; await _target.RunAsync(front, back, CancellationToken.None); var cursorAfterRetry = front.Value; @@ -742,50 +775,298 @@ public async Task RunAsync_WhenExceptionOccurs_DoesNotSkipPackage(string catalog .FirstOrDefault(pair => pair.Key.PathAndQuery.EndsWith("/anotherpackage/1.0.0/anotherpackage.1.0.0.nupkg")); Assert.NotNull(anotherPackage100.Key); - Assert.Equal(DateTime.Parse(expectedCursorBeforeRetry).ToUniversalTime(), cursorBeforeRetry); + Assert.Equal(MemoryCursor.MinValue, cursorBeforeRetry); Assert.Equal(DateTime.Parse("2015-10-12T10:08:55.3335317Z").ToUniversalTime(), cursorAfterRetry); } [Fact] - public async Task RunAsync_WhenMultipleEntriesWithSamePackageIdentityInSameBatch_Throws() + public async Task RunAsync_WithIdenticalCommitItems_ProcessesPackage() { - var zipWithWrongNameNuspec = CreateZipStreamWithEntry("Newtonsoft.Json.nuspec", _nuspecData); - var indexJsonUri = _catalogToDnxStorage.ResolveUri("/listedpackage/index.json"); - var nupkgUri = _catalogToDnxStorage.ResolveUri("/listedpackage/1.0.0/listedpackage.1.0.0.nupkg"); - var nuspecUri = _catalogToDnxStorage.ResolveUri("/listedpackage/1.0.0/listedpackage.nuspec"); - var nupkgStream = File.OpenRead(@"Packages\ListedPackage.1.0.1.zip"); - var expectedNupkg = GetStreamBytes(nupkgStream); - var catalogStorage = Catalogs.CreateTestCatalogWithMultipleEntriesWithSamePackageIdentityInSameBatch(); - - await _mockServer.AddStorageAsync(catalogStorage); - - _mockServer.SetAction( - "/packages/listedpackage.1.0.0.nupkg", - request => Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK) { Content = new StreamContent(nupkgStream) })); - - var front = new DurableCursor(_cursorJsonUri, _catalogToDnxStorage, MemoryCursor.MinValue); - ReadCursor back = MemoryCursor.CreateMax(); - - var exception = await Assert.ThrowsAsync( - () => _target.RunAsync(front, back, CancellationToken.None)); - - Assert.Equal("The catalog batch 10/13/2015 6:40:07 AM contains multiple entries for the same package identity. Package(s): listedpackage 1.0.0", exception.Message); + using (var package = TestPackage.Create(_random)) + { + var catalogIndexUri = new Uri(_baseUri, "index.json"); + var catalogPageUri = new Uri(_baseUri, "page0.json"); + + var commitId = Guid.NewGuid().ToString(); + var commitTimeStamp = DateTimeOffset.UtcNow; + var independentPackageDetails0 = new CatalogIndependentPackageDetails( + package.Id, + package.Version.ToNormalizedString(), + _baseUri.AbsoluteUri, + commitId, + commitTimeStamp); + var independentPackageDetails1 = new CatalogIndependentPackageDetails( + package.Id, + package.Version.ToNormalizedString(), + _baseUri.AbsoluteUri, + commitId, + commitTimeStamp); + var packageDetails = new[] + { + CatalogPackageDetails.Create(independentPackageDetails0), + CatalogPackageDetails.Create(independentPackageDetails1) + }; + + var independentPage = new CatalogIndependentPage( + catalogPageUri.AbsoluteUri, + CatalogConstants.CatalogPage, + commitId, + commitTimeStamp.ToString(CatalogConstants.CommitTimeStampFormat), + packageDetails.Length, + catalogIndexUri.AbsoluteUri, + packageDetails, + _contextKeyword); + + var index = CatalogIndex.Create(independentPage, _contextKeyword); + var catalogStorage = new MemoryStorage(_baseUri); + + catalogStorage.Content.TryAdd(catalogIndexUri, CreateStringStorageContent(index)); + catalogStorage.Content.TryAdd(catalogPageUri, CreateStringStorageContent(independentPage)); + catalogStorage.Content.TryAdd( + new Uri(independentPackageDetails0.IdKeyword), + CreateStringStorageContent(independentPackageDetails0)); + catalogStorage.Content.TryAdd( + new Uri(independentPackageDetails1.IdKeyword), + CreateStringStorageContent(independentPackageDetails1)); + + byte[] expectedNupkgBytes = ReadPackageBytes(package); + + await _mockServer.AddStorageAsync(catalogStorage); + + var packageId = package.Id.ToLowerInvariant(); + var packageVersion = package.Version.ToNormalizedString().ToLowerInvariant(); + var nupkgPathAndQuery = $"/packages/{packageId}.{packageVersion}.nupkg"; + + _mockServer.SetAction( + nupkgPathAndQuery, + request => Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK) + { + Content = new ByteArrayContent(expectedNupkgBytes) + })); + + var front = new DurableCursor(_cursorJsonUri, _catalogToDnxStorage, MemoryCursor.MinValue); + ReadCursor back = MemoryCursor.CreateMax(); + + await _target.RunAsync(front, back, CancellationToken.None); + + Assert.Equal(4, _catalogToDnxStorage.Content.Count); + Assert.Equal(3, _mockServer.Requests.Count); + + Assert.EndsWith("/index.json", _mockServer.Requests[0].RequestUri.AbsoluteUri); + Assert.EndsWith("/page0.json", _mockServer.Requests[1].RequestUri.AbsoluteUri); + Assert.Contains(nupkgPathAndQuery, _mockServer.Requests[2].RequestUri.AbsoluteUri); + + var indexJsonUri = _catalogToDnxStorage.ResolveUri($"{packageId}/index.json"); + var nupkgUri = _catalogToDnxStorage.ResolveUri($"{packageId}/{packageVersion}/{packageId}.{packageVersion}.nupkg"); + var nuspecUri = _catalogToDnxStorage.ResolveUri($"{packageId}/{packageVersion}/{packageId}.nuspec"); + + Assert.True(_catalogToDnxStorage.Content.ContainsKey(_cursorJsonUri)); + Assert.True(_catalogToDnxStorage.Content.ContainsKey(indexJsonUri)); + Assert.True(_catalogToDnxStorage.Content.ContainsKey(nupkgUri)); + Assert.True(_catalogToDnxStorage.Content.ContainsKey(nuspecUri)); + Assert.True(_catalogToDnxStorage.ContentBytes.TryGetValue(_cursorJsonUri, out var cursorBytes)); + Assert.True(_catalogToDnxStorage.ContentBytes.TryGetValue(indexJsonUri, out var indexBytes)); + Assert.True(_catalogToDnxStorage.ContentBytes.TryGetValue(nupkgUri, out var actualNupkgBytes)); + Assert.True(_catalogToDnxStorage.ContentBytes.TryGetValue(nuspecUri, out var nuspecBytes)); + + var actualCursorJson = Encoding.UTF8.GetString(cursorBytes); + var actualIndexJson = Encoding.UTF8.GetString(indexBytes); + var actualNuspec = Encoding.UTF8.GetString(nuspecBytes); + + Assert.Equal(GetExpectedCursorJsonContent(front.Value.ToString("yyyy-MM-ddTHH:mm:ss.fffffff")), actualCursorJson); + Assert.Equal(GetExpectedIndexJsonContent(packageVersion), actualIndexJson); + Assert.Equal(expectedNupkgBytes, actualNupkgBytes); + Assert.Equal(package.Nuspec, actualNuspec); + } } - private static byte[] GetStreamBytes(Stream srcStream) + [Fact] + public async Task RunAsync_WhenMultipleCommitItemsWithSamePackageIdentityExistAcrossMultipleCommits_OnlyLastCommitIsProcessed() { - using (var memoryStream = new MemoryStream()) + using (var package = TestPackage.Create(_random)) { - srcStream.Position = 0; - - srcStream.CopyTo(memoryStream); - - srcStream.Position = 0; + var catalogIndexUri = new Uri(_baseUri, "index.json"); + var catalogPageUri = new Uri(_baseUri, "page0.json"); + + var commitTimeStamp1 = DateTimeOffset.UtcNow; + var commitTimeStamp0 = commitTimeStamp1.AddMinutes(-1); + var independentPackageDetails0 = new CatalogIndependentPackageDetails( + package.Id, + package.Version.ToNormalizedString(), + _baseUri.AbsoluteUri, + Guid.NewGuid().ToString(), + commitTimeStamp0); + var independentPackageDetails1 = new CatalogIndependentPackageDetails( + package.Id, + package.Version.ToNormalizedString(), + _baseUri.AbsoluteUri, + Guid.NewGuid().ToString(), + commitTimeStamp1); + var packageDetails = new[] + { + CatalogPackageDetails.Create(independentPackageDetails0), + CatalogPackageDetails.Create(independentPackageDetails1) + }; + + var independentPage = new CatalogIndependentPage( + catalogPageUri.AbsoluteUri, + CatalogConstants.CatalogPage, + independentPackageDetails1.CommitId, + independentPackageDetails1.CommitTimeStamp, + packageDetails.Length, + catalogIndexUri.AbsoluteUri, + packageDetails, + _contextKeyword); + + var index = CatalogIndex.Create(independentPage, _contextKeyword); + var catalogStorage = new MemoryStorage(_baseUri); + + catalogStorage.Content.TryAdd(catalogIndexUri, CreateStringStorageContent(index)); + catalogStorage.Content.TryAdd(catalogPageUri, CreateStringStorageContent(independentPage)); + catalogStorage.Content.TryAdd( + new Uri(independentPackageDetails0.IdKeyword), + CreateStringStorageContent(independentPackageDetails0)); + catalogStorage.Content.TryAdd( + new Uri(independentPackageDetails1.IdKeyword), + CreateStringStorageContent(independentPackageDetails1)); + + byte[] expectedNupkgBytes = ReadPackageBytes(package); + + await _mockServer.AddStorageAsync(catalogStorage); + + var packageId = package.Id.ToLowerInvariant(); + var packageVersion = package.Version.ToNormalizedString().ToLowerInvariant(); + var nupkgPathAndQuery = $"/packages/{packageId}.{packageVersion}.nupkg"; + + _mockServer.SetAction( + nupkgPathAndQuery, + request => Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK) + { + Content = new ByteArrayContent(expectedNupkgBytes) + })); + + var front = new DurableCursor(_cursorJsonUri, _catalogToDnxStorage, MemoryCursor.MinValue); + ReadCursor back = MemoryCursor.CreateMax(); + + await _target.RunAsync(front, back, CancellationToken.None); + + Assert.Equal(4, _catalogToDnxStorage.Content.Count); + Assert.Equal(3, _mockServer.Requests.Count); + + Assert.EndsWith("/index.json", _mockServer.Requests[0].RequestUri.AbsoluteUri); + Assert.EndsWith("/page0.json", _mockServer.Requests[1].RequestUri.AbsoluteUri); + Assert.Contains(nupkgPathAndQuery, _mockServer.Requests[2].RequestUri.AbsoluteUri); + + var indexJsonUri = _catalogToDnxStorage.ResolveUri($"{packageId}/index.json"); + var nupkgUri = _catalogToDnxStorage.ResolveUri($"{packageId}/{packageVersion}/{packageId}.{packageVersion}.nupkg"); + var nuspecUri = _catalogToDnxStorage.ResolveUri($"{packageId}/{packageVersion}/{packageId}.nuspec"); + + Assert.True(_catalogToDnxStorage.Content.ContainsKey(_cursorJsonUri)); + Assert.True(_catalogToDnxStorage.Content.ContainsKey(indexJsonUri)); + Assert.True(_catalogToDnxStorage.Content.ContainsKey(nupkgUri)); + Assert.True(_catalogToDnxStorage.Content.ContainsKey(nuspecUri)); + Assert.True(_catalogToDnxStorage.ContentBytes.TryGetValue(_cursorJsonUri, out var cursorBytes)); + Assert.True(_catalogToDnxStorage.ContentBytes.TryGetValue(indexJsonUri, out var indexBytes)); + Assert.True(_catalogToDnxStorage.ContentBytes.TryGetValue(nupkgUri, out var actualNupkgBytes)); + Assert.True(_catalogToDnxStorage.ContentBytes.TryGetValue(nuspecUri, out var nuspecBytes)); + + var actualCursorJson = Encoding.UTF8.GetString(cursorBytes); + var actualIndexJson = Encoding.UTF8.GetString(indexBytes); + var actualNuspec = Encoding.UTF8.GetString(nuspecBytes); + + Assert.Equal(GetExpectedCursorJsonContent(front.Value.ToString("yyyy-MM-ddTHH:mm:ss.fffffff")), actualCursorJson); + Assert.Equal(GetExpectedIndexJsonContent(packageVersion), actualIndexJson); + Assert.Equal(expectedNupkgBytes, actualNupkgBytes); + Assert.Equal(package.Nuspec, actualNuspec); + } + } - return memoryStream.ToArray(); + [Fact] + public async Task RunAsync_WhenMultipleCommitItemsHaveSameCommitTimeStampButDifferentCommitId_Throws() + { + using (var package0 = TestPackage.Create(_random)) + using (var package1 = TestPackage.Create(_random)) + { + var catalogIndexUri = new Uri(_baseUri, "index.json"); + var catalogPageUri = new Uri(_baseUri, "page0.json"); + + var commitId0 = Guid.NewGuid().ToString(); + var commitId1 = Guid.NewGuid().ToString(); + var commitTimeStamp = DateTime.UtcNow; + var independentPackageDetails0 = new CatalogIndependentPackageDetails( + package0.Id, + package0.Version.ToNormalizedString(), + _baseUri.AbsoluteUri, + commitId0, + commitTimeStamp); + var independentPackageDetails1 = new CatalogIndependentPackageDetails( + package1.Id, + package1.Version.ToNormalizedString(), + _baseUri.AbsoluteUri, + commitId1, + commitTimeStamp); + var packageDetails = new[] + { + CatalogPackageDetails.Create(independentPackageDetails0), + CatalogPackageDetails.Create(independentPackageDetails1) + }; + + var independentPage = new CatalogIndependentPage( + catalogPageUri.AbsoluteUri, + CatalogConstants.CatalogPage, + independentPackageDetails1.CommitId, + commitTimeStamp.ToString(CatalogConstants.CommitTimeStampFormat), + packageDetails.Length, + catalogIndexUri.AbsoluteUri, + packageDetails, + _contextKeyword); + + var index = CatalogIndex.Create(independentPage, _contextKeyword); + var catalogStorage = new MemoryStorage(_baseUri); + + catalogStorage.Content.TryAdd(catalogIndexUri, CreateStringStorageContent(index)); + catalogStorage.Content.TryAdd(catalogPageUri, CreateStringStorageContent(independentPage)); + catalogStorage.Content.TryAdd( + new Uri(independentPackageDetails0.IdKeyword), + CreateStringStorageContent(independentPackageDetails0)); + catalogStorage.Content.TryAdd( + new Uri(independentPackageDetails1.IdKeyword), + CreateStringStorageContent(independentPackageDetails1)); + + byte[] expectedNupkgBytes = ReadPackageBytes(package0); + + await _mockServer.AddStorageAsync(catalogStorage); + + var packageId = package0.Id.ToLowerInvariant(); + var packageVersion = package0.Version.ToNormalizedString().ToLowerInvariant(); + var nupkgPathAndQuery = $"/packages/{packageId}.{packageVersion}.nupkg"; + + _mockServer.SetAction( + nupkgPathAndQuery, + request => Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK) + { + Content = new ByteArrayContent(expectedNupkgBytes) + })); + + var front = new DurableCursor(_cursorJsonUri, _catalogToDnxStorage, MemoryCursor.MinValue); + ReadCursor back = MemoryCursor.CreateMax(); + + var exception = await Assert.ThrowsAsync( + () => _target.RunAsync(front, back, CancellationToken.None)); + + var expectedMessage = "Multiple commits exist with the same commit timestamp but different commit ID's: " + + $"{{ CommitId = {commitId0}, CommitTimeStamp = {commitTimeStamp.ToString("yyyy-MM-ddTHH:mm:ss.fffffff")} }}, " + + $"{{ CommitId = {commitId1}, CommitTimeStamp = {commitTimeStamp.ToString("yyyy-MM-ddTHH:mm:ss.fffffff")} }}"; + + Assert.StartsWith(expectedMessage, exception.Message); } } + private static string GetExpectedCursorJsonContent(string cursor) + { + return $"{{\r\n \"value\": \"{cursor}\"\r\n}}"; + } + private static string GetExpectedIndexJsonContent(string version) { return $"{{\r\n \"versions\": [\r\n \"{version}\"\r\n ]\r\n}}"; @@ -808,6 +1089,11 @@ private void FailFirstRequest(string relativeUri) _mockServer.SetAction(relativeUri, failFirst); } + private StringStorageContent CreateStringStorageContent(T value) + { + return new StringStorageContent(JsonConvert.SerializeObject(value, _jsonSettings)); + } + private static MemoryStream CreateZipStreamWithEntry(string name, string content) { var zipWithNoNuspec = new MemoryStream(); @@ -828,6 +1114,14 @@ private static MemoryStream CreateZipStreamWithEntry(string name, string content return zipWithNoNuspec; } + private static byte[] ReadPackageBytes(TestPackage package) + { + using (var reader = new BinaryReader(package.Stream)) + { + return reader.ReadBytes((int)package.Stream.Length); + } + } + private class SynchronizedMemoryStorage : MemoryStorage { protected HashSet SynchronizedUris { get; private set; } diff --git a/tests/NgTests/DnxMakerTests.cs b/tests/CatalogTests/Dnx/DnxMakerTests.cs similarity index 99% rename from tests/NgTests/DnxMakerTests.cs rename to tests/CatalogTests/Dnx/DnxMakerTests.cs index f0dc73792..562264734 100644 --- a/tests/NgTests/DnxMakerTests.cs +++ b/tests/CatalogTests/Dnx/DnxMakerTests.cs @@ -17,7 +17,7 @@ using NuGet.Versioning; using Xunit; -namespace NgTests +namespace CatalogTests.Dnx { public class DnxMakerTests { diff --git a/tests/CatalogTests/Helpers/CatalogPropertiesTests.cs b/tests/CatalogTests/Helpers/CatalogPropertiesTests.cs index 4776459c4..efe15f318 100644 --- a/tests/CatalogTests/Helpers/CatalogPropertiesTests.cs +++ b/tests/CatalogTests/Helpers/CatalogPropertiesTests.cs @@ -2,7 +2,12 @@ // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. using System; +using System.Threading; +using System.Threading.Tasks; +using Moq; +using NuGet.Services.Metadata.Catalog; using NuGet.Services.Metadata.Catalog.Helpers; +using NuGet.Services.Metadata.Catalog.Persistence; using Xunit; namespace CatalogTests.Helpers @@ -31,5 +36,198 @@ public void Constructor_InitializesPropertiesWithNonNullValues() Assert.Equal(lastDeleted, properties.LastDeleted); Assert.Equal(lastEdited, properties.LastEdited); } + + [Fact] + public async Task ReadAsync_ThrowsForNullStorage() + { + var exception = await Assert.ThrowsAsync( + () => CatalogProperties.ReadAsync( + storage: null, + telemetryService: Mock.Of(), + cancellationToken: CancellationToken.None)); + + Assert.Equal("storage", exception.ParamName); + } + + [Fact] + public async Task ReadAsync_ThrowsForNullTelemetryService() + { + var exception = await Assert.ThrowsAsync( + () => CatalogProperties.ReadAsync( + storage: Mock.Of(), + telemetryService: null, + cancellationToken: CancellationToken.None)); + + Assert.Equal("telemetryService", exception.ParamName); + } + + [Fact] + public async Task ReadAsync_ThrowsIfCancelled() + { + await Assert.ThrowsAsync( + () => CatalogProperties.ReadAsync( + Mock.Of(), + Mock.Of(), + new CancellationToken(canceled: true))); + } + + [Fact] + public async Task ReadAsync_ReturnsNullPropertiesIfStorageReturnsNull() + { + var storage = CreateStorageMock(json: null); + + var catalogProperties = await CatalogProperties.ReadAsync( + storage.Object, + Mock.Of(), + CancellationToken.None); + + Assert.NotNull(catalogProperties); + Assert.Null(catalogProperties.LastCreated); + Assert.Null(catalogProperties.LastDeleted); + Assert.Null(catalogProperties.LastEdited); + + storage.Verify(); + } + + [Fact] + public async Task ReadAsync_ReturnsNullPropertiesIfPropertiesMissing() + { + var storage = CreateStorageMock(json: "{}"); + + var catalogProperties = await CatalogProperties.ReadAsync( + storage.Object, + Mock.Of(), + CancellationToken.None); + + Assert.NotNull(catalogProperties); + Assert.Null(catalogProperties.LastCreated); + Assert.Null(catalogProperties.LastDeleted); + Assert.Null(catalogProperties.LastEdited); + + storage.Verify(); + } + + [Fact] + public async Task ReadAsync_ReturnsAllPropertiesIfAllPropertiesSet() + { + var lastCreatedDatetimeOffset = CreateDateTimeOffset(TimeSpan.FromMinutes(-5)); + var lastDeletedDatetimeOffset = CreateDateTimeOffset(TimeSpan.Zero); + var lastEditedDatetimeOffset = CreateDateTimeOffset(TimeSpan.FromMinutes(-3)); + var json = $"{{\"nuget:lastCreated\":\"{(lastCreatedDatetimeOffset.ToString("O"))}\"," + + $"\"nuget:lastDeleted\":\"{(lastDeletedDatetimeOffset.ToString("O"))}\"," + + $"\"nuget:lastEdited\":\"{(lastEditedDatetimeOffset.ToString("O"))}\"}}"; + var storage = CreateStorageMock(json); + + var catalogProperties = await CatalogProperties.ReadAsync( + storage.Object, + Mock.Of(), + CancellationToken.None); + + Assert.NotNull(catalogProperties); + Assert.NotNull(catalogProperties.LastCreated); + Assert.NotNull(catalogProperties.LastDeleted); + Assert.NotNull(catalogProperties.LastEdited); + Assert.Equal(lastCreatedDatetimeOffset, catalogProperties.LastCreated.Value); + Assert.Equal(lastDeletedDatetimeOffset, catalogProperties.LastDeleted.Value); + Assert.Equal(lastEditedDatetimeOffset, catalogProperties.LastEdited.Value); + + storage.Verify(); + } + + [Fact] + public async Task ReadAsync_ReturnsDateTimeWithFractionalHourOffsetInUtc() + { + var lastCreated = CreateDateTimeOffset(new TimeSpan(hours: 5, minutes: 30, seconds: 0)); + var json = CreateCatalogJson("nuget:lastCreated", lastCreated); + + await VerifyPropertyAsync(json, catalogProperties => + { + Assert.NotNull(catalogProperties.LastCreated); + Assert.Equal(lastCreated, catalogProperties.LastCreated.Value); + Assert.Equal(DateTimeKind.Utc, catalogProperties.LastCreated.Value.Kind); + }); + } + + [Fact] + public async Task ReadAsync_ReturnsDateTimeWithPositiveOffsetInUtc() + { + var lastDeleted = CreateDateTimeOffset(TimeSpan.FromHours(1)); + var json = CreateCatalogJson("nuget:lastDeleted", lastDeleted); + + await VerifyPropertyAsync(json, catalogProperties => + { + Assert.NotNull(catalogProperties.LastDeleted); + Assert.Equal(lastDeleted, catalogProperties.LastDeleted.Value); + Assert.Equal(DateTimeKind.Utc, catalogProperties.LastDeleted.Value.Kind); + }); + } + + [Fact] + public async Task ReadAsync_ReturnsDateTimeWithNegativeOffsetInUtc() + { + var lastEdited = CreateDateTimeOffset(TimeSpan.FromHours(-1)); + var json = CreateCatalogJson("nuget:lastEdited", lastEdited); + + await VerifyPropertyAsync(json, catalogProperties => + { + Assert.NotNull(catalogProperties.LastEdited); + Assert.Equal(lastEdited, catalogProperties.LastEdited.Value); + Assert.Equal(DateTimeKind.Utc, catalogProperties.LastEdited.Value.Kind); + }); + } + + [Fact] + public async Task ReadAsync_ReturnUtcDateTimeInUtc() + { + var lastCreated = DateTimeOffset.UtcNow; + var json = CreateCatalogJson("nuget:lastCreated", lastCreated); + + await VerifyPropertyAsync(json, catalogProperties => + { + Assert.NotNull(catalogProperties.LastCreated); + Assert.Equal(lastCreated, catalogProperties.LastCreated.Value); + Assert.Equal(DateTimeKind.Utc, catalogProperties.LastCreated.Value.Kind); + }); + } + + private static string CreateCatalogJson(string propertyName, DateTimeOffset propertyValue) + { + return $"{{\"{propertyName}\":\"{(propertyValue.ToString("O"))}\"}}"; + } + + private static DateTimeOffset CreateDateTimeOffset(TimeSpan offset) + { + var datetime = new DateTime(DateTime.Now.Ticks, DateTimeKind.Unspecified); + + return new DateTimeOffset(datetime, offset); + } + + private static async Task VerifyPropertyAsync(string json, Action propertyVerifier) + { + var storage = CreateStorageMock(json); + + var catalogProperties = await CatalogProperties.ReadAsync( + storage.Object, + Mock.Of(), + CancellationToken.None); + + Assert.NotNull(catalogProperties); + propertyVerifier(catalogProperties); + storage.Verify(); + } + + private static Mock CreateStorageMock(string json) + { + var storage = new Mock(MockBehavior.Strict); + + storage.Setup(x => x.ResolveUri(It.IsNotNull())) + .Returns(new Uri("https://unit.test")) + .Verifiable(); + storage.Setup(x => x.LoadStringAsync(It.IsNotNull(), It.IsAny())) + .ReturnsAsync(json) + .Verifiable(); + + return storage; + } } } \ No newline at end of file diff --git a/tests/CatalogTests/Helpers/FeedHelpersTests.cs b/tests/CatalogTests/Helpers/FeedHelpersTests.cs index 436649398..cd62e64ef 100644 --- a/tests/CatalogTests/Helpers/FeedHelpersTests.cs +++ b/tests/CatalogTests/Helpers/FeedHelpersTests.cs @@ -24,157 +24,6 @@ public class FeedHelpersTests { private const string _baseUri = "http://unit.test"; - [Fact] - public async Task GetCatalogPropertiesAsync_ThrowsForNullStorage() - { - var exception = await Assert.ThrowsAsync( - () => FeedHelpers.GetCatalogPropertiesAsync( - storage: null, - telemetryService: Mock.Of(), - cancellationToken: CancellationToken.None)); - - Assert.Equal("storage", exception.ParamName); - } - - [Fact] - public async Task GetCatalogPropertiesAsync_ThrowsForNullTelemetryService() - { - var exception = await Assert.ThrowsAsync( - () => FeedHelpers.GetCatalogPropertiesAsync( - storage: Mock.Of(), - telemetryService: null, - cancellationToken: CancellationToken.None)); - - Assert.Equal("telemetryService", exception.ParamName); - } - - [Fact] - public async Task GetCatalogPropertiesAsync_ThrowsIfCancelled() - { - await Assert.ThrowsAsync( - () => FeedHelpers.GetCatalogPropertiesAsync( - Mock.Of(), - Mock.Of(), - new CancellationToken(canceled: true))); - } - - [Fact] - public async Task GetCatalogPropertiesAsync_ReturnsNullPropertiesIfStorageReturnsNull() - { - var storage = CreateStorageMock(json: null); - - var catalogProperties = await FeedHelpers.GetCatalogPropertiesAsync( - storage.Object, - Mock.Of(), - CancellationToken.None); - - Assert.NotNull(catalogProperties); - Assert.Null(catalogProperties.LastCreated); - Assert.Null(catalogProperties.LastDeleted); - Assert.Null(catalogProperties.LastEdited); - - storage.Verify(); - } - - [Fact] - public async Task GetCatalogPropertiesAsync_ReturnsNullPropertiesIfPropertiesMissing() - { - var storage = CreateStorageMock(json: "{}"); - - var catalogProperties = await FeedHelpers.GetCatalogPropertiesAsync( - storage.Object, - Mock.Of(), - CancellationToken.None); - - Assert.NotNull(catalogProperties); - Assert.Null(catalogProperties.LastCreated); - Assert.Null(catalogProperties.LastDeleted); - Assert.Null(catalogProperties.LastEdited); - - storage.Verify(); - } - - [Fact] - public async Task GetCatalogPropertiesAsync_ReturnsAllPropertiesIfAllPropertiesSet() - { - var datetimeOffset = CreateDateTimeOffset(TimeSpan.Zero); - var json = $"{{\"nuget:lastCreated\":\"{(datetimeOffset.ToString("O"))}\"," + - $"\"nuget:lastDeleted\":\"{(datetimeOffset.ToString("O"))}\"," + - $"\"nuget:lastEdited\":\"{(datetimeOffset.ToString("O"))}\"}}"; - var storage = CreateStorageMock(json); - - var catalogProperties = await FeedHelpers.GetCatalogPropertiesAsync( - storage.Object, - Mock.Of(), - CancellationToken.None); - - Assert.NotNull(catalogProperties); - Assert.NotNull(catalogProperties.LastCreated); - Assert.NotNull(catalogProperties.LastDeleted); - Assert.NotNull(catalogProperties.LastEdited); - Assert.Equal(datetimeOffset, catalogProperties.LastCreated.Value); - Assert.Equal(datetimeOffset, catalogProperties.LastDeleted.Value); - Assert.Equal(datetimeOffset, catalogProperties.LastEdited.Value); - - storage.Verify(); - } - - [Fact] - public async Task GetCatalogPropertiesAsync_ReturnsDateTimeWithFractionalHourOffsetInUtc() - { - var lastCreated = CreateDateTimeOffset(new TimeSpan(hours: 5, minutes: 30, seconds: 0)); - var json = CreateCatalogJson("nuget:lastCreated", lastCreated); - - await VerifyPropertyAsync(json, catalogProperties => - { - Assert.NotNull(catalogProperties.LastCreated); - Assert.Equal(lastCreated, catalogProperties.LastCreated.Value); - Assert.Equal(DateTimeKind.Utc, catalogProperties.LastCreated.Value.Kind); - }); - } - - [Fact] - public async Task GetCatalogPropertiesAsync_ReturnsDateTimeWithPositiveOffsetInUtc() - { - var lastDeleted = CreateDateTimeOffset(TimeSpan.FromHours(1)); - var json = CreateCatalogJson("nuget:lastDeleted", lastDeleted); - - await VerifyPropertyAsync(json, catalogProperties => - { - Assert.NotNull(catalogProperties.LastDeleted); - Assert.Equal(lastDeleted, catalogProperties.LastDeleted.Value); - Assert.Equal(DateTimeKind.Utc, catalogProperties.LastDeleted.Value.Kind); - }); - } - - [Fact] - public async Task GetCatalogPropertiesAsync_ReturnsDateTimeWithNegativeOffsetInUtc() - { - var lastEdited = CreateDateTimeOffset(TimeSpan.FromHours(-1)); - var json = CreateCatalogJson("nuget:lastEdited", lastEdited); - - await VerifyPropertyAsync(json, catalogProperties => - { - Assert.NotNull(catalogProperties.LastEdited); - Assert.Equal(lastEdited, catalogProperties.LastEdited.Value); - Assert.Equal(DateTimeKind.Utc, catalogProperties.LastEdited.Value.Kind); - }); - } - - [Fact] - public async Task GetCatalogPropertiesAsync_ReturnUtcDateTimeInUtc() - { - var lastCreated = DateTimeOffset.UtcNow; - var json = CreateCatalogJson("nuget:lastCreated", lastCreated); - - await VerifyPropertyAsync(json, catalogProperties => - { - Assert.NotNull(catalogProperties.LastCreated); - Assert.Equal(lastCreated, catalogProperties.LastCreated.Value); - Assert.Equal(DateTimeKind.Utc, catalogProperties.LastCreated.Value.Kind); - }); - } - public static IEnumerable GetPackages_GetsAllPackages_data { get @@ -759,46 +608,6 @@ private static IEnumerable ODataPackages } } - private static string CreateCatalogJson(string propertyName, DateTimeOffset propertyValue) - { - return $"{{\"{propertyName}\":\"{(propertyValue.ToString("O"))}\"}}"; - } - - private static DateTimeOffset CreateDateTimeOffset(TimeSpan offset) - { - var datetime = new DateTime(DateTime.Now.Ticks, DateTimeKind.Unspecified); - - return new DateTimeOffset(datetime, offset); - } - - private static Mock CreateStorageMock(string json) - { - var storage = new Mock(MockBehavior.Strict); - - storage.Setup(x => x.ResolveUri(It.IsNotNull())) - .Returns(new Uri("https://unit.test")) - .Verifiable(); - storage.Setup(x => x.LoadStringAsync(It.IsNotNull(), It.IsAny())) - .ReturnsAsync(json) - .Verifiable(); - - return storage; - } - - private static async Task VerifyPropertyAsync(string json, Action propertyVerifier) - { - var storage = CreateStorageMock(json); - - var catalogProperties = await FeedHelpers.GetCatalogPropertiesAsync( - storage.Object, - Mock.Of(), - CancellationToken.None); - - Assert.NotNull(catalogProperties); - propertyVerifier(catalogProperties); - storage.Verify(); - } - private static NupkgMetadata GetNupkgMetadata(string resourceName) { using (var stream = TestHelper.GetStream(resourceName)) diff --git a/tests/CatalogTests/PackageCatalogItemCreatorTests.cs b/tests/CatalogTests/PackageCatalogItemCreatorTests.cs index 55471bf0d..5c6711aac 100644 --- a/tests/CatalogTests/PackageCatalogItemCreatorTests.cs +++ b/tests/CatalogTests/PackageCatalogItemCreatorTests.cs @@ -3,7 +3,6 @@ using System; using System.Collections.Generic; -using System.IO; using System.Linq; using System.Net; using System.Net.Http; diff --git a/tests/CatalogTests/Registration/RegistrationCollectorTests.cs b/tests/CatalogTests/Registration/RegistrationCollectorTests.cs index faeef394b..3af6904b9 100644 --- a/tests/CatalogTests/Registration/RegistrationCollectorTests.cs +++ b/tests/CatalogTests/Registration/RegistrationCollectorTests.cs @@ -9,6 +9,7 @@ using System.Threading; using System.Threading.Tasks; using CatalogTests.Helpers; +using Microsoft.Extensions.Logging; using Moq; using Newtonsoft.Json; using Newtonsoft.Json.Linq; @@ -77,8 +78,10 @@ private void SharedInit(bool useLegacy, bool useSemVer2, Uri baseUri = null, Uri _legacyStorageFactory, _semVer2StorageFactory, contentBaseUri ?? new Uri("http://tempuri.org/packages"), - new Mock().Object, - handlerFunc: () => _mockServer); + Mock.Of(), + Mock.Of(), + handlerFunc: () => _mockServer, + httpRetryStrategy: new NoRetryStrategy()); RegistrationMakerCatalogItem.PackagePathProvider = new PackagesFolderPackagePathProvider(); } @@ -96,7 +99,8 @@ public void Constructor_WhenMaxConcurrentBatchesIsNotPositive_Throws(int maxConc storageFactory, storageFactory, _baseUri, - new Mock().Object, + Mock.Of(), + Mock.Of(), maxConcurrentBatches: maxConcurrentBatches)); Assert.Equal("maxConcurrentBatches", exception.ParamName); @@ -150,7 +154,7 @@ await Assert.ThrowsAsync( .FirstOrDefault(pair => pair.Key.PathAndQuery.EndsWith("/anotherpackage/1.0.0.json")); Assert.NotNull(anotherPackage100.Key); - Assert.Equal(DateTime.Parse(expectedCursorBeforeRetry).ToUniversalTime(), cursorBeforeRetry); + Assert.Equal(MemoryCursor.MinValue, cursorBeforeRetry); Assert.Equal(DateTime.Parse("2015-10-12T10:08:55.3335317Z").ToUniversalTime(), cursorAfterRetry); } diff --git a/tests/NgTests/Data/Catalogs.cs b/tests/NgTests/Data/Catalogs.cs index 56041e544..695b1d977 100644 --- a/tests/NgTests/Data/Catalogs.cs +++ b/tests/NgTests/Data/Catalogs.cs @@ -186,25 +186,6 @@ public static MemoryStorage CreateTestCatalogWithNonNormalizedDelete() return catalogStorage; } - public static MemoryStorage CreateTestCatalogWithMultipleEntriesWithSamePackageIdentityInSameBatch() - { - var catalogStorage = new MemoryStorage(new Uri("http://nuget.test")); - - catalogStorage.Content.TryAdd( - new Uri(catalogStorage.BaseAddress, "index.json"), - new StringStorageContent(TestCatalogEntries.TestCatalogWithMultipleEntriesWithSamePackageIdentityInSameBatchIndex)); - - catalogStorage.Content.TryAdd( - new Uri(catalogStorage.BaseAddress, "page0.json"), - new StringStorageContent(TestCatalogEntries.TestCatalogWithMultipleEntriesWithSamePackageIdentityInSameBatchPage)); - - catalogStorage.Content.TryAdd( - new Uri(catalogStorage.BaseAddress, "data/2015.10.13.06.40.07/listedpackage.1.0.0.json"), - new StringStorageContent(TestCatalogEntries.TestCatalogWithMultipleEntriesWithSamePackageIdentityInSameBatchListedPackage100)); - - return catalogStorage; - } - public static MemoryStorage CreateTestCatalogWithOnePackage() { var catalogStorage = new MemoryStorage(); diff --git a/tests/NgTests/Data/TestCatalogEntries.Designer.cs b/tests/NgTests/Data/TestCatalogEntries.Designer.cs index 2971298ba..55ffa4abc 100644 --- a/tests/NgTests/Data/TestCatalogEntries.Designer.cs +++ b/tests/NgTests/Data/TestCatalogEntries.Designer.cs @@ -657,80 +657,6 @@ public static string TestCatalogWithCommitThenTwoPackageCommitPage { } } - /// - /// Looks up a localized string similar to { - /// "@id": "http://nuget.test/index.json", - /// "@type": [ - /// "CatalogRoot", - /// "AppendOnlyCatalog", - /// "Permalink" - /// ], - /// "commitId": "afc8c1f4-486e-4142-b3ec-cf5841eb8883", - /// "commitTimeStamp": "2015-10-13T06:40:07.7850657Z", - /// "count": 1, - /// "items": [ - /// { - /// "@id": "http://nuget.test/page0.json", - /// "@type": "CatalogPage", - /// "commitId": "afc8c1f4-486e-4142-b3ec-cf5841eb8883", - /// "commitTimeStamp": "2015-10-13T06:40:07.7850657Z", - /// "count": 2 - /// } - /// ], - /// "nuget:lastC [rest of string was truncated]";. - /// - public static string TestCatalogWithMultipleEntriesWithSamePackageIdentityInSameBatchIndex { - get { - return ResourceManager.GetString("TestCatalogWithMultipleEntriesWithSamePackageIdentityInSameBatchIndex", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to { - /// "@id": "http://nuget.test/data/2015.10.13.06.40.07/listedpackage.1.0.0.json", - /// "@type": [ - /// "PackageDetails", - /// "catalog:Permalink" - /// ], - /// "authors": "NuGet", - /// "catalog:commitId": "afc8c1f4-486e-4142-b3ec-cf5841eb8883", - /// "catalog:commitTimeStamp": "2015-10-13T06:40:07.7850657Z", - /// "created": "2015-01-01T00:00:00Z", - /// "description": "Package description.", - /// "id": "ListedPackage", - /// "isPrerelease": false, - /// "lastEdited": "2015-01-01T00:00:00Z", - /// "licenseNames": "", - /// "licenseReport [rest of string was truncated]";. - /// - public static string TestCatalogWithMultipleEntriesWithSamePackageIdentityInSameBatchListedPackage100 { - get { - return ResourceManager.GetString("TestCatalogWithMultipleEntriesWithSamePackageIdentityInSameBatchListedPackage100", resourceCulture); - } - } - - /// - /// Looks up a localized string similar to { - /// "@id": "http://nuget.test/page0.json", - /// "@type": "CatalogPage", - /// "commitId": "afc8c1f4-486e-4142-b3ec-cf5841eb8883", - /// "commitTimeStamp": "2015-10-13T06:40:07.7850657Z", - /// "count": 2, - /// "items": [ - /// { - /// "@id": "http://nuget.test/data/2015.10.13.06.40.07/listedpackage.1.0.0.json", - /// "@type": "nuget:PackageDetails", - /// "commitId": "afc8c1f4-486e-4142-b3ec-cf5841eb8883", - /// "commitTimeStamp": "2015-10-13T06:40:07.7850657Z", - /// "nuget:id": "ListedPackage", - /// "nuget:vers [rest of string was truncated]";. - /// - public static string TestCatalogWithMultipleEntriesWithSamePackageIdentityInSameBatchPage { - get { - return ResourceManager.GetString("TestCatalogWithMultipleEntriesWithSamePackageIdentityInSameBatchPage", resourceCulture); - } - } - /// /// Looks up a localized string similar to { /// "@id": "http://tempuri.org/index.json", diff --git a/tests/NgTests/Data/TestCatalogEntries.resx b/tests/NgTests/Data/TestCatalogEntries.resx index 9351db962..b3935355d 100644 --- a/tests/NgTests/Data/TestCatalogEntries.resx +++ b/tests/NgTests/Data/TestCatalogEntries.resx @@ -1541,169 +1541,6 @@ "@type": "http://www.w3.org/2001/XMLSchema#dateTime" } } -} - - - { - "@id": "http://nuget.test/index.json", - "@type": [ - "CatalogRoot", - "AppendOnlyCatalog", - "Permalink" - ], - "commitId": "afc8c1f4-486e-4142-b3ec-cf5841eb8883", - "commitTimeStamp": "2015-10-13T06:40:07.7850657Z", - "count": 1, - "items": [ - { - "@id": "http://nuget.test/page0.json", - "@type": "CatalogPage", - "commitId": "afc8c1f4-486e-4142-b3ec-cf5841eb8883", - "commitTimeStamp": "2015-10-13T06:40:07.7850657Z", - "count": 2 - } - ], - "nuget:lastCreated": "2015-01-01T00:00:00Z", - "nuget:lastDeleted": "2015-01-01T01:01:01.0748028Z", - "nuget:lastEdited": "2015-01-01T01:01:01.0748028Z", - "@context": { - "@vocab": "http://schema.nuget.org/catalog#", - "nuget": "http://schema.nuget.org/schema#", - "items": { - "@id": "item", - "@container": "@set" - }, - "parent": { - "@type": "@id" - }, - "commitTimeStamp": { - "@type": "http://www.w3.org/2001/XMLSchema#dateTime" - }, - "nuget:lastCreated": { - "@type": "http://www.w3.org/2001/XMLSchema#dateTime" - }, - "nuget:lastEdited": { - "@type": "http://www.w3.org/2001/XMLSchema#dateTime" - }, - "nuget:lastDeleted": { - "@type": "http://www.w3.org/2001/XMLSchema#dateTime" - } - } -} - - - { - "@id": "http://nuget.test/data/2015.10.13.06.40.07/listedpackage.1.0.0.json", - "@type": [ - "PackageDetails", - "catalog:Permalink" - ], - "authors": "NuGet", - "catalog:commitId": "afc8c1f4-486e-4142-b3ec-cf5841eb8883", - "catalog:commitTimeStamp": "2015-10-13T06:40:07.7850657Z", - "created": "2015-01-01T00:00:00Z", - "description": "Package description.", - "id": "ListedPackage", - "isPrerelease": false, - "lastEdited": "2015-01-01T00:00:00Z", - "licenseNames": "", - "licenseReportUrl": "", - "listed": true, - "packageHash": "EpTkeONwnhX59JBzl5QfuFNNgZADaAbwYxNGn0KEkJ4ylukUQFcS15vISqFUnrWy/+yylox6L6QT3MD/+Us+vg==", - "packageHashAlgorithm": "SHA512", - "packageSize": 2529, - "published": "2015-01-01T00:00:00Z", - "requireLicenseAcceptance": false, - "verbatimVersion": "1.0.0", - "version": "1.0.0", - "@context": { - "@vocab": "http://schema.nuget.org/schema#", - "catalog": "http://schema.nuget.org/catalog#", - "xsd": "http://www.w3.org/2001/XMLSchema#", - "dependencies": { - "@id": "dependency", - "@container": "@set" - }, - "dependencyGroups": { - "@id": "dependencyGroup", - "@container": "@set" - }, - "packageEntries": { - "@id": "packageEntry", - "@container": "@set" - }, - "supportedFrameworks": { - "@id": "supportedFramework", - "@container": "@set" - }, - "tags": { - "@id": "tag", - "@container": "@set" - }, - "published": { - "@type": "xsd:dateTime" - }, - "created": { - "@type": "xsd:dateTime" - }, - "lastEdited": { - "@type": "xsd:dateTime" - }, - "catalog:commitTimeStamp": { - "@type": "xsd:dateTime" - } - } -} - - - { - "@id": "http://nuget.test/page0.json", - "@type": "CatalogPage", - "commitId": "afc8c1f4-486e-4142-b3ec-cf5841eb8883", - "commitTimeStamp": "2015-10-13T06:40:07.7850657Z", - "count": 2, - "items": [ - { - "@id": "http://nuget.test/data/2015.10.13.06.40.07/listedpackage.1.0.0.json", - "@type": "nuget:PackageDetails", - "commitId": "afc8c1f4-486e-4142-b3ec-cf5841eb8883", - "commitTimeStamp": "2015-10-13T06:40:07.7850657Z", - "nuget:id": "ListedPackage", - "nuget:version": "1.0.0" - }, - { - "@id": "http://nuget.test/data/2015.10.13.06.40.07/listedpackage.1.0.0.json", - "@type": "nuget:PackageDetails", - "commitId": "afc8c1f4-486e-4142-b3ec-cf5841eb8883", - "commitTimeStamp": "2015-10-13T06:40:07.7850657Z", - "nuget:id": "ListedPackage", - "nuget:version": "1.0.0" - } - ], - "parent": "http://nuget.test/index.json", - "@context": { - "@vocab": "http://schema.nuget.org/catalog#", - "nuget": "http://schema.nuget.org/schema#", - "items": { - "@id": "item", - "@container": "@set" - }, - "parent": { - "@type": "@id" - }, - "commitTimeStamp": { - "@type": "http://www.w3.org/2001/XMLSchema#dateTime" - }, - "nuget:lastCreated": { - "@type": "http://www.w3.org/2001/XMLSchema#dateTime" - }, - "nuget:lastEdited": { - "@type": "http://www.w3.org/2001/XMLSchema#dateTime" - }, - "nuget:lastDeleted": { - "@type": "http://www.w3.org/2001/XMLSchema#dateTime" - } - } } diff --git a/tests/NgTests/Feed2CatalogTests.cs b/tests/NgTests/Feed2CatalogTests.cs index d1faffeee..55d60cb0c 100644 --- a/tests/NgTests/Feed2CatalogTests.cs +++ b/tests/NgTests/Feed2CatalogTests.cs @@ -1552,7 +1552,7 @@ private TestPackage AddPackageEntry(TestPackage package) } } - return new TestPackage(package.Id, package.Version, package.Author, package.Description, stream); + return new TestPackage(package.Id, package.Version, package.Author, package.Description, package.Nuspec, stream); } private static JObject ReadJsonWithoutDateTimeHandling(JObject jObject) diff --git a/tests/NgTests/Infrastructure/MockTelemetryService.cs b/tests/NgTests/Infrastructure/MockTelemetryService.cs index f01ca6093..982b2b13d 100644 --- a/tests/NgTests/Infrastructure/MockTelemetryService.cs +++ b/tests/NgTests/Infrastructure/MockTelemetryService.cs @@ -12,16 +12,15 @@ namespace NgTests.Infrastructure { public sealed class MockTelemetryService : ITelemetryService { - public IDictionary GlobalDimensions => throw new NotImplementedException(); + private readonly List _trackDurationCalls = new List(); + private readonly List _trackMetricCalls = new List(); + private readonly object _durationCallsSyncObject = new object(); + private readonly object _metricCallsSyncObject = new object(); - public List TrackDurationCalls { get; } - public List TrackMetricCalls { get; } + public IDictionary GlobalDimensions => throw new NotImplementedException(); - public MockTelemetryService() - { - TrackDurationCalls = new List(); - TrackMetricCalls = new List(); - } + public IReadOnlyList TrackDurationCalls => _trackDurationCalls; + public IReadOnlyList TrackMetricCalls => _trackMetricCalls; public void TrackCatalogIndexReadDuration(TimeSpan duration, Uri uri) { @@ -62,14 +61,20 @@ public void TrackPackageHashFixed(string packageId, NuGetVersion packageVersion) public DurationMetric TrackDuration(string name, IDictionary properties = null) { - TrackDurationCalls.Add(new TelemetryCall(name, properties)); + lock (_durationCallsSyncObject) + { + _trackDurationCalls.Add(new TelemetryCall(name, properties)); + } return new DurationMetric(Mock.Of(), name, properties); } public void TrackMetric(string name, ulong metric, IDictionary properties = null) { - TrackMetricCalls.Add(new TrackMetricCall(name, metric, properties)); + lock (_metricCallsSyncObject) + { + _trackMetricCalls.Add(new TrackMetricCall(name, metric, properties)); + } } } } \ No newline at end of file diff --git a/tests/NgTests/Infrastructure/NoRetryStrategy.cs b/tests/NgTests/Infrastructure/NoRetryStrategy.cs new file mode 100644 index 000000000..78f1c6b91 --- /dev/null +++ b/tests/NgTests/Infrastructure/NoRetryStrategy.cs @@ -0,0 +1,22 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using System.Net.Http; +using System.Threading; +using System.Threading.Tasks; +using NuGet.Services.Metadata.Catalog; + +namespace NgTests.Infrastructure +{ + /// + /// Simple no-retry passthrough to avoid the full default exponential retry strategy in unit tests. + /// + public sealed class NoRetryStrategy : IHttpRetryStrategy + { + public Task SendAsync(HttpClient client, Uri address, CancellationToken cancellationToken) + { + return client.GetAsync(address, cancellationToken); + } + } +} \ No newline at end of file diff --git a/tests/NgTests/Infrastructure/TestPackage.cs b/tests/NgTests/Infrastructure/TestPackage.cs index e4f647761..70e8270ab 100644 --- a/tests/NgTests/Infrastructure/TestPackage.cs +++ b/tests/NgTests/Infrastructure/TestPackage.cs @@ -9,22 +9,24 @@ namespace NgTests.Infrastructure { - internal sealed class TestPackage : IDisposable + public sealed class TestPackage : IDisposable { private bool _isDisposed; - internal string Id { get; } - internal NuGetVersion Version { get; } - internal string Author { get; } - internal string Description { get; } - internal Stream Stream { get; private set; } + public string Id { get; } + public NuGetVersion Version { get; } + public string Author { get; } + public string Description { get; } + public string Nuspec { get; } + public Stream Stream { get; } - internal TestPackage(string id, NuGetVersion version, string author, string description, Stream stream) + public TestPackage(string id, NuGetVersion version, string author, string description, string nuspec, Stream stream) { Id = id; Version = version; Author = author; Description = description; + Nuspec = nuspec; Stream = stream; } @@ -40,7 +42,7 @@ public void Dispose() } } - internal static TestPackage Create(Random random) + public static TestPackage Create(Random random) { var id = TestUtility.CreateRandomAlphanumericString(random); var version = CreateRandomVersion(random); @@ -52,7 +54,7 @@ internal static TestPackage Create(Random random) { var stream = CreatePackageStream(id, nuspec, rng, random); - return new TestPackage(id, version, author, description, stream); + return new TestPackage(id, version, author, description, nuspec, stream); } } @@ -103,6 +105,8 @@ private static MemoryStream CreatePackageStream(string id, string nuspec, Random } } + stream.Position = 0; + return stream; } diff --git a/tests/NgTests/Infrastructure/TestUtility.cs b/tests/NgTests/Infrastructure/TestUtility.cs index 752978d1e..b90767456 100644 --- a/tests/NgTests/Infrastructure/TestUtility.cs +++ b/tests/NgTests/Infrastructure/TestUtility.cs @@ -3,6 +3,9 @@ using System; using System.Linq; +using Newtonsoft.Json.Linq; +using NuGet.Packaging.Core; +using NuGet.Services.Metadata.Catalog; namespace NgTests.Infrastructure { @@ -24,5 +27,56 @@ public static string CreateRandomAlphanumericString(Random random) .Select(s => s[random.Next(s.Length)]) .ToArray()); } + + public static JObject CreateCatalogContextJObject() + { + return new JObject( + new JProperty(CatalogConstants.VocabKeyword, CatalogConstants.NuGetSchemaUri), + new JProperty(CatalogConstants.NuGet, CatalogConstants.NuGetSchemaUri), + new JProperty(CatalogConstants.Items, + new JObject( + new JProperty(CatalogConstants.IdKeyword, CatalogConstants.Item), + new JProperty(CatalogConstants.ContainerKeyword, CatalogConstants.SetKeyword))), + new JProperty(CatalogConstants.Parent, + new JObject( + new JProperty(CatalogConstants.TypeKeyword, CatalogConstants.IdKeyword))), + new JProperty(CatalogConstants.CommitTimeStamp, + new JObject( + new JProperty(CatalogConstants.TypeKeyword, CatalogConstants.XsdDateTime))), + new JProperty(CatalogConstants.NuGetLastCreated, + new JObject( + new JProperty(CatalogConstants.TypeKeyword, CatalogConstants.XsdDateTime))), + new JProperty(CatalogConstants.NuGetLastEdited, + new JObject( + new JProperty(CatalogConstants.TypeKeyword, CatalogConstants.XsdDateTime))), + new JProperty(CatalogConstants.NuGetLastDeleted, + new JObject( + new JProperty(CatalogConstants.TypeKeyword, CatalogConstants.XsdDateTime)))); + } + + public static JObject CreateCatalogCommitItemJObject( + DateTime commitTimeStamp, + PackageIdentity packageIdentity, + string commitId = null) + { + return new JObject( + new JProperty(CatalogConstants.IdKeyword, $"https://nuget.test/{packageIdentity.Id}"), + new JProperty(CatalogConstants.TypeKeyword, CatalogConstants.NuGetPackageDetails), + new JProperty(CatalogConstants.CommitTimeStamp, commitTimeStamp.ToString("O")), + new JProperty(CatalogConstants.CommitId, commitId ?? Guid.NewGuid().ToString()), + new JProperty(CatalogConstants.NuGetId, packageIdentity.Id), + new JProperty(CatalogConstants.NuGetVersion, packageIdentity.Version.ToNormalizedString())); + } + + public static CatalogCommitItem CreateCatalogCommitItem( + DateTime commitTimeStamp, + PackageIdentity packageIdentity, + string commitId = null) + { + var context = CreateCatalogContextJObject(); + var commitItem = CreateCatalogCommitItemJObject(commitTimeStamp, packageIdentity, commitId); + + return CatalogCommitItem.Create(context, commitItem); + } } } \ No newline at end of file diff --git a/tests/NgTests/NgTests.csproj b/tests/NgTests/NgTests.csproj index f6b18e238..5b24520b9 100644 --- a/tests/NgTests/NgTests.csproj +++ b/tests/NgTests/NgTests.csproj @@ -63,13 +63,12 @@ True TestRegistrationEntries.resx - - + diff --git a/tests/NgTests/PackageFixup/FixPackageHashHandlerFacts.cs b/tests/NgTests/PackageFixup/FixPackageHashHandlerFacts.cs index 48174a863..145ec7be3 100644 --- a/tests/NgTests/PackageFixup/FixPackageHashHandlerFacts.cs +++ b/tests/NgTests/PackageFixup/FixPackageHashHandlerFacts.cs @@ -9,9 +9,9 @@ using System.Threading.Tasks; using Microsoft.Extensions.Logging; using Microsoft.WindowsAzure.Storage; -using Microsoft.WindowsAzure.Storage.Blob; using Moq; using NgTests.Infrastructure; +using NuGet.Packaging.Core; using NuGet.Services.Metadata.Catalog; using NuGet.Services.Metadata.Catalog.Persistence; using NuGet.Versioning; @@ -21,8 +21,7 @@ namespace NgTests.PackageFixup { public class FixPackageHashHandlerFacts { - private const string PackageId = "TestUnsigned"; - private static readonly NuGetVersion PackageVersion = new NuGetVersion("1.0.0"); + private static readonly PackageIdentity PackageIdentity = new PackageIdentity("TestUnsigned", new NuGetVersion("1.0.0")); private readonly CatalogIndexEntry _packageEntry; private readonly Mock _blob; @@ -46,8 +45,7 @@ public FixPackageHashHandlerFacts() "nuget:PackageDetails", "123", DateTime.UtcNow, - PackageId, - PackageVersion); + PackageIdentity); _blob = new Mock(); _blob.Setup(b => b.Uri).Returns(new Uri("http://localhost/packages/testunsigned.1.0.0.nupkg")); @@ -70,8 +68,8 @@ public async Task SkipsPackagesThatAlreadyHaveAHash() // Assert _blob.Verify(b => b.FetchAttributesAsync(It.IsAny()), Times.Once); - _telemetryService.Verify(t => t.TrackPackageAlreadyHasHash(PackageId, PackageVersion), Times.Once); - _telemetryService.Verify(t => t.TrackPackageHashFixed(PackageId, PackageVersion), Times.Never); + _telemetryService.Verify(t => t.TrackPackageAlreadyHasHash(PackageIdentity.Id, PackageIdentity.Version), Times.Once); + _telemetryService.Verify(t => t.TrackPackageHashFixed(PackageIdentity.Id, PackageIdentity.Version), Times.Never); } [Fact] @@ -98,8 +96,8 @@ public async Task AddsHashIfPackageIsMissingHash() null), Times.Once); - _telemetryService.Verify(t => t.TrackPackageAlreadyHasHash(PackageId, PackageVersion), Times.Never); - _telemetryService.Verify(t => t.TrackPackageHashFixed(PackageId, PackageVersion), Times.Once); + _telemetryService.Verify(t => t.TrackPackageAlreadyHasHash(PackageIdentity.Id, PackageIdentity.Version), Times.Never); + _telemetryService.Verify(t => t.TrackPackageHashFixed(PackageIdentity.Id, PackageIdentity.Version), Times.Once); } } -} +} \ No newline at end of file diff --git a/tests/NgTests/PackageFixup/PackagesContainerCatalogProcessorFacts.cs b/tests/NgTests/PackageFixup/PackagesContainerCatalogProcessorFacts.cs index 7688301a6..b9dc67666 100644 --- a/tests/NgTests/PackageFixup/PackagesContainerCatalogProcessorFacts.cs +++ b/tests/NgTests/PackageFixup/PackagesContainerCatalogProcessorFacts.cs @@ -11,6 +11,7 @@ using Microsoft.WindowsAzure.Storage; using Microsoft.WindowsAzure.Storage.Blob; using Moq; +using NuGet.Packaging.Core; using NuGet.Services.Metadata.Catalog; using NuGet.Services.Metadata.Catalog.Persistence; using NuGet.Versioning; @@ -20,8 +21,7 @@ namespace NgTests.PackageFixup { public class PackagesContainerCatalogProcessorFacts { - private const string PackageId = "TestPackage"; - private static readonly NuGetVersion PackageVersion = new NuGetVersion("1.0.0"); + private static readonly PackageIdentity PackageIdentity = new PackageIdentity("TestPackage", new NuGetVersion("1.0.0")); private readonly CatalogIndexEntry _catalogEntry; private readonly Mock _rawBlob; @@ -41,8 +41,7 @@ public PackagesContainerCatalogProcessorFacts() "nuget:PackageDetails", "123", DateTime.UtcNow, - PackageId, - PackageVersion); + PackageIdentity); _handler = new Mock(); _telemetryService = new Mock(); diff --git a/tests/NgTests/PackageFixup/ValidatePackageHashHandlerFacts.cs b/tests/NgTests/PackageFixup/ValidatePackageHashHandlerFacts.cs index ff1f683cc..27d7284ed 100644 --- a/tests/NgTests/PackageFixup/ValidatePackageHashHandlerFacts.cs +++ b/tests/NgTests/PackageFixup/ValidatePackageHashHandlerFacts.cs @@ -8,9 +8,9 @@ using System.Threading; using System.Threading.Tasks; using Microsoft.Extensions.Logging; -using Microsoft.WindowsAzure.Storage.Blob; using Moq; using NgTests.Infrastructure; +using NuGet.Packaging.Core; using NuGet.Services.Metadata.Catalog; using NuGet.Services.Metadata.Catalog.Persistence; using NuGet.Versioning; @@ -20,8 +20,7 @@ namespace NgTests.PackageFixup { public class ValidatePackageHashHandlerFacts { - private const string PackageId = "TestUnsigned"; - private static readonly NuGetVersion PackageVersion = new NuGetVersion("1.0.0"); + private static readonly PackageIdentity PackageIdentity = new PackageIdentity("TestUnsigned", new NuGetVersion("1.0.0")); private readonly CatalogIndexEntry _packageEntry; private readonly Mock _blob; @@ -45,8 +44,7 @@ public ValidatePackageHashHandlerFacts() "nuget:PackageDetails", "123", DateTime.UtcNow, - PackageId, - PackageVersion); + PackageIdentity); _blob = new Mock(); _blob.Setup(b => b.Uri).Returns(new Uri("http://localhost/packages/testunsigned.1.0.0.nupkg")); @@ -69,8 +67,8 @@ public async Task ReportsPackagesThatAreMissingAHash() // Assert _blob.Verify(b => b.FetchAttributesAsync(It.IsAny()), Times.Once); - _telemetryService.Verify(t => t.TrackPackageMissingHash(PackageId, PackageVersion), Times.Once); - _telemetryService.Verify(t => t.TrackPackageHasIncorrectHash(PackageId, PackageVersion), Times.Never); + _telemetryService.Verify(t => t.TrackPackageMissingHash(PackageIdentity.Id, PackageIdentity.Version), Times.Once); + _telemetryService.Verify(t => t.TrackPackageHasIncorrectHash(PackageIdentity.Id, PackageIdentity.Version), Times.Never); } [Fact] @@ -84,8 +82,8 @@ public async Task ReportsPackagesWithIncorrectHash() // Assert _blob.Verify(b => b.FetchAttributesAsync(It.IsAny()), Times.Once); - _telemetryService.Verify(t => t.TrackPackageMissingHash(PackageId, PackageVersion), Times.Never); - _telemetryService.Verify(t => t.TrackPackageHasIncorrectHash(PackageId, PackageVersion), Times.Once); + _telemetryService.Verify(t => t.TrackPackageMissingHash(PackageIdentity.Id, PackageIdentity.Version), Times.Never); + _telemetryService.Verify(t => t.TrackPackageHasIncorrectHash(PackageIdentity.Id, PackageIdentity.Version), Times.Once); } [Fact] @@ -99,8 +97,8 @@ public async Task ReportsNothingIfPackageHasCorrectHash() // Assert _blob.Verify(b => b.FetchAttributesAsync(It.IsAny()), Times.Once); - _telemetryService.Verify(t => t.TrackPackageMissingHash(PackageId, PackageVersion), Times.Never); - _telemetryService.Verify(t => t.TrackPackageHasIncorrectHash(PackageId, PackageVersion), Times.Never); + _telemetryService.Verify(t => t.TrackPackageMissingHash(PackageIdentity.Id, PackageIdentity.Version), Times.Never); + _telemetryService.Verify(t => t.TrackPackageHasIncorrectHash(PackageIdentity.Id, PackageIdentity.Version), Times.Never); } } } diff --git a/tests/NgTests/PackageMonitoringStatusServiceTests.cs b/tests/NgTests/PackageMonitoringStatusServiceTests.cs index 9db1ff76d..c08e25a0c 100644 --- a/tests/NgTests/PackageMonitoringStatusServiceTests.cs +++ b/tests/NgTests/PackageMonitoringStatusServiceTests.cs @@ -123,7 +123,10 @@ private static CatalogIndexEntry CreateCatalogIndexEntry(string id, string versi { return new CatalogIndexEntry( new UriBuilder() { Path = $"{id.ToLowerInvariant()}/{id.ToLowerInvariant()}.{version.ToLowerInvariant()}" }.Uri, - "nuget:PackageDetails", Guid.NewGuid().ToString(), DateTime.UtcNow, id, new NuGetVersion(version)); + CatalogConstants.NuGetPackageDetails, + Guid.NewGuid().ToString(), + DateTime.UtcNow, + new PackageIdentity(id, new NuGetVersion(version))); } private static DeletionAuditEntry CreateDeletionAuditEntry(string id, string version) diff --git a/tests/NgTests/PackageTimestampMetadataTests.cs b/tests/NgTests/PackageTimestampMetadataTests.cs index da94288bd..72014a753 100644 --- a/tests/NgTests/PackageTimestampMetadataTests.cs +++ b/tests/NgTests/PackageTimestampMetadataTests.cs @@ -4,12 +4,12 @@ using System; using System.Collections.Generic; using System.Globalization; -using System.Linq; using System.Net; using System.Net.Http; using System.Threading.Tasks; using NgTests.Data; using NgTests.Infrastructure; +using NuGet.Packaging.Core; using NuGet.Services.Metadata.Catalog; using NuGet.Services.Metadata.Catalog.Monitoring; using NuGet.Versioning; @@ -107,8 +107,7 @@ public async Task FromCatalogEntry_HandlesCreatedLastEdited() CatalogConstants.NuGetPackageDetails, "9a37734f-1960-4c07-8934-c8bc797e35c1", commitTimeStamp1, - "ListedPackage", - new NuGetVersion("1.0.0"))), + new PackageIdentity("ListedPackage", new NuGetVersion("1.0.0")))), PackageTimestampMetadata.FromCatalogEntry( client, new CatalogIndexEntry( @@ -116,8 +115,7 @@ public async Task FromCatalogEntry_HandlesCreatedLastEdited() CatalogConstants.NuGetPackageDetails, "9a37734f-1960-4c07-8934-c8bc797e35c1", commitTimeStamp1, - "UnlistedPackage", - new NuGetVersion("1.0.0"))), + new PackageIdentity("UnlistedPackage", new NuGetVersion("1.0.0")))), PackageTimestampMetadata.FromCatalogEntry( client, new CatalogIndexEntry( @@ -125,8 +123,7 @@ public async Task FromCatalogEntry_HandlesCreatedLastEdited() CatalogConstants.NuGetPackageDetails, "8a9e7694-73d4-4775-9b7a-20aa59b9773e", commitTimeStamp2, - "ListedPackage", - new NuGetVersion("1.0.1"))), + new PackageIdentity("ListedPackage", new NuGetVersion("1.0.1")))) }; // Act @@ -162,8 +159,7 @@ public async Task FromCatalogEntry_HandlesDeleted_NotNull() CatalogConstants.CommitTimeStampFormat, DateTimeFormatInfo.CurrentInfo, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal), - "OtherPackage", - new NuGetVersion("1.0.0")); + new PackageIdentity("OtherPackage", new NuGetVersion("1.0.0"))); // Act var entry = await PackageTimestampMetadata.FromCatalogEntry(client, catalogIndexEntry); diff --git a/tests/NgTests/SearchIndexFromCatalogCollectorTests.cs b/tests/NgTests/SearchIndexFromCatalogCollectorTests.cs index 187e6cb70..3cfbd9d31 100644 --- a/tests/NgTests/SearchIndexFromCatalogCollectorTests.cs +++ b/tests/NgTests/SearchIndexFromCatalogCollectorTests.cs @@ -2,7 +2,6 @@ // Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. using System; -using System.Collections.Generic; using System.IO; using System.Linq; using System.Net; @@ -15,7 +14,6 @@ using Ng.Jobs; using NgTests.Data; using NgTests.Infrastructure; -using NuGet.Services.Logging; using NuGet.Services.Metadata.Catalog; using Xunit; using Constants = NuGet.IndexingTests.TestSupport.Constants; @@ -53,8 +51,6 @@ public async Task DoesNotSkipPackagesWhenExceptionOccurs(string catalogUri, stri MemoryCursor.MinValue); ReadCursor back = MemoryCursor.CreateMax(); - var commitTimeout = TimeSpan.FromSeconds(1); - var telemetryService = new Mock(); var indexCommitDurationMetric = new Mock(); telemetryService.Setup(t => t.TrackIndexCommitDuration()).Returns(indexCommitDurationMetric.Object); @@ -68,11 +64,12 @@ public async Task DoesNotSkipPackagesWhenExceptionOccurs(string catalogUri, stri new Uri("http://tempuri.org/index.json"), indexWriter, commitEachBatch: true, - commitTimeout: commitTimeout, + commitTimeout: Timeout.InfiniteTimeSpan, baseAddress: null, telemetryService: telemetryService.Object, logger: new TestLogger(), - handlerFunc: () => mockServer); + handlerFunc: () => mockServer, + httpRetryStrategy: new NoRetryStrategy()); // Act await Assert.ThrowsAsync(() => target.RunAsync(front, back, CancellationToken.None)); @@ -160,7 +157,8 @@ public async Task ThrowsIfCommitTimesOut() baseAddress: null, telemetryService: telemetryService.Object, logger: new TestLogger(), - handlerFunc: () => mockServer); + handlerFunc: () => mockServer, + httpRetryStrategy: new NoRetryStrategy()); // Act & Assert await Assert.ThrowsAsync(() => target.RunAsync(front, back, CancellationToken.None)); diff --git a/tests/NgTests/SortingIdVersionCollectorTests.cs b/tests/NgTests/SortingIdVersionCollectorTests.cs index 8db71735b..71f9ac00f 100644 --- a/tests/NgTests/SortingIdVersionCollectorTests.cs +++ b/tests/NgTests/SortingIdVersionCollectorTests.cs @@ -7,8 +7,11 @@ using System.Threading.Tasks; using Moq; using Newtonsoft.Json.Linq; +using NgTests.Infrastructure; +using NuGet.Packaging.Core; using NuGet.Services.Metadata.Catalog; using NuGet.Services.Metadata.Catalog.Helpers; +using NuGet.Versioning; using Xunit; namespace NgTests @@ -22,7 +25,7 @@ public static IEnumerable BatchesData // Different id, same version yield return new object[] { - new List + new List { CreatePackage("test1", "1.0.0"), CreatePackage("test2", "1.0.0"), @@ -34,7 +37,7 @@ public static IEnumerable BatchesData // Same id, different version yield return new object[] { - new List + new List { CreatePackage("test1", "1.0.0"), CreatePackage("test1", "2.0.0"), @@ -46,7 +49,7 @@ public static IEnumerable BatchesData // Same id, same version yield return new object[] { - new List + new List { CreatePackage("test1", "1.0.0"), CreatePackage("test1", "1.0.0"), @@ -59,7 +62,7 @@ public static IEnumerable BatchesData [Theory] [MemberData(nameof(BatchesData))] - public async Task OnProcessBatch_BatchesCorrectly(IEnumerable items) + public async Task OnProcessBatch_BatchesCorrectly(IEnumerable items) { // Arrange var collectorMock = new Mock() @@ -70,8 +73,8 @@ public async Task OnProcessBatch_BatchesCorrectly(IEnumerable items) var seenPackages = new List(); collectorMock - .Setup(x => x.OverridableProcessSortedBatch(It.IsAny>>())) - .Returns>>( + .Setup(x => x.OverridableProcessSortedBatch(It.IsAny>>())) + .Returns>>( (pair) => { // Assert @@ -91,33 +94,33 @@ public async Task OnProcessBatch_BatchesCorrectly(IEnumerable items) var result = await collectorMock.Object.OnProcessBatchAsync(items); } - private static JToken CreatePackage(string id, string version) + private static CatalogCommitItem CreatePackage(string id, string version) { - return new JObject - { - { "nuget:id", id }, - { "nuget:version", version } - }; + var context = TestUtility.CreateCatalogContextJObject(); + var packageIdentity = new PackageIdentity(id, new NuGetVersion(version)); + var commitItem = TestUtility.CreateCatalogCommitItemJObject(DateTime.UtcNow, packageIdentity); + + return CatalogCommitItem.Create(context, commitItem); } public class TestableSortingIdVersionCollector : SortingIdVersionCollector { public TestableSortingIdVersionCollector() : base( - new Uri("https://www.microsoft.com"), - new Mock().Object, - null) + new Uri("https://nuget.test"), + Mock.Of(), + handlerFunc: null) { } - public Task OnProcessBatchAsync(IEnumerable items) + public Task OnProcessBatchAsync(IEnumerable items) { return base.OnProcessBatchAsync(null, items, null, DateTime.MinValue, false, CancellationToken.None); } protected override Task ProcessSortedBatchAsync( CollectorHttpClient client, - KeyValuePair> sortedBatch, + KeyValuePair> sortedBatch, JToken context, CancellationToken cancellationToken) { @@ -125,7 +128,7 @@ protected override Task ProcessSortedBatchAsync( } public virtual Task OverridableProcessSortedBatch( - KeyValuePair> sortedBatch) + KeyValuePair> sortedBatch) { return Task.FromResult(0); } diff --git a/tests/NgTests/Validation/CatalogAggregateValidatorFacts.cs b/tests/NgTests/Validation/CatalogAggregateValidatorFacts.cs index f53fe87b8..24201a1dc 100644 --- a/tests/NgTests/Validation/CatalogAggregateValidatorFacts.cs +++ b/tests/NgTests/Validation/CatalogAggregateValidatorFacts.cs @@ -190,8 +190,7 @@ private static ValidationContext CreateContext(CollectorHttpClient client, DateT CatalogConstants.NuGetPackageDetails, Guid.NewGuid().ToString(), commitTimeStamp, - _packageIdentity.Id, - _packageIdentity.Version) + _packageIdentity) }; return new ValidationContext( diff --git a/tests/NgTests/Validation/PackageHasSignatureValidatorFacts.cs b/tests/NgTests/Validation/PackageHasSignatureValidatorFacts.cs index 3da2fc742..880b3b2d7 100644 --- a/tests/NgTests/Validation/PackageHasSignatureValidatorFacts.cs +++ b/tests/NgTests/Validation/PackageHasSignatureValidatorFacts.cs @@ -96,7 +96,7 @@ public void SkipsIfNoEntries() public void SkipsIfLatestEntryIsDelete() { var target = CreateTarget(); - var uri = new Uri($"https://nuget.test/{PackageId}"); + var uri = new Uri($"https://nuget.test/{PackageIdentity.Id}"); var context = CreateValidationContext( catalogEntries: new[] { @@ -105,15 +105,13 @@ public void SkipsIfLatestEntryIsDelete() type: CatalogConstants.NuGetPackageDetails, commitId: Guid.NewGuid().ToString(), commitTs: DateTime.MinValue, - id: PackageId, - version: PackageNuGetVersion), + packageIdentity: PackageIdentity), new CatalogIndexEntry( uri, type: CatalogConstants.NuGetPackageDelete, commitId: Guid.NewGuid().ToString(), commitTs: DateTime.MinValue.AddDays(1), - id: PackageId, - version: PackageNuGetVersion), + packageIdentity: PackageIdentity), }); Assert.False(target.ShouldRunValidator(context)); @@ -123,7 +121,7 @@ public void SkipsIfLatestEntryIsDelete() public void RunsIfLatestEntryIsntDelete() { var target = CreateTarget(); - var uri = new Uri($"https://nuget.test/{PackageId}"); + var uri = new Uri($"https://nuget.test/{PackageIdentity.Id}"); var context = CreateValidationContext( catalogEntries: new[] { @@ -132,15 +130,13 @@ public void RunsIfLatestEntryIsntDelete() type: CatalogConstants.NuGetPackageDelete, commitId: Guid.NewGuid().ToString(), commitTs: DateTime.MinValue, - id: PackageId, - version: PackageNuGetVersion), + packageIdentity: PackageIdentity), new CatalogIndexEntry( uri, type: CatalogConstants.NuGetPackageDetails, commitId: Guid.NewGuid().ToString(), commitTs: DateTime.MinValue.AddDays(1), - id: PackageId, - version: PackageNuGetVersion), + packageIdentity: PackageIdentity), }); Assert.True(target.ShouldRunValidator(context)); @@ -162,15 +158,13 @@ public async Task ReturnsGracefullyIfLatestLeafHasSignatureFile() type: CatalogConstants.NuGetPackageDetails, commitId: Guid.NewGuid().ToString(), commitTs: DateTime.MinValue, - id: PackageId, - version: PackageNuGetVersion), + packageIdentity: PackageIdentity), new CatalogIndexEntry( uri: new Uri("https://nuget.test/b.json"), type: CatalogConstants.NuGetPackageDetails, commitId: Guid.NewGuid().ToString(), commitTs: DateTime.MinValue.AddDays(1), - id: PackageId, - version: PackageNuGetVersion), + packageIdentity: PackageIdentity), }); AddCatalogLeaf("/a.json", new CatalogLeaf @@ -209,15 +203,13 @@ public async Task ThrowsIfLatestLeafIsMissingASignatureFile() type: CatalogConstants.NuGetPackageDetails, commitId: Guid.NewGuid().ToString(), commitTs: DateTime.MinValue, - id: PackageId, - version: PackageNuGetVersion), + packageIdentity: PackageIdentity), new CatalogIndexEntry( uri: malformedUri, type: CatalogConstants.NuGetPackageDetails, commitId: Guid.NewGuid().ToString(), commitTs: DateTime.MinValue.AddDays(1), - id: PackageId, - version: PackageNuGetVersion), + packageIdentity: PackageIdentity), }); AddCatalogLeaf("/a.json", new CatalogLeaf @@ -257,8 +249,7 @@ public async Task ThrowsIfLeafPackageEntriesIsMissing() type: CatalogConstants.NuGetPackageDetails, commitId: Guid.NewGuid().ToString(), commitTs: DateTime.MinValue, - id: PackageId, - version: PackageNuGetVersion), + packageIdentity: PackageIdentity), }); AddCatalogLeaf("/a.json", "{ 'this': 'is missing the packageEntries field' }"); @@ -284,8 +275,7 @@ public async Task ThrowsIfLeafPackageEntriesIsMalformed() type: CatalogConstants.NuGetPackageDetails, commitId: Guid.NewGuid().ToString(), commitTs: DateTime.MinValue, - id: PackageId, - version: PackageNuGetVersion), + packageIdentity: PackageIdentity), }); AddCatalogLeaf("/a.json", "{ 'packageEntries': 'malformed'}"); @@ -299,10 +289,7 @@ public async Task ThrowsIfLeafPackageEntriesIsMalformed() public class FactsBase { - public const string PackageId = "TestPackage"; - public const string PackageVersion = "1.0.0"; - - public static readonly NuGetVersion PackageNuGetVersion = NuGetVersion.Parse(PackageVersion); + public static readonly PackageIdentity PackageIdentity = new PackageIdentity("TestPackage", NuGetVersion.Parse("1.0.0")); protected readonly Mock> _logger; private readonly MockServerHttpClientHandler _mockServer; @@ -320,7 +307,7 @@ protected ValidationContext CreateValidationContext(IEnumerable _catalogEntries; @@ -205,8 +203,7 @@ public FactsBase() CatalogConstants.NuGetPackageDetails, Guid.NewGuid().ToString(), DateTime.UtcNow, - PackageId, - PackageNuGetVersion) + PackageIdentity) }; AddCatalogLeafToMockServer("/catalog/leaf.json", new CatalogLeaf @@ -252,7 +249,7 @@ protected ValidationContext CreateValidationContext(string packageResource = nul var httpClient = new CollectorHttpClient(_mockServer); return new ValidationContext( - new PackageIdentity(PackageId, PackageNuGetVersion), + PackageIdentity, _catalogEntries, new DeletionAuditEntry[0], httpClient, diff --git a/tests/NgTests/Validation/PackageValidatorContextTests.cs b/tests/NgTests/Validation/PackageValidatorContextTests.cs index c60b0b347..83083e29a 100644 --- a/tests/NgTests/Validation/PackageValidatorContextTests.cs +++ b/tests/NgTests/Validation/PackageValidatorContextTests.cs @@ -3,6 +3,7 @@ using System; using System.Linq; +using NuGet.Packaging.Core; using NuGet.Services.Metadata.Catalog; using NuGet.Services.Metadata.Catalog.Helpers; using NuGet.Services.Metadata.Catalog.Monitoring; @@ -47,8 +48,7 @@ public void Constructor_WhenArgumentsAreValid_InitializesInstance() CatalogConstants.NuGetPackageDetails, Guid.NewGuid().ToString(), DateTime.UtcNow, - "a", - new NuGetVersion("1.0.0")) + new PackageIdentity(id: "a", version: new NuGetVersion("1.0.0"))) }; var context = new PackageValidatorContext(_package, catalogEntries); diff --git a/tests/NuGet.Protocol.Catalog.Tests/CatalogClientFacts.cs b/tests/NuGet.Protocol.Catalog.Tests/CatalogClientFacts.cs new file mode 100644 index 000000000..77dc9f655 --- /dev/null +++ b/tests/NuGet.Protocol.Catalog.Tests/CatalogClientFacts.cs @@ -0,0 +1,131 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using System.Net.Http; +using System.Threading.Tasks; +using Microsoft.Extensions.Logging.Abstractions; +using Xunit; + +namespace NuGet.Protocol.Catalog +{ + public class CatalogClientFacts + { + public class GetIndexAsync + { + [Fact] + public async Task WorksWithNuGetOrgSnapshot() + { + // Arrange + using (var httpClient = new HttpClient(new TestDataHttpMessageHandler())) + { + var client = new CatalogClient(httpClient, new NullLogger()); + + // Act + var actual = await client.GetIndexAsync(TestData.CatalogIndexUrl); + + // Assert + Assert.NotNull(actual); + Assert.NotEqual(default(DateTimeOffset), actual.CommitTimestamp); + Assert.NotEqual(0, actual.Count); + Assert.NotEmpty(actual.Items); + } + } + } + + public class GetPageAsync + { + [Fact] + public async Task WorksWithNuGetOrgSnapshot() + { + // Arrange + using (var httpClient = new HttpClient(new TestDataHttpMessageHandler())) + { + var client = new CatalogClient(httpClient, new NullLogger()); + + // Act + var actual = await client.GetPageAsync(TestData.CatalogPageUrl); + + // Assert + Assert.NotNull(actual); + Assert.NotEqual(default(DateTimeOffset), actual.CommitTimestamp); + Assert.NotEqual(0, actual.Count); + Assert.NotEmpty(actual.Items); + } + } + } + + public class GetPackageDeleteLeafAsync + { + [Fact] + public async Task WorksWithNuGetOrgSnapshot() + { + // Arrange + using (var httpClient = new HttpClient(new TestDataHttpMessageHandler())) + { + var client = new CatalogClient(httpClient, new NullLogger()); + + // Act + var actual = await client.GetPackageDeleteLeafAsync(TestData.PackageDeleteCatalogLeafUrl); + + // Assert + Assert.NotNull(actual); + } + } + } + + public class GetPackageDetailsLeafAsync + { + [Fact] + public async Task WorksWithNuGetOrgSnapshot() + { + // Arrange + using (var httpClient = new HttpClient(new TestDataHttpMessageHandler())) + { + var client = new CatalogClient(httpClient, new NullLogger()); + + // Act + var actual = await client.GetPackageDetailsLeafAsync(TestData.PackageDetailsCatalogLeafUrl); + + // Assert + Assert.NotNull(actual); + } + } + } + + public class GetLeafAsync + { + [Fact] + public async Task WorksWithNuGetOrgPackageDeleteSnapshot() + { + // Arrange + using (var httpClient = new HttpClient(new TestDataHttpMessageHandler())) + { + var client = new CatalogClient(httpClient, new NullLogger()); + + // Act + var actual = await client.GetLeafAsync(TestData.PackageDeleteCatalogLeafUrl); + + // Assert + Assert.NotNull(actual); + } + } + + [Fact] + public async Task WorksWithNuGetOrgPackageDetailsSnapshot() + { + // Arrange + using (var httpClient = new HttpClient(new TestDataHttpMessageHandler())) + { + var client = new CatalogClient(httpClient, new NullLogger()); + + // Act + var actual = await client.GetLeafAsync(TestData.PackageDetailsCatalogLeafUrl); + + // Assert + Assert.NotNull(actual); + } + } + } + } +} diff --git a/tests/NuGet.Protocol.Catalog.Tests/CatalogProcessorSettingsFacts.cs b/tests/NuGet.Protocol.Catalog.Tests/CatalogProcessorSettingsFacts.cs new file mode 100644 index 000000000..1e2ca7ea8 --- /dev/null +++ b/tests/NuGet.Protocol.Catalog.Tests/CatalogProcessorSettingsFacts.cs @@ -0,0 +1,58 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using FluentAssertions; +using Xunit; + +namespace NuGet.Protocol.Catalog +{ + public class CatalogProcessorSettingsFacts + { + public class Constructor + { + [Fact] + public void HasUnchangingDefaults() + { + // Arrange + var expected = new CatalogProcessorSettings + { + ServiceIndexUrl = "https://api.nuget.org/v3/index.json", + DefaultMinCommitTimestamp = null, + MinCommitTimestamp = DateTimeOffset.MinValue, + MaxCommitTimestamp = DateTimeOffset.MaxValue, + ExcludeRedundantLeaves = true, + }; + + // Act + var actual = new CatalogProcessorSettings(); + + // Assert + actual.Should().BeEquivalentTo(expected); + } + } + + public class Clone + { + [Fact] + public void CopiesAllProperties() + { + // Arrange + var expected = new CatalogProcessorSettings + { + ServiceIndexUrl = "https://example/v3/index.json", + DefaultMinCommitTimestamp = new DateTimeOffset(2017, 11, 8, 13, 50, 44, TimeSpan.Zero), + MinCommitTimestamp = new DateTimeOffset(2010, 1, 1, 0, 0, 0, TimeSpan.Zero), + MaxCommitTimestamp = new DateTimeOffset(2020, 1, 1, 0, 0, 0, TimeSpan.Zero), + ExcludeRedundantLeaves = true, + }; + + // Act + var actual = expected.Clone(); + + // Assert + actual.Should().BeEquivalentTo(expected); + } + } + } +} diff --git a/tests/NuGet.Protocol.Catalog.Tests/NuGet.Protocol.Catalog.Tests.csproj b/tests/NuGet.Protocol.Catalog.Tests/NuGet.Protocol.Catalog.Tests.csproj new file mode 100644 index 000000000..4c7c6ff1d --- /dev/null +++ b/tests/NuGet.Protocol.Catalog.Tests/NuGet.Protocol.Catalog.Tests.csproj @@ -0,0 +1,87 @@ + + + + + Debug + AnyCPU + {1F3BC053-796C-4A35-88F4-955A0F142197} + Library + Properties + NuGet.Protocol.Catalog + NuGet.Protocol.Catalog.Tests + v4.6.2 + 512 + true + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + True + True + TestData.resx + + + + + + ResXFileCodeGenerator + TestData.Designer.cs + + + + + 5.5.0 + + + 2.0.0 + + + 2.4.1 + + + 2.4.1 + runtime; build; native; contentfiles; analyzers + all + + + + + {d44c2e89-2d98-44bd-8712-8ccbe4e67c9c} + NuGet.Protocol.Catalog + + + + + + ..\..\build + $(BUILD_SOURCESDIRECTORY)\build + $(NuGetBuildPath) + none + + + \ No newline at end of file diff --git a/tests/NuGet.Protocol.Catalog.Tests/Properties/AssemblyInfo.cs b/tests/NuGet.Protocol.Catalog.Tests/Properties/AssemblyInfo.cs new file mode 100644 index 000000000..0110b11e2 --- /dev/null +++ b/tests/NuGet.Protocol.Catalog.Tests/Properties/AssemblyInfo.cs @@ -0,0 +1,9 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System.Reflection; +using System.Runtime.InteropServices; + +[assembly: AssemblyTitle("NuGet.Protocol.Catalog.Tests")] +[assembly: ComVisible(false)] +[assembly: Guid("1f3bc053-796c-4a35-88f4-955a0f142197")] diff --git a/tests/NuGet.Protocol.Catalog.Tests/TestData.Designer.cs b/tests/NuGet.Protocol.Catalog.Tests/TestData.Designer.cs new file mode 100644 index 000000000..ca2ee4c76 --- /dev/null +++ b/tests/NuGet.Protocol.Catalog.Tests/TestData.Designer.cs @@ -0,0 +1,159 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.42000 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace NuGet.Protocol.Catalog { + using System; + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "15.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class TestData { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal TestData() { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("NuGet.Protocol.Catalog.TestData", typeof(TestData).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + + /// + /// Looks up a localized string similar to {"@id":"https://api.nuget.org/v3/catalog0/index.json","@type":["CatalogRoot","AppendOnlyCatalog","Permalink"],"commitId":"57de6c98-d4c6-4a24-95b9-1829c5013985","commitTimeStamp":"2017-11-06T19:30:56.0421411Z","count":2945,"nuget:lastCreated":"2017-11-06T19:30:30.19Z","nuget:lastDeleted":"2017-11-06T19:27:45.3684766Z","nuget:lastEdited":"2017-11-06T19:02:37.87Z","items":[{"@id":"https://api.nuget.org/v3/catalog0/page0.json","@type":"CatalogPage","commitId":"00000000-0000-0000-0000-000000000000","commitTimeSt [rest of string was truncated]";. + /// + internal static string CatalogIndex { + get { + return ResourceManager.GetString("CatalogIndex", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to https://api.nuget.org/v3/catalog0/index.json. + /// + internal static string CatalogIndexUrl { + get { + return ResourceManager.GetString("CatalogIndexUrl", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to {"@id":"https://api.nuget.org/v3/catalog0/page2944.json","@type":"CatalogPage","commitId":"f241ce46-35ba-44c2-bd72-790eb44539a5","commitTimeStamp":"2017-11-06T22:07:49.3270578Z","count":218,"parent":"https://api.nuget.org/v3/catalog0/index.json","items":[{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.22.07.49/dotnettency.container.1.3.2.json","@type":"nuget:PackageDetails","commitId":"f241ce46-35ba-44c2-bd72-790eb44539a5","commitTimeStamp":"2017-11-06T22:07:49.3270578Z","nuget:id":"Dotnettency.Co [rest of string was truncated]";. + /// + internal static string CatalogPage { + get { + return ResourceManager.GetString("CatalogPage", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to https://api.nuget.org/v3/catalog0/page2944.json. + /// + internal static string CatalogPageUrl { + get { + return ResourceManager.GetString("CatalogPageUrl", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to { + /// "@id": "https://api.nuget.org/v3/catalog0/data/2017.11.06.19.29.03/microsoft.azure.iot.edge.function.0.3.0.json", + /// "@type": [ + /// "PackageDelete", + /// "catalog:Permalink" + /// ], + /// "catalog:commitId": "b429c4e3-5127-4430-9cc8-74927c9c3886", + /// "catalog:commitTimeStamp": "2017-11-06T19:29:03.6198426Z", + /// "id": "Microsoft.Azure.IoT.Edge.Function", + /// "originalId": "Microsoft.Azure.IoT.Edge.Function", + /// "published": "2017-11-06T19:27:45.3684766Z", + /// "version": "0.3.0", + /// "@context": { + /// "@vocab" [rest of string was truncated]";. + /// + internal static string PackageDeleteCatalogLeaf { + get { + return ResourceManager.GetString("PackageDeleteCatalogLeaf", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to https://api.nuget.org/v3/catalog0/data/2017.11.06.19.29.03/microsoft.azure.iot.edge.function.0.3.0.json. + /// + internal static string PackageDeleteCatalogLeafUrl { + get { + return ResourceManager.GetString("PackageDeleteCatalogLeafUrl", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to { + /// "@id": "https://api.nuget.org/v3/catalog0/data/2017.11.06.22.07.49/dotnettency.container.1.3.2.json", + /// "@type": [ + /// "PackageDetails", + /// "catalog:Permalink" + /// ], + /// "authors": "Darrell Tunnell", + /// "catalog:commitId": "f241ce46-35ba-44c2-bd72-790eb44539a5", + /// "catalog:commitTimeStamp": "2017-11-06T22:07:49.3270578Z", + /// "created": "2017-11-06T22:06:53.64Z", + /// "description": "Container support, for the dotnettency Mutlitenancy library for dotnet standard compatible applications.", + /// "id": "Do [rest of string was truncated]";. + /// + internal static string PackageDetailsCatalogLeaf { + get { + return ResourceManager.GetString("PackageDetailsCatalogLeaf", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to https://api.nuget.org/v3/catalog0/data/2017.11.06.22.07.49/dotnettency.container.1.3.2.json. + /// + internal static string PackageDetailsCatalogLeafUrl { + get { + return ResourceManager.GetString("PackageDetailsCatalogLeafUrl", resourceCulture); + } + } + } +} diff --git a/tests/NuGet.Protocol.Catalog.Tests/TestData.resx b/tests/NuGet.Protocol.Catalog.Tests/TestData.resx new file mode 100644 index 000000000..783666fb0 --- /dev/null +++ b/tests/NuGet.Protocol.Catalog.Tests/TestData.resx @@ -0,0 +1,293 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + {"@id":"https://api.nuget.org/v3/catalog0/index.json","@type":["CatalogRoot","AppendOnlyCatalog","Permalink"],"commitId":"57de6c98-d4c6-4a24-95b9-1829c5013985","commitTimeStamp":"2017-11-06T19:30:56.0421411Z","count":2945,"nuget:lastCreated":"2017-11-06T19:30:30.19Z","nuget:lastDeleted":"2017-11-06T19:27:45.3684766Z","nuget:lastEdited":"2017-11-06T19:02:37.87Z","items":[{"@id":"https://api.nuget.org/v3/catalog0/page0.json","@type":"CatalogPage","commitId":"00000000-0000-0000-0000-000000000000","commitTimeStamp":"2015-02-01T06:30:11.7477681Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page1.json","@type":"CatalogPage","commitId":"8bcd3cbf-74f0-47a2-a7ae-b7ecc50005d3","commitTimeStamp":"2015-02-01T06:39:53.9553899Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page2.json","@type":"CatalogPage","commitId":"ddbb307f-3af3-4276-aac8-04577b703a09","commitTimeStamp":"2015-02-01T06:49:12.657797Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page3.json","@type":"CatalogPage","commitId":"3a94eead-7619-46b6-a502-13d7a21d9a97","commitTimeStamp":"2015-02-01T06:58:47.9532886Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page4.json","@type":"CatalogPage","commitId":"70e23de0-2243-457a-99fc-d099eb291a01","commitTimeStamp":"2015-02-01T07:06:41.27878Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page5.json","@type":"CatalogPage","commitId":"22e1f6ed-d412-421e-b476-1b24ee2b7b23","commitTimeStamp":"2015-02-01T07:15:44.5527543Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page6.json","@type":"CatalogPage","commitId":"423a2cbb-f351-4e47-bb51-08fe58c4ca55","commitTimeStamp":"2015-02-01T07:24:24.5537913Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page7.json","@type":"CatalogPage","commitId":"3f38b04c-d916-42c8-9128-dd2421c0a757","commitTimeStamp":"2015-02-01T07:33:28.9218723Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page8.json","@type":"CatalogPage","commitId":"05aa7e6c-cb25-4e09-8456-cc263f0c4906","commitTimeStamp":"2015-02-01T07:44:56.5453045Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page9.json","@type":"CatalogPage","commitId":"45a09c71-e639-4ab0-81de-0ac51deef6ea","commitTimeStamp":"2015-02-01T07:55:34.5170706Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page10.json","@type":"CatalogPage","commitId":"3c9bc582-e047-47a5-a9ee-86a371d75f09","commitTimeStamp":"2015-02-01T08:06:59.4261022Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page11.json","@type":"CatalogPage","commitId":"9f4ff8fd-9548-4af7-838f-a7ecf5bfb556","commitTimeStamp":"2015-02-01T08:16:46.9598079Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page12.json","@type":"CatalogPage","commitId":"63b2fbe9-421d-4f11-90ed-b8a7f90867e9","commitTimeStamp":"2015-02-01T08:25:48.4826012Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page13.json","@type":"CatalogPage","commitId":"0349c096-be04-4029-8def-8951be2ce273","commitTimeStamp":"2015-02-01T08:34:32.1791916Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page14.json","@type":"CatalogPage","commitId":"5ac82009-c506-452b-9ec0-4a23dfd0a139","commitTimeStamp":"2015-02-01T08:45:48.746707Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page15.json","@type":"CatalogPage","commitId":"8c7373fc-7b60-4ff6-8f37-59b73b80fd18","commitTimeStamp":"2015-02-01T08:57:40.9795454Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page16.json","@type":"CatalogPage","commitId":"6d0b5e8a-74d8-405a-88af-7f1039c840e8","commitTimeStamp":"2015-02-01T09:09:07.2925344Z","count":538},{"@id":"https://api.nuget.org/v3/catalog0/page17.json","@type":"CatalogPage","commitId":"c62fd0a9-6e6b-449d-bdd1-dace8cec99e9","commitTimeStamp":"2015-02-01T09:19:49.2760414Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page18.json","@type":"CatalogPage","commitId":"7ca5e615-ee03-4910-9f0d-f08a927245e3","commitTimeStamp":"2015-02-01T09:29:14.1153342Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page19.json","@type":"CatalogPage","commitId":"cd0f1fd5-1223-4012-88c1-831113f3a169","commitTimeStamp":"2015-02-01T09:40:53.9605425Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page20.json","@type":"CatalogPage","commitId":"af25c51f-86e6-49ac-b2f3-9d4adace3d7e","commitTimeStamp":"2015-02-01T09:52:22.37016Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page21.json","@type":"CatalogPage","commitId":"208041aa-69d5-4337-a912-70018127a7aa","commitTimeStamp":"2015-02-01T10:03:44.2881321Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page22.json","@type":"CatalogPage","commitId":"6c666678-e587-4175-90c1-c4709cbc763e","commitTimeStamp":"2015-02-01T10:14:45.9340251Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page23.json","@type":"CatalogPage","commitId":"1d833774-98ae-42d0-bcc7-3853d124502c","commitTimeStamp":"2015-02-01T10:24:21.3347999Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page24.json","@type":"CatalogPage","commitId":"8822d5b8-4a13-4cef-b4be-7a92d13bfc6c","commitTimeStamp":"2015-02-01T10:33:58.5576357Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page25.json","@type":"CatalogPage","commitId":"61f3c9a8-2882-4a82-8a9c-852f661e3196","commitTimeStamp":"2015-02-01T10:47:12.2353585Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page26.json","@type":"CatalogPage","commitId":"00000000-0000-0000-0000-000000000000","commitTimeStamp":"2015-02-01T10:59:39.9767757Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page27.json","@type":"CatalogPage","commitId":"374719f9-9fcb-4a32-b6d5-1903b7429779","commitTimeStamp":"2015-02-01T11:11:41.9083539Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page28.json","@type":"CatalogPage","commitId":"00000000-0000-0000-0000-000000000000","commitTimeStamp":"2015-02-01T11:23:46.8866726Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page29.json","@type":"CatalogPage","commitId":"00000000-0000-0000-0000-000000000000","commitTimeStamp":"2015-02-01T11:36:32.0153363Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page30.json","@type":"CatalogPage","commitId":"00000000-0000-0000-0000-000000000000","commitTimeStamp":"2015-02-01T11:50:04.0835313Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page31.json","@type":"CatalogPage","commitId":"2368da8c-3cce-4047-ae87-b1d98796ad5c","commitTimeStamp":"2015-02-01T12:04:17.1858358Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page32.json","@type":"CatalogPage","commitId":"41aac087-19e0-437e-9351-9b00b25d908d","commitTimeStamp":"2015-02-01T12:17:37.875788Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page33.json","@type":"CatalogPage","commitId":"50ed5ede-350a-4a9b-ab32-75b7e47ee3ab","commitTimeStamp":"2015-02-01T12:29:24.2922228Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page34.json","@type":"CatalogPage","commitId":"1aa1a28c-02ef-4199-abc4-3a8e4c784bed","commitTimeStamp":"2015-02-01T12:42:19.7685797Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page35.json","@type":"CatalogPage","commitId":"713d0893-d2db-489d-85f6-66bb596ca47b","commitTimeStamp":"2015-02-01T12:55:14.5891123Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page36.json","@type":"CatalogPage","commitId":"706e235b-697b-47df-bfe3-426f404aae7d","commitTimeStamp":"2015-02-01T13:09:37.5912977Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page37.json","@type":"CatalogPage","commitId":"ff434d2b-65d7-4782-9647-bec32c09919e","commitTimeStamp":"2015-02-01T13:22:42.37873Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page38.json","@type":"CatalogPage","commitId":"87df4d1a-8ff0-4d14-ae8d-0552347432a1","commitTimeStamp":"2015-02-01T13:36:18.2070162Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page39.json","@type":"CatalogPage","commitId":"42a6223a-07e5-4a25-a6e9-2e12b1e2e207","commitTimeStamp":"2015-02-01T13:51:36.3122739Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page40.json","@type":"CatalogPage","commitId":"59306216-d615-4761-b988-a63b6c743b52","commitTimeStamp":"2015-02-01T14:09:28.4658122Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page41.json","@type":"CatalogPage","commitId":"b58d261c-8e0c-4975-8dcf-aac9f49ce62b","commitTimeStamp":"2015-02-01T14:24:13.0080426Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page42.json","@type":"CatalogPage","commitId":"65223762-fadb-4f3e-9274-75ddfcb83d57","commitTimeStamp":"2015-02-01T14:36:58.257618Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page43.json","@type":"CatalogPage","commitId":"64141e21-f84d-4de9-89a5-97b62c11c7cf","commitTimeStamp":"2015-02-01T14:49:42.0549582Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page44.json","@type":"CatalogPage","commitId":"3d9b2986-c6ff-4424-8bc3-ca1900936778","commitTimeStamp":"2015-02-01T14:59:57.7507026Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page45.json","@type":"CatalogPage","commitId":"36236c75-18e0-4c3e-a9af-8530a2b6c57f","commitTimeStamp":"2015-02-01T15:10:59.9949458Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page46.json","@type":"CatalogPage","commitId":"1fb47e91-0c15-4923-bbdb-f4409ce9711a","commitTimeStamp":"2015-02-01T15:22:00.3374688Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page47.json","@type":"CatalogPage","commitId":"3322b67f-3f69-478e-9748-9dccda26e402","commitTimeStamp":"2015-02-01T15:33:31.066306Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page48.json","@type":"CatalogPage","commitId":"2eccdd85-478f-4f94-91a9-fceea438ee50","commitTimeStamp":"2015-02-01T15:42:30.511083Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page49.json","@type":"CatalogPage","commitId":"2221d26b-d88c-48e3-b499-d3e6e7ae3e2b","commitTimeStamp":"2015-02-01T15:53:02.7064394Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page50.json","@type":"CatalogPage","commitId":"b1aafd12-fd2f-4c2b-90d5-e6fbeb8155d2","commitTimeStamp":"2015-02-01T16:02:27.4600574Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page51.json","@type":"CatalogPage","commitId":"4c6c96a0-943a-4690-8f7f-31d7911ade99","commitTimeStamp":"2015-02-01T16:12:15.0932073Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page52.json","@type":"CatalogPage","commitId":"81f13753-572e-49e9-b562-485490a1e411","commitTimeStamp":"2015-02-01T16:23:31.9565114Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page53.json","@type":"CatalogPage","commitId":"9f7ea3ba-2e7c-4f19-91b5-cb8b96e91722","commitTimeStamp":"2015-02-01T16:35:52.255371Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page54.json","@type":"CatalogPage","commitId":"1709d3d1-eafe-4f17-ab1d-1064b9429dda","commitTimeStamp":"2015-02-01T16:45:45.1969707Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page55.json","@type":"CatalogPage","commitId":"bc46f62d-be80-404b-a187-cbdfe36fd191","commitTimeStamp":"2015-02-01T16:56:12.5296174Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page56.json","@type":"CatalogPage","commitId":"0d1b243b-d89b-4c8d-a224-80668d011736","commitTimeStamp":"2015-02-01T17:04:49.5292388Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page57.json","@type":"CatalogPage","commitId":"c8fbe871-b4e6-45d7-a57d-997f08d39856","commitTimeStamp":"2015-02-01T17:14:59.4311843Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page58.json","@type":"CatalogPage","commitId":"1bd226b0-3e96-4cc0-8bfc-f5300e8971a7","commitTimeStamp":"2015-02-01T17:23:13.5134632Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page59.json","@type":"CatalogPage","commitId":"e6e57dac-bccd-4490-b568-93dd8e5ea88d","commitTimeStamp":"2015-02-01T17:32:13.4643225Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page60.json","@type":"CatalogPage","commitId":"6cc7f91b-39ee-4601-85a1-ca5089b33398","commitTimeStamp":"2015-02-01T17:42:40.4785527Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page61.json","@type":"CatalogPage","commitId":"e33f7f03-1139-447a-b1ea-7d4890891af4","commitTimeStamp":"2015-02-01T17:52:30.6040221Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page62.json","@type":"CatalogPage","commitId":"06556814-7bf9-4f6b-a135-8eb89a9a6d02","commitTimeStamp":"2015-02-01T18:03:33.4269221Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page63.json","@type":"CatalogPage","commitId":"d0aae0b5-e1db-4c4b-a70d-32fa5fe6b66b","commitTimeStamp":"2015-02-01T18:14:38.5468392Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page64.json","@type":"CatalogPage","commitId":"7f63aef4-c070-40f9-aeea-efe335b9a70b","commitTimeStamp":"2015-02-01T18:24:22.9539508Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page65.json","@type":"CatalogPage","commitId":"c6aec5da-de41-4ba9-8d66-d92535b837b9","commitTimeStamp":"2015-02-01T18:35:34.5126267Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page66.json","@type":"CatalogPage","commitId":"e1010281-13e6-45b5-96c8-fe14e5856a30","commitTimeStamp":"2015-02-01T18:45:23.8838705Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page67.json","@type":"CatalogPage","commitId":"ea2dec9d-6cdd-40d8-9eb1-53e661f2691e","commitTimeStamp":"2015-02-01T18:54:51.0719205Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page68.json","@type":"CatalogPage","commitId":"2c23cf67-042c-4856-b4c0-07c4ad1b3d02","commitTimeStamp":"2015-02-01T19:04:05.631379Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page69.json","@type":"CatalogPage","commitId":"8b4e129b-91af-4ccf-b2c8-01baaaadeb5a","commitTimeStamp":"2015-02-01T19:13:40.7380254Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page70.json","@type":"CatalogPage","commitId":"1f067c71-588c-4cb9-a0d5-396bcc1967f0","commitTimeStamp":"2015-02-01T19:23:23.0899995Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page71.json","@type":"CatalogPage","commitId":"de892af7-b8b5-41e5-b1f2-3586911ba2fa","commitTimeStamp":"2015-02-01T19:32:41.5655623Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page72.json","@type":"CatalogPage","commitId":"b111741c-3c76-4464-8498-af09ff8f2d94","commitTimeStamp":"2015-02-01T19:42:35.3657516Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page73.json","@type":"CatalogPage","commitId":"77a9fab4-1548-4a22-94fd-11ae24c54df6","commitTimeStamp":"2015-02-01T19:51:07.1240824Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page74.json","@type":"CatalogPage","commitId":"a0b60ec3-daf3-4bfe-ae4c-d71ef3011d18","commitTimeStamp":"2015-02-01T19:59:49.5855713Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page75.json","@type":"CatalogPage","commitId":"a37f2f5a-93e5-4d42-a992-cc574e6918a9","commitTimeStamp":"2015-02-01T20:09:44.1205988Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page76.json","@type":"CatalogPage","commitId":"74ddd0f8-87e8-49b0-9717-836df6c7094c","commitTimeStamp":"2015-02-01T20:18:47.7259607Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page77.json","@type":"CatalogPage","commitId":"5e53c415-62f2-4b66-862c-adbcd49a56e6","commitTimeStamp":"2015-02-01T20:29:39.9656468Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page78.json","@type":"CatalogPage","commitId":"17e02540-597b-4ac8-826c-5fc77a630a4d","commitTimeStamp":"2015-02-01T20:39:45.6941861Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page79.json","@type":"CatalogPage","commitId":"61c0a706-52a5-4600-a717-503f1972ce8b","commitTimeStamp":"2015-02-01T20:50:07.4771322Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page80.json","@type":"CatalogPage","commitId":"11a16607-7f9c-4535-b00d-c64e2f4e7902","commitTimeStamp":"2015-02-01T21:00:38.2511381Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page81.json","@type":"CatalogPage","commitId":"6d7fc22a-501e-4598-a2db-bc564a29d4a9","commitTimeStamp":"2015-02-01T21:10:11.1474898Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page82.json","@type":"CatalogPage","commitId":"283008a7-73e1-4c3f-9883-31841b6eb2cd","commitTimeStamp":"2015-02-01T21:20:16.4171015Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page83.json","@type":"CatalogPage","commitId":"4b11594c-1403-4600-b45f-dc1b5a438a7f","commitTimeStamp":"2015-02-01T21:30:43.1700766Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page84.json","@type":"CatalogPage","commitId":"16281542-79b5-4441-8f00-e7fac41631b8","commitTimeStamp":"2015-02-01T21:40:47.5178853Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page85.json","@type":"CatalogPage","commitId":"b6158ba6-d55a-46e2-8e79-30d471d7847d","commitTimeStamp":"2015-02-01T21:51:09.6196783Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page86.json","@type":"CatalogPage","commitId":"855a4fe6-426d-4343-bf06-a721c57c82dc","commitTimeStamp":"2015-02-01T22:00:51.7235773Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page87.json","@type":"CatalogPage","commitId":"ae7e3524-2688-4a28-9a4f-287d41378f39","commitTimeStamp":"2015-02-01T22:11:31.7570831Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page88.json","@type":"CatalogPage","commitId":"17b3632b-926c-4342-924d-59f45b633e4c","commitTimeStamp":"2015-02-01T22:21:14.6222101Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page89.json","@type":"CatalogPage","commitId":"84dcd0ee-9eb9-4d7d-a3de-da6fd366f0f4","commitTimeStamp":"2015-02-01T22:29:30.0345687Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page90.json","@type":"CatalogPage","commitId":"ec636145-ef1a-4c09-ac6f-d1d83b56c1ad","commitTimeStamp":"2015-02-01T22:38:57.2785352Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page91.json","@type":"CatalogPage","commitId":"4048c43f-12a1-4ba7-af3f-c2292c35f1a3","commitTimeStamp":"2015-02-01T22:47:56.2574265Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page92.json","@type":"CatalogPage","commitId":"1315e98b-abc7-4218-bd9a-39c0940576ef","commitTimeStamp":"2015-02-01T22:57:09.7321264Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page93.json","@type":"CatalogPage","commitId":"043906aa-a0bf-45e5-bb56-8dfcf7c6ca5c","commitTimeStamp":"2015-02-01T23:05:39.065951Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page94.json","@type":"CatalogPage","commitId":"b2923428-959a-4d4b-9099-d4cffe914c48","commitTimeStamp":"2015-02-01T23:15:57.3993091Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page95.json","@type":"CatalogPage","commitId":"5f9ade8b-342d-46e8-a416-681bb0648d40","commitTimeStamp":"2015-02-01T23:24:56.1168725Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page96.json","@type":"CatalogPage","commitId":"1746bdf7-cbcc-489c-a415-9db45094436f","commitTimeStamp":"2015-02-01T23:32:58.4511292Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page97.json","@type":"CatalogPage","commitId":"72a135ef-78ba-47c5-b008-0d122a0dd3aa","commitTimeStamp":"2015-02-01T23:42:52.7810612Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page98.json","@type":"CatalogPage","commitId":"119d7d49-bc66-4406-95e4-1d9ec6a2ef8f","commitTimeStamp":"2015-02-01T23:51:19.1471156Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page99.json","@type":"CatalogPage","commitId":"6fcaa8ff-e794-4a92-85b3-35ef1deb5104","commitTimeStamp":"2015-02-02T00:00:40.342449Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page100.json","@type":"CatalogPage","commitId":"ca75f2a3-a005-47e4-8b5e-ae6727a00f04","commitTimeStamp":"2015-02-02T00:10:51.5039017Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page101.json","@type":"CatalogPage","commitId":"e5cf32ce-64f7-4966-ae60-31107e51bdb3","commitTimeStamp":"2015-02-02T00:21:02.2260478Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page102.json","@type":"CatalogPage","commitId":"7d09c4fa-917f-40c9-b050-f61f22b9f4fe","commitTimeStamp":"2015-02-02T00:31:24.8050789Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page103.json","@type":"CatalogPage","commitId":"dcb5756f-fd31-4cd0-969b-7940774e85a5","commitTimeStamp":"2015-02-02T00:41:29.072463Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page104.json","@type":"CatalogPage","commitId":"2064d78c-f11c-47a8-b687-808d0764d74a","commitTimeStamp":"2015-02-02T00:51:18.4505417Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page105.json","@type":"CatalogPage","commitId":"83264e77-bcdc-4049-92fd-aceafbc43abe","commitTimeStamp":"2015-02-02T01:02:08.6696643Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page106.json","@type":"CatalogPage","commitId":"0cffa2ec-8128-402e-81af-456abc35de23","commitTimeStamp":"2015-02-02T01:12:55.5420214Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page107.json","@type":"CatalogPage","commitId":"f67af3da-f091-4548-8dcb-e05c88aae6ee","commitTimeStamp":"2015-02-02T01:23:16.8550747Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page108.json","@type":"CatalogPage","commitId":"b414d7f2-c6be-4315-a0e4-45723b7c83af","commitTimeStamp":"2015-02-02T01:32:47.351392Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page109.json","@type":"CatalogPage","commitId":"657b571c-7531-498d-962e-3841228aef5c","commitTimeStamp":"2015-02-02T01:42:57.2891812Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page110.json","@type":"CatalogPage","commitId":"c568635c-632c-4edd-8c6c-53921c5d32d6","commitTimeStamp":"2015-02-02T01:54:07.0809335Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page111.json","@type":"CatalogPage","commitId":"58927331-0cc3-435a-8f42-a6306cd9a36a","commitTimeStamp":"2015-02-02T02:05:22.5187283Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page112.json","@type":"CatalogPage","commitId":"0e0dee18-2bbe-45fd-bb86-c8bf8a754ed3","commitTimeStamp":"2015-02-02T02:18:16.3472108Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page113.json","@type":"CatalogPage","commitId":"a42f6b37-83be-4436-b499-681597f90056","commitTimeStamp":"2015-02-02T02:29:48.3167332Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page114.json","@type":"CatalogPage","commitId":"f2910867-d1a5-4fa5-b39f-84ae84758b99","commitTimeStamp":"2015-02-02T02:42:57.6161566Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page115.json","@type":"CatalogPage","commitId":"116d711a-c24a-4102-b00b-fff61e2a0bc5","commitTimeStamp":"2015-02-02T02:54:48.230787Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page116.json","@type":"CatalogPage","commitId":"faa83e4c-9012-452c-a72a-45384e7bad1e","commitTimeStamp":"2015-02-02T03:07:17.2821818Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page117.json","@type":"CatalogPage","commitId":"f4d66d52-0ff8-4649-acd4-0d345117cf4f","commitTimeStamp":"2015-02-02T03:17:52.7947969Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page118.json","@type":"CatalogPage","commitId":"1a33a8c4-32e3-4b50-af52-284ae17e59cc","commitTimeStamp":"2015-02-02T03:26:43.6220936Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page119.json","@type":"CatalogPage","commitId":"9b93e92d-576c-45ad-9a82-80fbc0608641","commitTimeStamp":"2015-02-02T03:36:12.35412Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page120.json","@type":"CatalogPage","commitId":"d7a21db8-2adb-414c-b111-011865ffe038","commitTimeStamp":"2015-02-02T03:43:54.5374317Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page121.json","@type":"CatalogPage","commitId":"34d017ca-9319-4dfb-9a15-9358bde13b1b","commitTimeStamp":"2015-02-02T03:51:41.5037451Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page122.json","@type":"CatalogPage","commitId":"370cc52b-9ea8-49b4-b939-039f72dd06cc","commitTimeStamp":"2015-02-02T04:01:50.6828993Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page123.json","@type":"CatalogPage","commitId":"d654bd07-01ab-4b88-8b1a-4a95f0a7b3c0","commitTimeStamp":"2015-02-02T04:13:15.5082495Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page124.json","@type":"CatalogPage","commitId":"d6fac537-9afe-4369-97d8-de08d196193d","commitTimeStamp":"2015-02-02T04:24:34.4209685Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page125.json","@type":"CatalogPage","commitId":"4cc856f0-febc-4ef2-b03d-e735d1beb6df","commitTimeStamp":"2015-02-02T04:36:35.2083545Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page126.json","@type":"CatalogPage","commitId":"d3a71288-929a-4256-b757-773357828530","commitTimeStamp":"2015-02-02T04:50:08.0056107Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page127.json","@type":"CatalogPage","commitId":"a0a2ed34-57c5-4362-81bb-ddadb33a0c8f","commitTimeStamp":"2015-02-02T16:43:56.1117359Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page128.json","@type":"CatalogPage","commitId":"5846192c-6c8a-4d0f-af2f-ccfbb4fd8c50","commitTimeStamp":"2015-02-02T16:53:24.9758074Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page129.json","@type":"CatalogPage","commitId":"8d9e07e5-b308-4bda-a6d8-b529e834eaae","commitTimeStamp":"2015-02-02T17:07:15.8805201Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page130.json","@type":"CatalogPage","commitId":"5e25a29a-2070-40b4-a1d9-ea30dbaa2831","commitTimeStamp":"2015-02-02T17:16:03.7513908Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page131.json","@type":"CatalogPage","commitId":"431bc3d8-60c2-4856-b4a6-dbb175554351","commitTimeStamp":"2015-02-02T17:26:15.6542828Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page132.json","@type":"CatalogPage","commitId":"13ec4bab-c679-42b3-830c-fc2d4de9afdc","commitTimeStamp":"2015-02-02T17:36:50.9851046Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page133.json","@type":"CatalogPage","commitId":"baa8a473-70e4-445b-b2d5-95e6db49de8b","commitTimeStamp":"2015-02-02T17:45:49.1036254Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page134.json","@type":"CatalogPage","commitId":"8c518cb5-376f-41c9-b766-ac28fea2a235","commitTimeStamp":"2015-02-02T17:56:04.7793769Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page135.json","@type":"CatalogPage","commitId":"bcfee23e-9289-4fce-bf4e-a9e01cce9b61","commitTimeStamp":"2015-02-02T18:07:08.3379531Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page136.json","@type":"CatalogPage","commitId":"1858b764-cf3f-4998-b9b3-e25b3a256dfd","commitTimeStamp":"2015-02-02T18:16:54.4080086Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page137.json","@type":"CatalogPage","commitId":"f88a2340-40da-4b40-8527-1a63dd406494","commitTimeStamp":"2015-02-02T18:26:00.8493824Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page138.json","@type":"CatalogPage","commitId":"223cf899-fc32-45ff-9e09-127c4327812d","commitTimeStamp":"2015-02-02T18:36:22.1386255Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page139.json","@type":"CatalogPage","commitId":"938f0f55-9224-4d62-866d-5398e6217645","commitTimeStamp":"2015-02-02T18:44:43.0932129Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page140.json","@type":"CatalogPage","commitId":"1f5a2261-d329-4b70-9777-ec316bcab055","commitTimeStamp":"2015-02-02T18:53:43.0599699Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page141.json","@type":"CatalogPage","commitId":"3767e61e-1861-41e3-b6eb-f91c400d6d45","commitTimeStamp":"2015-02-02T19:02:01.3754391Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page142.json","@type":"CatalogPage","commitId":"5844b0ea-3721-4016-a0ca-c1f33d6198b4","commitTimeStamp":"2015-02-02T19:10:44.8005001Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page143.json","@type":"CatalogPage","commitId":"9afd6e9f-ae64-446e-8042-2fd546b4a8f7","commitTimeStamp":"2015-02-02T19:19:37.6656141Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page144.json","@type":"CatalogPage","commitId":"0482f971-62cd-4a6f-8151-5e2b82f39c21","commitTimeStamp":"2015-02-02T19:27:51.4895423Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page145.json","@type":"CatalogPage","commitId":"3879d54c-38f4-4eca-b1c0-3117a97e02ab","commitTimeStamp":"2015-02-02T19:35:20.528202Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page146.json","@type":"CatalogPage","commitId":"b578f51d-3c0f-480a-89d7-04a089af665d","commitTimeStamp":"2015-02-02T19:44:33.6604813Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page147.json","@type":"CatalogPage","commitId":"79c10a68-00e8-4fad-8db5-33448db342da","commitTimeStamp":"2015-02-02T19:54:42.2911539Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page148.json","@type":"CatalogPage","commitId":"a5655318-5006-470a-bdca-1bd4703642b2","commitTimeStamp":"2015-02-02T20:04:40.4909177Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page149.json","@type":"CatalogPage","commitId":"1c018d65-32e5-4623-b025-e3b3348c606e","commitTimeStamp":"2015-02-02T20:16:43.5229248Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page150.json","@type":"CatalogPage","commitId":"c1305c01-8779-42d4-ac4e-cbfee5ea760a","commitTimeStamp":"2015-02-02T20:27:27.1210733Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page151.json","@type":"CatalogPage","commitId":"d88ae05c-9828-424d-a9d9-a8b757095a5c","commitTimeStamp":"2015-02-02T20:35:42.2589027Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page152.json","@type":"CatalogPage","commitId":"9b44ae04-71dc-42bf-93fc-17c2605e23f5","commitTimeStamp":"2015-02-02T20:43:15.3842289Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page153.json","@type":"CatalogPage","commitId":"102f59eb-a41f-4d69-b6be-efe4b5100c8c","commitTimeStamp":"2015-02-02T20:52:18.3440248Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page154.json","@type":"CatalogPage","commitId":"e80128bd-0b31-4c60-8fdd-8959ab938a97","commitTimeStamp":"2015-02-02T21:00:59.3835343Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page155.json","@type":"CatalogPage","commitId":"12224037-d7fd-4cc0-b0c6-d399fad776d8","commitTimeStamp":"2015-02-02T21:10:47.8737446Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page156.json","@type":"CatalogPage","commitId":"3bafdf91-b73d-4203-9d31-7cbe00b7dd89","commitTimeStamp":"2015-02-02T21:20:34.2329147Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page157.json","@type":"CatalogPage","commitId":"eee04a1b-51c1-4e65-84e8-1254b61ffb36","commitTimeStamp":"2015-02-02T21:30:35.9861255Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page158.json","@type":"CatalogPage","commitId":"42e3a5c7-b5d9-424a-ae57-c5ccdb151d8c","commitTimeStamp":"2015-02-02T21:40:11.8700867Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page159.json","@type":"CatalogPage","commitId":"12158bc2-ffc6-43ae-b6e1-dbb7cbd17ba5","commitTimeStamp":"2015-02-02T21:51:49.8659999Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page160.json","@type":"CatalogPage","commitId":"6a3edd1e-1355-4022-8ab8-905ab5b84272","commitTimeStamp":"2015-02-02T21:59:49.1307543Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page161.json","@type":"CatalogPage","commitId":"d7ebde2a-4b48-4628-a428-d38607c9896b","commitTimeStamp":"2015-02-02T22:13:49.5829366Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page162.json","@type":"CatalogPage","commitId":"ce65b4b5-6743-4086-947a-deb48fa27fea","commitTimeStamp":"2015-02-02T22:24:00.6563125Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page163.json","@type":"CatalogPage","commitId":"c8832af5-1871-422f-a4c6-28727ad9ca20","commitTimeStamp":"2015-02-02T22:32:42.388769Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page164.json","@type":"CatalogPage","commitId":"91c8ba76-4c55-44f6-bb64-c184d9107948","commitTimeStamp":"2015-02-02T22:41:56.8528914Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page165.json","@type":"CatalogPage","commitId":"51cc10ba-7b59-45d1-8a4d-17f1f79012fe","commitTimeStamp":"2015-02-02T22:51:05.0414231Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page166.json","@type":"CatalogPage","commitId":"e2ea4b3c-3af6-4a1c-9e98-dce8f3ba28b9","commitTimeStamp":"2015-02-02T23:00:41.02623Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page167.json","@type":"CatalogPage","commitId":"f92c0654-d1d1-4f12-abbd-579dbd9f239f","commitTimeStamp":"2015-02-02T23:09:45.162409Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page168.json","@type":"CatalogPage","commitId":"6ec0cdaf-02a8-4272-8779-696a78c21dcd","commitTimeStamp":"2015-02-02T23:17:09.3481109Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page169.json","@type":"CatalogPage","commitId":"58e8c34b-112e-4316-b27e-207c04c7589f","commitTimeStamp":"2015-02-02T23:28:10.5310009Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page170.json","@type":"CatalogPage","commitId":"f1367183-2eec-4319-bc83-1eaf9514ab88","commitTimeStamp":"2015-02-02T23:36:49.1274998Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page171.json","@type":"CatalogPage","commitId":"4ce3005d-64e1-4a38-8e00-babd935d7f04","commitTimeStamp":"2015-02-02T23:45:10.9882852Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page172.json","@type":"CatalogPage","commitId":"06796786-fb83-45bf-b9b6-cc4b6e9769f7","commitTimeStamp":"2015-02-02T23:53:36.0544957Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page173.json","@type":"CatalogPage","commitId":"8f55cf5a-91df-4b81-808d-6a4483011fef","commitTimeStamp":"2015-02-03T00:04:50.5949079Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page174.json","@type":"CatalogPage","commitId":"55ba1977-97f1-4dea-ad4e-e2fc9087e66c","commitTimeStamp":"2015-02-03T00:13:39.6120445Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page175.json","@type":"CatalogPage","commitId":"3e7eb703-4cb6-439d-8bed-f052f3c2be94","commitTimeStamp":"2015-02-03T00:23:17.6347663Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page176.json","@type":"CatalogPage","commitId":"1a20b7b3-2f00-4b49-8abf-23bc93e17001","commitTimeStamp":"2015-02-03T00:35:10.6407035Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page177.json","@type":"CatalogPage","commitId":"88b9beeb-2e42-4294-82f0-d7b1af618367","commitTimeStamp":"2015-02-03T00:46:53.6699778Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page178.json","@type":"CatalogPage","commitId":"181ded66-45b9-428d-8538-09242a3f1c39","commitTimeStamp":"2015-02-03T01:02:26.2717626Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page179.json","@type":"CatalogPage","commitId":"9f1a235a-d5e0-4d2c-b74e-8fd05d056be5","commitTimeStamp":"2015-02-03T01:12:21.3965086Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page180.json","@type":"CatalogPage","commitId":"e41f3df0-6e2b-4b5f-9032-12a4e6868f8e","commitTimeStamp":"2015-02-03T01:22:11.4393964Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page181.json","@type":"CatalogPage","commitId":"bf9854f6-358d-4a55-9786-6e06dc2d8e21","commitTimeStamp":"2015-02-03T01:30:21.6847056Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page182.json","@type":"CatalogPage","commitId":"764208be-50a1-45dc-9d70-a3c04f52e08d","commitTimeStamp":"2015-02-03T01:39:48.8142731Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page183.json","@type":"CatalogPage","commitId":"5b3cfb3e-82a4-46dd-a736-c1824c962683","commitTimeStamp":"2015-02-03T01:48:40.7684116Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page184.json","@type":"CatalogPage","commitId":"cc7219b3-2e68-4b58-8f64-9c6895055e7d","commitTimeStamp":"2015-02-03T01:59:17.6397178Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page185.json","@type":"CatalogPage","commitId":"5599af1f-d25c-4818-b3c5-e0a5dbca65f7","commitTimeStamp":"2015-02-03T02:08:58.8535547Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page186.json","@type":"CatalogPage","commitId":"703481b9-8a3a-4f5c-a6fd-08e1bc6feee3","commitTimeStamp":"2015-02-03T02:19:13.3933306Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page187.json","@type":"CatalogPage","commitId":"d657319f-9f5b-49b3-bf0f-832689dc25f9","commitTimeStamp":"2015-02-03T02:28:27.7747878Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page188.json","@type":"CatalogPage","commitId":"e5fd1bb5-bf24-4554-9908-7769f4939562","commitTimeStamp":"2015-02-03T02:38:04.9155207Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page189.json","@type":"CatalogPage","commitId":"66443818-6955-4edf-afbf-f7da2d08637f","commitTimeStamp":"2015-02-03T02:46:24.5435606Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page190.json","@type":"CatalogPage","commitId":"7dffad46-a9a6-4b87-b311-b74e88da0695","commitTimeStamp":"2015-02-03T02:55:40.7514038Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page191.json","@type":"CatalogPage","commitId":"d49a8701-694f-493c-bf71-8100419e9b1f","commitTimeStamp":"2015-02-03T03:06:34.8130413Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page192.json","@type":"CatalogPage","commitId":"7ef8a91c-dc45-4d10-8df3-f0961e12be14","commitTimeStamp":"2015-02-03T03:16:13.1612615Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page193.json","@type":"CatalogPage","commitId":"bea0926b-e7e7-42c5-97c2-fa57b30d29a2","commitTimeStamp":"2015-02-03T03:24:48.2342436Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page194.json","@type":"CatalogPage","commitId":"fb31e73b-c2fc-4846-8be0-52f923f16496","commitTimeStamp":"2015-02-03T03:32:27.0410848Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page195.json","@type":"CatalogPage","commitId":"53606a9b-14ca-4090-b34f-199b4cd4dc9f","commitTimeStamp":"2015-02-03T03:42:38.2560514Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page196.json","@type":"CatalogPage","commitId":"eff8a869-89fe-448a-8e73-5d1d76115dca","commitTimeStamp":"2015-02-03T03:51:23.7289678Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page197.json","@type":"CatalogPage","commitId":"95c91351-93a0-4e1c-a46a-0bcaaa2edbfc","commitTimeStamp":"2015-02-03T03:59:42.7227488Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page198.json","@type":"CatalogPage","commitId":"8d9f7638-fae2-486f-8320-dca751e54215","commitTimeStamp":"2015-02-03T04:09:27.7904852Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page199.json","@type":"CatalogPage","commitId":"fe255dfb-8c77-4d5c-851e-50151731567f","commitTimeStamp":"2015-02-03T04:22:11.3453757Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page200.json","@type":"CatalogPage","commitId":"ccaf966c-8242-48d7-8aad-2d1ade7281cf","commitTimeStamp":"2015-02-03T04:30:28.403543Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page201.json","@type":"CatalogPage","commitId":"4d13b798-1538-4db8-9828-5b53518ad646","commitTimeStamp":"2015-02-03T04:39:07.8205419Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page202.json","@type":"CatalogPage","commitId":"a32c668f-a4f3-4f06-9e96-b2007b83d2b7","commitTimeStamp":"2015-02-03T04:47:25.9615778Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page203.json","@type":"CatalogPage","commitId":"b86d1fa7-5334-45f3-949f-03ecb62f8952","commitTimeStamp":"2015-02-03T04:57:20.4152447Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page204.json","@type":"CatalogPage","commitId":"5da7bbca-6aa7-4ae3-af03-674f8803f328","commitTimeStamp":"2015-02-03T05:24:30.7692719Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page205.json","@type":"CatalogPage","commitId":"8b43973f-e500-4b67-b2bd-004a55ab4da1","commitTimeStamp":"2015-02-03T05:31:12.2086202Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page206.json","@type":"CatalogPage","commitId":"ece723d0-027d-49ca-a3c2-76667b1cea4b","commitTimeStamp":"2015-02-03T05:39:06.0993701Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page207.json","@type":"CatalogPage","commitId":"daed3478-6f79-468c-9df3-76fdbce6f029","commitTimeStamp":"2015-02-03T05:45:57.0869507Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page208.json","@type":"CatalogPage","commitId":"558a5a2c-68c7-43e7-a325-77bad1d2cbe2","commitTimeStamp":"2015-02-03T05:53:28.3121656Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page209.json","@type":"CatalogPage","commitId":"2027586a-1101-407e-8931-84fc980f1f7b","commitTimeStamp":"2015-02-03T06:03:17.2532343Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page210.json","@type":"CatalogPage","commitId":"9a26e1ea-d14c-44ea-84d9-3ae7f1bcb47d","commitTimeStamp":"2015-02-03T06:16:23.8541799Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page211.json","@type":"CatalogPage","commitId":"8a3b24ae-34ef-4fbf-a818-b06a9c987cd7","commitTimeStamp":"2015-02-03T06:24:54.4917731Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page212.json","@type":"CatalogPage","commitId":"909445b0-4396-4a63-b296-aa668202ebed","commitTimeStamp":"2015-02-03T06:34:17.4400481Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page213.json","@type":"CatalogPage","commitId":"702c0ff6-881b-479f-8ed1-58e0e9326ab2","commitTimeStamp":"2015-02-03T06:42:35.1148918Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page214.json","@type":"CatalogPage","commitId":"1382e48f-dcb5-426c-83d5-f95f2a92d868","commitTimeStamp":"2015-02-03T06:50:38.1169518Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page215.json","@type":"CatalogPage","commitId":"c2491c78-21e4-475a-ba29-b35d09de60a3","commitTimeStamp":"2015-02-03T06:57:50.4640722Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page216.json","@type":"CatalogPage","commitId":"7f25180a-5977-4d73-8ea8-2129013c36e2","commitTimeStamp":"2015-02-03T07:04:49.9528154Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page217.json","@type":"CatalogPage","commitId":"82172756-24a5-456e-a8fd-4cb456dbc912","commitTimeStamp":"2015-02-03T07:12:17.3330518Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page218.json","@type":"CatalogPage","commitId":"367ca34a-6be9-4343-b923-e1806b04c268","commitTimeStamp":"2015-02-03T07:19:49.5891235Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page219.json","@type":"CatalogPage","commitId":"6f5a5525-f26a-477b-b56b-ee1fb3d07754","commitTimeStamp":"2015-02-03T07:29:08.8665326Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page220.json","@type":"CatalogPage","commitId":"27e3d47a-5c24-4043-9f56-5e3786326880","commitTimeStamp":"2015-02-03T07:35:50.2955818Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page221.json","@type":"CatalogPage","commitId":"9749b9f6-26d2-462b-a329-552eaf020813","commitTimeStamp":"2015-02-03T07:43:09.3490772Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page222.json","@type":"CatalogPage","commitId":"66f563db-bd09-45aa-aa0a-eb707dbeda37","commitTimeStamp":"2015-02-03T07:50:15.8872173Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page223.json","@type":"CatalogPage","commitId":"a8d3bd25-9a4e-4f6d-beff-1c5b563d54c3","commitTimeStamp":"2015-02-03T07:56:41.9851017Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page224.json","@type":"CatalogPage","commitId":"82c992e3-3ae1-4a2f-af21-47fd41a3927d","commitTimeStamp":"2015-02-03T08:05:21.3674197Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page225.json","@type":"CatalogPage","commitId":"8c4eba57-3e32-4355-af64-3cb84923165b","commitTimeStamp":"2015-02-03T08:15:18.5961574Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page226.json","@type":"CatalogPage","commitId":"e3535e93-b8c3-4988-bccc-5c6843cbfec5","commitTimeStamp":"2015-02-03T08:23:41.9039624Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page227.json","@type":"CatalogPage","commitId":"1e47a1ac-a54e-4017-9399-58819cf7a454","commitTimeStamp":"2015-02-03T08:31:48.2319101Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page228.json","@type":"CatalogPage","commitId":"5730b1f6-b51f-4997-adb5-4d07888d4cd7","commitTimeStamp":"2015-02-03T08:39:02.1945654Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page229.json","@type":"CatalogPage","commitId":"44a01ad0-d7c3-47e5-9edb-6e4450e77d50","commitTimeStamp":"2015-02-03T08:47:26.532934Z","count":538},{"@id":"https://api.nuget.org/v3/catalog0/page230.json","@type":"CatalogPage","commitId":"4f915725-0ab1-4f38-9522-2b4cb3c97b87","commitTimeStamp":"2015-02-03T08:54:15.5623182Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page231.json","@type":"CatalogPage","commitId":"603fbf2c-99c3-44b7-a9ef-0525a9c593ee","commitTimeStamp":"2015-02-03T09:01:59.6727901Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page232.json","@type":"CatalogPage","commitId":"33ce3a8f-67d9-486e-a5ac-e949d8e0c30d","commitTimeStamp":"2015-02-03T09:09:38.8054624Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page233.json","@type":"CatalogPage","commitId":"399f1c83-8cc6-49f1-87db-f455b5c91f46","commitTimeStamp":"2015-02-03T09:16:35.8691333Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page234.json","@type":"CatalogPage","commitId":"14bacaa4-2c51-4c68-89bd-878ebcb9de9f","commitTimeStamp":"2015-02-03T09:23:41.1198307Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page235.json","@type":"CatalogPage","commitId":"ccc6ea3d-0a47-44d7-9be9-d093422c20aa","commitTimeStamp":"2015-02-03T09:31:25.4338767Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page236.json","@type":"CatalogPage","commitId":"ab7cc4b0-3176-4cbf-a7bc-f9e3d4586ca7","commitTimeStamp":"2015-02-03T09:38:29.3926071Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page237.json","@type":"CatalogPage","commitId":"a353ae72-ced8-4a7b-a2dd-40ddfd32dd68","commitTimeStamp":"2015-02-03T09:45:40.5093109Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page238.json","@type":"CatalogPage","commitId":"1388ea94-9916-42ec-a647-02825095653f","commitTimeStamp":"2015-02-03T09:53:08.4537487Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page239.json","@type":"CatalogPage","commitId":"70170f1b-0403-4faa-a291-26a3123192cb","commitTimeStamp":"2015-02-03T10:00:50.5978541Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page240.json","@type":"CatalogPage","commitId":"c5ae7c1e-7d2b-4c16-b5dd-b3fd5038a257","commitTimeStamp":"2015-02-03T10:07:25.5534367Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page241.json","@type":"CatalogPage","commitId":"04d19af0-5f17-4028-9bee-ef47ef73390e","commitTimeStamp":"2015-02-03T10:13:12.9927635Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page242.json","@type":"CatalogPage","commitId":"7983182d-760f-4a34-b270-afa53b4be1b0","commitTimeStamp":"2015-02-03T10:19:19.2269424Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page243.json","@type":"CatalogPage","commitId":"19bdcaa9-81bd-4a54-96d4-f84a1ae357e3","commitTimeStamp":"2015-02-03T10:25:24.883194Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page244.json","@type":"CatalogPage","commitId":"b5c46527-1c4d-4c87-9d95-edc7056faff8","commitTimeStamp":"2015-02-03T10:32:21.9390672Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page245.json","@type":"CatalogPage","commitId":"5fc9fa04-9292-4740-af7f-943b0af4527a","commitTimeStamp":"2015-02-03T10:38:52.7011604Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page246.json","@type":"CatalogPage","commitId":"0bad0e84-1fdc-4d2e-af4f-9ef726857326","commitTimeStamp":"2015-02-03T10:48:07.6288281Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page247.json","@type":"CatalogPage","commitId":"8eb476d1-1d29-478d-9530-993563a90bbd","commitTimeStamp":"2015-02-03T10:56:39.2112101Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page248.json","@type":"CatalogPage","commitId":"327d5a4a-915f-48db-8af3-03f34d8055a4","commitTimeStamp":"2015-02-03T11:04:07.4055416Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page249.json","@type":"CatalogPage","commitId":"b1f987c7-f4b3-4c39-8aee-21842eb22f52","commitTimeStamp":"2015-02-03T11:13:03.7880633Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page250.json","@type":"CatalogPage","commitId":"773d9e7d-31eb-4dfc-aefa-0983db126331","commitTimeStamp":"2015-02-03T11:21:37.2307187Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page251.json","@type":"CatalogPage","commitId":"5e21edee-6495-4216-a7fe-a988b176ebd4","commitTimeStamp":"2015-02-03T11:33:14.6286497Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page252.json","@type":"CatalogPage","commitId":"1282040f-8805-4108-b602-60b3d4d27d6c","commitTimeStamp":"2015-02-03T11:41:01.1059561Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page253.json","@type":"CatalogPage","commitId":"6269f03a-85ba-4333-a196-82792b5d2680","commitTimeStamp":"2015-02-03T11:48:32.3952553Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page254.json","@type":"CatalogPage","commitId":"81cbdbca-8913-4d31-9f4b-4a7512324282","commitTimeStamp":"2015-02-03T11:56:19.4944804Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page255.json","@type":"CatalogPage","commitId":"a4f45b48-b324-44c0-9db9-a049e32b59b0","commitTimeStamp":"2015-02-03T12:03:49.5497172Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page256.json","@type":"CatalogPage","commitId":"ffc74dae-822c-4517-8bf9-d3ac017a68c0","commitTimeStamp":"2015-02-03T12:13:47.1340454Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page257.json","@type":"CatalogPage","commitId":"5a3d2b6b-14eb-4339-9992-35958162425b","commitTimeStamp":"2015-02-03T12:22:10.1323722Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page258.json","@type":"CatalogPage","commitId":"740d1992-a29b-4f20-937b-6bf2e84596f9","commitTimeStamp":"2015-02-03T12:31:57.4746418Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page259.json","@type":"CatalogPage","commitId":"6151fbeb-c1a4-4467-97ea-30554f92b440","commitTimeStamp":"2015-02-03T12:39:41.7976908Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page260.json","@type":"CatalogPage","commitId":"96cf4418-b7d5-46c1-b511-b275cbc3edba","commitTimeStamp":"2015-02-03T12:45:14.5644248Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page261.json","@type":"CatalogPage","commitId":"df3f1113-f4ca-42fc-9fb5-b608e69ff436","commitTimeStamp":"2015-02-03T12:51:45.423751Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page262.json","@type":"CatalogPage","commitId":"076b7a95-f337-46fb-9a1f-114213523b50","commitTimeStamp":"2015-02-03T12:58:38.169212Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page263.json","@type":"CatalogPage","commitId":"10fb64c6-8e01-45d2-9ed0-6a75766dd473","commitTimeStamp":"2015-02-03T13:06:08.230788Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page264.json","@type":"CatalogPage","commitId":"55a6b991-79b2-4085-97cf-85a92743d13e","commitTimeStamp":"2015-02-03T13:13:48.2892426Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page265.json","@type":"CatalogPage","commitId":"0462d0e4-3c1d-4413-9183-d483ccf869de","commitTimeStamp":"2015-02-03T13:24:29.3952913Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page266.json","@type":"CatalogPage","commitId":"456ce389-0409-4d69-a2ba-edc8c098443f","commitTimeStamp":"2015-02-03T13:32:47.6123873Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page267.json","@type":"CatalogPage","commitId":"4be272a6-8a39-44a3-b2eb-a31c44fb0846","commitTimeStamp":"2015-02-03T13:41:11.2304921Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page268.json","@type":"CatalogPage","commitId":"b1f266b4-5d55-4c2a-82d9-41214ac08fb1","commitTimeStamp":"2015-02-03T13:48:59.6289184Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page269.json","@type":"CatalogPage","commitId":"60535ec9-123b-4b58-bc45-695e3fab85c3","commitTimeStamp":"2015-02-03T13:59:19.1126346Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page270.json","@type":"CatalogPage","commitId":"8bfcbff7-aece-4a6a-b8b9-283c82fee68d","commitTimeStamp":"2015-02-03T14:09:42.2923144Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page271.json","@type":"CatalogPage","commitId":"727c0737-4557-4eaa-aaf9-c6362acf83d6","commitTimeStamp":"2015-02-03T14:19:50.9073863Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page272.json","@type":"CatalogPage","commitId":"9f207c34-be15-4e5d-b730-c3a736a30659","commitTimeStamp":"2015-02-03T14:29:46.3161974Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page273.json","@type":"CatalogPage","commitId":"2a993ce4-b537-4a90-a2e6-f18a05c98242","commitTimeStamp":"2015-02-03T14:39:09.6158973Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page274.json","@type":"CatalogPage","commitId":"da76298f-a835-4387-88c0-56a91cd2aaf0","commitTimeStamp":"2015-02-03T14:47:28.5429712Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page275.json","@type":"CatalogPage","commitId":"17d1d5ef-f756-40ca-a5b3-00739a9fb047","commitTimeStamp":"2015-02-03T14:58:29.9132601Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page276.json","@type":"CatalogPage","commitId":"6e52ab1d-b81a-45a3-8930-d2b3f7bc43e2","commitTimeStamp":"2015-02-03T15:06:34.4167927Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page277.json","@type":"CatalogPage","commitId":"a00ffe3b-83f1-4a67-868f-2a6084f2c896","commitTimeStamp":"2015-02-03T15:13:34.9428258Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page278.json","@type":"CatalogPage","commitId":"bde217b8-2032-473f-a5e0-d1af2817e595","commitTimeStamp":"2015-02-03T15:21:34.9623808Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page279.json","@type":"CatalogPage","commitId":"ee3a4250-206f-42fe-89b8-f678c4579c6d","commitTimeStamp":"2015-02-03T15:29:06.0107154Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page280.json","@type":"CatalogPage","commitId":"da37001c-9ef1-4c5f-a4b8-19d3d600ac3c","commitTimeStamp":"2015-02-03T15:37:03.7774751Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page281.json","@type":"CatalogPage","commitId":"683dd504-936a-440f-bcac-9c7437903368","commitTimeStamp":"2015-02-03T15:44:39.2525023Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page282.json","@type":"CatalogPage","commitId":"6f441b15-6cc2-4f51-9c63-124f29c62363","commitTimeStamp":"2015-02-03T15:52:12.6522181Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page283.json","@type":"CatalogPage","commitId":"c5800fba-5190-4d69-aef4-4bffd0888885","commitTimeStamp":"2015-02-03T15:59:50.8633473Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page284.json","@type":"CatalogPage","commitId":"50f9f900-e0c1-4b0c-960d-557de46f2618","commitTimeStamp":"2015-02-03T16:07:53.933809Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page285.json","@type":"CatalogPage","commitId":"45d30008-ed1c-42cd-830d-a6daa1ac7d95","commitTimeStamp":"2015-02-03T16:16:44.9451285Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page286.json","@type":"CatalogPage","commitId":"59696702-b697-4b35-87f7-4595a4eee721","commitTimeStamp":"2015-02-03T16:24:39.1465107Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page287.json","@type":"CatalogPage","commitId":"b2f8cbe5-43f3-4bd9-b2ec-7269e799290b","commitTimeStamp":"2015-02-03T16:33:54.6183271Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page288.json","@type":"CatalogPage","commitId":"cb4b3889-7aea-4848-9c5d-39d84c618d5e","commitTimeStamp":"2015-02-03T16:43:16.2623263Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page289.json","@type":"CatalogPage","commitId":"8aed4cf7-9029-4540-8b2f-3d6040dd1efe","commitTimeStamp":"2015-02-03T16:52:38.0527808Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page290.json","@type":"CatalogPage","commitId":"8bf8eaae-387c-4e52-b1b3-0efe0d7b0aef","commitTimeStamp":"2015-02-03T17:00:39.9818599Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page291.json","@type":"CatalogPage","commitId":"14efcdbf-7fca-40dd-b8a9-1aefab9b8917","commitTimeStamp":"2015-02-03T17:07:43.5712863Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page292.json","@type":"CatalogPage","commitId":"0f78301e-9321-4e94-800b-ac7701c5a995","commitTimeStamp":"2015-02-03T17:16:36.4982708Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page293.json","@type":"CatalogPage","commitId":"3d1df078-6882-40f9-8093-8faa472c92d1","commitTimeStamp":"2015-02-03T17:24:14.0465273Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page294.json","@type":"CatalogPage","commitId":"d78e5e8a-6e2e-45a0-8867-ac0b84a87f24","commitTimeStamp":"2015-02-03T17:31:40.877606Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page295.json","@type":"CatalogPage","commitId":"9c0e8a15-2353-4c72-a470-fe788b64ffd5","commitTimeStamp":"2015-02-03T17:41:55.1469527Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page296.json","@type":"CatalogPage","commitId":"f20303c4-3843-4c83-b6b4-ed7c577562f9","commitTimeStamp":"2015-02-03T17:50:00.8618313Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page297.json","@type":"CatalogPage","commitId":"166a6a78-ada7-49ca-92c1-3f9ed7a0a235","commitTimeStamp":"2015-02-03T17:57:39.3498032Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page298.json","@type":"CatalogPage","commitId":"58a95c62-6b3c-4565-9aef-436c32e44022","commitTimeStamp":"2015-02-03T18:05:36.9921286Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page299.json","@type":"CatalogPage","commitId":"33bb0ca4-1066-42e6-af9c-f9e356fea546","commitTimeStamp":"2015-02-03T18:11:55.4593595Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page300.json","@type":"CatalogPage","commitId":"c6129b83-7cff-43a5-8344-21bacff57842","commitTimeStamp":"2015-02-03T18:20:14.4886425Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page301.json","@type":"CatalogPage","commitId":"4774a3bf-4cdd-4d5d-848e-5e638d0db70a","commitTimeStamp":"2015-02-03T18:30:41.8927408Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page302.json","@type":"CatalogPage","commitId":"aab1f692-4cd6-4ec8-8edf-388c06e15f97","commitTimeStamp":"2015-02-03T18:39:48.7855959Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page303.json","@type":"CatalogPage","commitId":"ccd7da8c-5bb5-4694-9928-2c10508836f6","commitTimeStamp":"2015-02-03T18:47:19.7433551Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page304.json","@type":"CatalogPage","commitId":"629339a5-dc62-4f54-b844-8f69d39eab30","commitTimeStamp":"2015-02-03T18:54:16.6868002Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page305.json","@type":"CatalogPage","commitId":"1c840968-6795-44c0-9dc7-0f738856644b","commitTimeStamp":"2015-02-03T19:01:59.6937319Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page306.json","@type":"CatalogPage","commitId":"b83da551-220f-4112-bd13-dec39d635afb","commitTimeStamp":"2015-02-03T19:10:51.7754838Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page307.json","@type":"CatalogPage","commitId":"45f8fd83-6466-4e05-bef4-28705faa25d6","commitTimeStamp":"2015-02-03T19:20:11.8557548Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page308.json","@type":"CatalogPage","commitId":"8dd487a3-491f-4a8d-9493-57d39d92503e","commitTimeStamp":"2015-02-03T19:29:54.0767801Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page309.json","@type":"CatalogPage","commitId":"f22f4380-951f-4644-af0d-5cd5cafa17df","commitTimeStamp":"2015-02-03T19:37:46.6967494Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page310.json","@type":"CatalogPage","commitId":"54d36346-971f-474e-ad25-a117851bdaa0","commitTimeStamp":"2015-02-03T19:47:51.4243329Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page311.json","@type":"CatalogPage","commitId":"ef1204e8-6199-49ee-aeec-ca41112c4094","commitTimeStamp":"2015-02-03T19:56:02.1343165Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page312.json","@type":"CatalogPage","commitId":"fd0daeae-efcc-4c94-b44f-59e32f330447","commitTimeStamp":"2015-02-03T20:04:34.9651303Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page313.json","@type":"CatalogPage","commitId":"12888955-19f1-4557-a6bd-b1a403ab922e","commitTimeStamp":"2015-02-03T20:13:03.4333836Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page314.json","@type":"CatalogPage","commitId":"81b9afbd-beca-4278-871a-80e9ea5b6b11","commitTimeStamp":"2015-02-03T20:20:33.3851725Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page315.json","@type":"CatalogPage","commitId":"07539d22-1ea3-4383-bf86-1273695b2ee3","commitTimeStamp":"2015-02-03T20:30:28.9746167Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page316.json","@type":"CatalogPage","commitId":"e3233f99-882a-4243-ab9c-9c7e07382263","commitTimeStamp":"2015-02-03T20:39:55.7481553Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page317.json","@type":"CatalogPage","commitId":"ba147257-7c36-4d15-ba16-ff7459ef1626","commitTimeStamp":"2015-02-03T20:47:27.8270269Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page318.json","@type":"CatalogPage","commitId":"8ef0c43b-51c0-41e9-a35a-0a8553cc448a","commitTimeStamp":"2015-02-03T20:55:25.2473999Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page319.json","@type":"CatalogPage","commitId":"b504419e-9abc-4145-a670-05d882c3dd3c","commitTimeStamp":"2015-02-03T21:02:14.3891879Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page320.json","@type":"CatalogPage","commitId":"2794a014-86f0-47a0-b6f7-ddf91da130b9","commitTimeStamp":"2015-02-03T21:10:48.541962Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page321.json","@type":"CatalogPage","commitId":"90c90b79-310e-4e01-975f-bfb7dc02e111","commitTimeStamp":"2015-02-03T21:20:36.5532806Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page322.json","@type":"CatalogPage","commitId":"65c942a5-bc9a-4f60-980e-8eefeb3f8362","commitTimeStamp":"2015-02-03T21:29:02.4461589Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page323.json","@type":"CatalogPage","commitId":"5743e06a-a918-44ac-9376-2cc21f65916b","commitTimeStamp":"2015-02-03T21:35:51.3776776Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page324.json","@type":"CatalogPage","commitId":"73491952-8c54-499f-8cf8-f03854c0192b","commitTimeStamp":"2015-02-03T21:43:21.1832896Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page325.json","@type":"CatalogPage","commitId":"01e48e8c-611f-4564-9ffe-728cf0e367d6","commitTimeStamp":"2015-02-03T21:49:42.0245591Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page326.json","@type":"CatalogPage","commitId":"ff1d4c07-f370-4fa9-a13a-32967325ccbc","commitTimeStamp":"2015-02-03T21:57:37.6739494Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page327.json","@type":"CatalogPage","commitId":"8715f766-d789-4138-b4d3-82116f76f724","commitTimeStamp":"2015-02-03T22:07:20.8152057Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page328.json","@type":"CatalogPage","commitId":"142edfde-7209-4d43-8faf-6867d3771290","commitTimeStamp":"2015-02-03T22:16:27.639269Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page329.json","@type":"CatalogPage","commitId":"62409c7e-5fd5-4cdc-a759-2db23d7ca23c","commitTimeStamp":"2015-02-03T22:25:09.7188179Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page330.json","@type":"CatalogPage","commitId":"29e08c85-8780-444e-ace5-91784d335399","commitTimeStamp":"2015-02-03T22:33:05.746775Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page331.json","@type":"CatalogPage","commitId":"06668c92-d893-4168-befc-511608b7ae3f","commitTimeStamp":"2015-02-03T22:42:11.1901533Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page332.json","@type":"CatalogPage","commitId":"772179bc-10c7-4dab-b831-ee2bfa8c5ffe","commitTimeStamp":"2015-02-03T22:52:30.4373933Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page333.json","@type":"CatalogPage","commitId":"f3cbe4b6-2172-4830-8a6d-70088dea0244","commitTimeStamp":"2015-02-03T23:01:12.7008656Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page334.json","@type":"CatalogPage","commitId":"686b407b-7cab-4079-ab5f-dd757d641ca4","commitTimeStamp":"2015-02-03T23:13:43.9819054Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page335.json","@type":"CatalogPage","commitId":"00d5c4b9-636b-45c6-a680-2d556d718a56","commitTimeStamp":"2015-02-03T23:25:05.1768076Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page336.json","@type":"CatalogPage","commitId":"306b99b7-0261-4e55-ab9a-178e566e7512","commitTimeStamp":"2015-02-03T23:42:26.3011262Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page337.json","@type":"CatalogPage","commitId":"aa16a7f2-516d-4bbe-971c-7ba13d2cba4b","commitTimeStamp":"2015-02-03T23:51:41.0000862Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page338.json","@type":"CatalogPage","commitId":"d1592bdb-7234-4814-a70b-e86f19632979","commitTimeStamp":"2015-02-04T00:00:40.5179104Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page339.json","@type":"CatalogPage","commitId":"03e83700-fd01-44b0-9983-3625e2dc818a","commitTimeStamp":"2015-02-04T00:08:25.5917181Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page340.json","@type":"CatalogPage","commitId":"e566c63a-0ff7-4e83-926d-dc5320d6af38","commitTimeStamp":"2015-02-04T00:16:30.5400644Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page341.json","@type":"CatalogPage","commitId":"d015c97e-4b5a-4ab9-9857-65cb63e5fdab","commitTimeStamp":"2015-02-04T00:23:53.7089945Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page342.json","@type":"CatalogPage","commitId":"4d857a9b-ac0e-49f9-bd58-d1667287c19f","commitTimeStamp":"2015-02-04T00:32:46.692667Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page343.json","@type":"CatalogPage","commitId":"a3872c69-9643-439a-962d-b29530bc6276","commitTimeStamp":"2015-02-04T00:44:50.5152894Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page344.json","@type":"CatalogPage","commitId":"fa9a8668-c431-42a0-ba42-53515225592b","commitTimeStamp":"2015-02-04T00:55:49.2311231Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page345.json","@type":"CatalogPage","commitId":"5c1c708c-7941-4ef5-97fd-a49c6cced30a","commitTimeStamp":"2015-02-04T01:03:04.2671669Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page346.json","@type":"CatalogPage","commitId":"4fc63ee1-400f-4eae-8b1d-c6089e2bbd83","commitTimeStamp":"2015-02-04T01:15:54.6441571Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page347.json","@type":"CatalogPage","commitId":"a05d069d-48e5-4724-a675-f8345f8571c8","commitTimeStamp":"2015-02-04T01:25:35.8958054Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page348.json","@type":"CatalogPage","commitId":"7edcacd8-7706-4ef5-99a5-a0c4063a297e","commitTimeStamp":"2015-02-04T01:35:19.9927612Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page349.json","@type":"CatalogPage","commitId":"90f92573-41c3-48a4-8ba2-70fb154f8ace","commitTimeStamp":"2015-02-04T01:44:26.6731494Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page350.json","@type":"CatalogPage","commitId":"3ab9c106-ab91-42a9-ab51-f6140d0b7abd","commitTimeStamp":"2015-02-04T01:54:52.5066144Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page351.json","@type":"CatalogPage","commitId":"d20174e5-d7eb-447a-9bec-9d942fcdfb9d","commitTimeStamp":"2015-02-04T02:05:39.2114664Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page352.json","@type":"CatalogPage","commitId":"d4c30b23-1522-46ac-a7c4-b15efd2fcdf1","commitTimeStamp":"2015-02-04T02:17:48.0302868Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page353.json","@type":"CatalogPage","commitId":"44554b20-c6ca-4bb3-ba28-fa65567c1960","commitTimeStamp":"2015-02-04T02:28:33.8234121Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page354.json","@type":"CatalogPage","commitId":"675362d2-d095-4b46-920c-a78214a6f230","commitTimeStamp":"2015-02-04T02:42:42.9793807Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page355.json","@type":"CatalogPage","commitId":"3db8e316-39b3-4b58-87ae-ce25be8929df","commitTimeStamp":"2015-02-04T02:52:27.5207087Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page356.json","@type":"CatalogPage","commitId":"8eb8eaec-5ec0-451d-bdf5-b8a9c841abd5","commitTimeStamp":"2015-02-04T03:02:53.7288686Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page357.json","@type":"CatalogPage","commitId":"5f22a1ac-599a-4b44-958d-6e3e708ca2d7","commitTimeStamp":"2015-02-04T03:15:47.4047914Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page358.json","@type":"CatalogPage","commitId":"37af8417-b9ac-4c77-afc1-31336501f7a5","commitTimeStamp":"2015-02-04T03:28:55.2524147Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page359.json","@type":"CatalogPage","commitId":"d1ed400d-004d-46c4-ae74-c295b89762ab","commitTimeStamp":"2015-02-04T03:44:11.6946144Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page360.json","@type":"CatalogPage","commitId":"798493c2-5b78-43d6-b07f-e1a3d838f4e6","commitTimeStamp":"2015-02-04T03:54:32.5270546Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page361.json","@type":"CatalogPage","commitId":"42f97080-1e53-4981-b7bb-00e9403dd738","commitTimeStamp":"2015-02-04T04:05:01.574091Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page362.json","@type":"CatalogPage","commitId":"6c2ee0e8-9d65-46e2-a81a-06b24bc01907","commitTimeStamp":"2015-02-04T04:15:19.8513013Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page363.json","@type":"CatalogPage","commitId":"8b881464-f678-442e-bd9e-069eaa5e49fd","commitTimeStamp":"2015-02-04T04:24:26.3088698Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page364.json","@type":"CatalogPage","commitId":"c4a3c3dc-1d26-4af8-8765-64acc905c2ff","commitTimeStamp":"2015-02-04T04:33:45.0426815Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page365.json","@type":"CatalogPage","commitId":"44c50531-df03-42ac-96a8-1b614412591d","commitTimeStamp":"2015-02-04T04:43:42.2434735Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page366.json","@type":"CatalogPage","commitId":"c033f651-1d8d-4f34-819b-9084353bb412","commitTimeStamp":"2015-02-04T04:54:34.5356612Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page367.json","@type":"CatalogPage","commitId":"8929e112-d0aa-43a7-8a9f-53245f9ee501","commitTimeStamp":"2015-02-04T05:21:59.6117509Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page368.json","@type":"CatalogPage","commitId":"4432cfa4-b83b-4e30-bdc3-751fe4345b4d","commitTimeStamp":"2015-02-04T05:33:12.376171Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page369.json","@type":"CatalogPage","commitId":"ee2055f6-2260-4b04-9861-944fb56c339d","commitTimeStamp":"2015-02-04T05:46:28.4357126Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page370.json","@type":"CatalogPage","commitId":"4deb155c-39e2-4e64-9c57-c25ea4e06e33","commitTimeStamp":"2015-02-04T05:58:03.5357251Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page371.json","@type":"CatalogPage","commitId":"9472efff-9915-466e-87c2-b27f94880c22","commitTimeStamp":"2015-02-04T06:22:09.9130954Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page372.json","@type":"CatalogPage","commitId":"bbf112f1-7680-488e-8295-b19bd7927a02","commitTimeStamp":"2015-02-04T06:38:43.1371942Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page373.json","@type":"CatalogPage","commitId":"4bdb32ef-a9fa-4629-bb4a-25c50c4861dc","commitTimeStamp":"2015-02-04T06:50:23.4379195Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page374.json","@type":"CatalogPage","commitId":"fdd0b72c-98ff-47fc-b05e-d2dea4ace82e","commitTimeStamp":"2015-02-04T07:02:03.7407579Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page375.json","@type":"CatalogPage","commitId":"13e23c20-7ae3-4a38-9395-5178d29f9b91","commitTimeStamp":"2015-02-04T07:19:48.746832Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page376.json","@type":"CatalogPage","commitId":"a7d78aae-2f1e-4a0a-8a77-fcf67e98e95e","commitTimeStamp":"2015-02-04T07:35:19.1372406Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page377.json","@type":"CatalogPage","commitId":"15c29c4a-f6a3-4ad7-b39b-a4f3cca456d9","commitTimeStamp":"2015-02-04T08:01:03.38493Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page378.json","@type":"CatalogPage","commitId":"6e1d7901-9643-41a5-b83b-ba6442d4d691","commitTimeStamp":"2015-02-04T08:11:21.9448264Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page379.json","@type":"CatalogPage","commitId":"5eda655c-059e-44ef-a64b-ac05fe73dace","commitTimeStamp":"2015-02-04T08:24:15.1657352Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page380.json","@type":"CatalogPage","commitId":"0de0dbc6-0282-491c-b9ce-b7cbcc8775d5","commitTimeStamp":"2015-02-04T08:36:45.0559321Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page381.json","@type":"CatalogPage","commitId":"1734333d-0b17-440e-b7d4-dcf6b6dd9cb0","commitTimeStamp":"2015-02-04T08:47:41.6684268Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page382.json","@type":"CatalogPage","commitId":"c54af2a5-2c03-424f-9018-4e1d439bb0d1","commitTimeStamp":"2015-02-04T09:00:14.370519Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page383.json","@type":"CatalogPage","commitId":"ccf4c334-e995-4b0e-bd19-be005ffb1ead","commitTimeStamp":"2015-02-04T09:11:50.6481556Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page384.json","@type":"CatalogPage","commitId":"7b8a9ef2-ac4b-49e2-b2b4-b88cdb3d48e0","commitTimeStamp":"2015-02-04T09:22:47.3948335Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page385.json","@type":"CatalogPage","commitId":"4df67eb1-7914-4892-8860-273edbd80c8c","commitTimeStamp":"2015-02-04T09:35:30.92205Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page386.json","@type":"CatalogPage","commitId":"ab9376c9-4603-4a93-89f6-788ebae06995","commitTimeStamp":"2015-02-04T09:48:26.0950683Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page387.json","@type":"CatalogPage","commitId":"201c7d42-6b0b-4706-a2cf-e83c7c413bf3","commitTimeStamp":"2015-02-04T10:03:03.9645052Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page388.json","@type":"CatalogPage","commitId":"01aa7bb5-f80d-42dc-9df5-0670004d917c","commitTimeStamp":"2015-02-04T10:15:55.335089Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page389.json","@type":"CatalogPage","commitId":"58da8f4a-ed59-484e-b5e6-b687254541bc","commitTimeStamp":"2015-02-04T10:32:14.3350885Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page390.json","@type":"CatalogPage","commitId":"8abfaead-37d0-445e-b434-7454f54d0d95","commitTimeStamp":"2015-02-04T10:46:50.37556Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page391.json","@type":"CatalogPage","commitId":"d6aca6ce-1227-45f3-9465-5e615197c540","commitTimeStamp":"2015-02-04T11:02:25.9173299Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page392.json","@type":"CatalogPage","commitId":"70f57ade-229a-44fe-af6c-642d60c0c96e","commitTimeStamp":"2015-02-04T11:36:56.4947868Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page393.json","@type":"CatalogPage","commitId":"6a900836-23ba-495c-969c-fbadabea7c6d","commitTimeStamp":"2015-02-04T11:49:16.8251866Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page394.json","@type":"CatalogPage","commitId":"748cec8f-2600-4663-a2d3-9b701a8cb880","commitTimeStamp":"2015-02-04T12:04:54.7702584Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page395.json","@type":"CatalogPage","commitId":"8a5c60cb-a439-4f1c-9a1b-ff67de265cac","commitTimeStamp":"2015-02-04T12:17:08.4525071Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page396.json","@type":"CatalogPage","commitId":"0264aabd-189d-4e3c-a381-841d72a2b4df","commitTimeStamp":"2015-02-04T12:30:01.706696Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page397.json","@type":"CatalogPage","commitId":"9e015379-9b6b-4926-9422-c78ddf891b3d","commitTimeStamp":"2015-02-04T12:41:49.2439609Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page398.json","@type":"CatalogPage","commitId":"86a4653a-8fa4-43cf-83bc-f4ecdef9fb0b","commitTimeStamp":"2015-02-04T12:54:17.7933123Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page399.json","@type":"CatalogPage","commitId":"0ae738b4-9983-41e6-a399-4cfe37875461","commitTimeStamp":"2015-02-04T13:04:31.4611357Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page400.json","@type":"CatalogPage","commitId":"1c5ad5d7-d676-4b21-bb54-d23203bf5f5e","commitTimeStamp":"2015-02-04T13:16:58.2474328Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page401.json","@type":"CatalogPage","commitId":"f4aea808-59e6-42eb-9960-c769b5c5ff41","commitTimeStamp":"2015-02-04T13:30:26.7133985Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page402.json","@type":"CatalogPage","commitId":"7d2f07f4-0e5e-4308-ad99-cadcdb2e45a3","commitTimeStamp":"2015-02-04T13:43:31.9414407Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page403.json","@type":"CatalogPage","commitId":"778b4c6c-59ee-460b-9cd9-abde85c255a0","commitTimeStamp":"2015-02-04T13:55:50.6642285Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page404.json","@type":"CatalogPage","commitId":"fbc2bf18-c2b6-4c11-963f-bc1fc29b8288","commitTimeStamp":"2015-02-04T14:06:42.6924634Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page405.json","@type":"CatalogPage","commitId":"c46b1bd8-e930-4ac9-a74c-6ea1850cbf46","commitTimeStamp":"2015-02-04T14:17:44.5448215Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page406.json","@type":"CatalogPage","commitId":"9b0bfdfc-5716-4c5e-8fa7-989be121e983","commitTimeStamp":"2015-02-04T14:31:12.4117817Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page407.json","@type":"CatalogPage","commitId":"d21efa49-0e25-4f39-bf46-7f63031934d8","commitTimeStamp":"2015-02-04T14:41:39.762887Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page408.json","@type":"CatalogPage","commitId":"c30b3a4a-a7a4-4c56-aed5-6999db801322","commitTimeStamp":"2015-02-04T14:53:54.3764241Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page409.json","@type":"CatalogPage","commitId":"f7ebfbc8-b7ee-4eda-9870-580b01c69cd3","commitTimeStamp":"2015-02-04T15:06:16.8034283Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page410.json","@type":"CatalogPage","commitId":"27f6847f-ee84-40f3-a77c-c5992bfc0c10","commitTimeStamp":"2015-02-04T15:20:38.0648912Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page411.json","@type":"CatalogPage","commitId":"714106eb-0d3c-44b9-9b0a-29e8099f1668","commitTimeStamp":"2015-02-04T15:33:29.8502042Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page412.json","@type":"CatalogPage","commitId":"d89de50f-63d0-4c8a-9feb-fa4b1d745d2a","commitTimeStamp":"2015-02-04T15:47:47.6944399Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page413.json","@type":"CatalogPage","commitId":"0ac87413-689b-43a4-80f6-4ee0a2eeba40","commitTimeStamp":"2015-02-04T16:04:30.0517037Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page414.json","@type":"CatalogPage","commitId":"4b95bf05-a4ce-42e4-b4ec-86332376fafc","commitTimeStamp":"2015-02-04T16:19:23.7699735Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page415.json","@type":"CatalogPage","commitId":"9a1de5ac-dd83-4c49-abd3-a4b4088027bb","commitTimeStamp":"2015-02-04T16:32:32.6969168Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page416.json","@type":"CatalogPage","commitId":"e88ccc08-b451-4ce0-a344-03a1a0a1074b","commitTimeStamp":"2015-02-04T16:46:17.3703575Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page417.json","@type":"CatalogPage","commitId":"06cf846c-9e82-4fd8-92bd-6b2a0fb2b92b","commitTimeStamp":"2015-02-04T16:59:03.7318501Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page418.json","@type":"CatalogPage","commitId":"4d6c65cd-55b4-42c7-82cf-c819ffcb9005","commitTimeStamp":"2015-02-04T17:12:35.2640535Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page419.json","@type":"CatalogPage","commitId":"239a714d-f1e4-430d-9bf5-a4a7571aa40a","commitTimeStamp":"2015-02-04T17:24:50.1245886Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page420.json","@type":"CatalogPage","commitId":"d998ad45-31d6-46f6-8ba1-8f91b2d10387","commitTimeStamp":"2015-02-04T17:37:14.6694433Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page421.json","@type":"CatalogPage","commitId":"7d0a9a54-fe44-4756-b3c7-9b96c5b20aef","commitTimeStamp":"2015-02-04T17:47:38.9791836Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page422.json","@type":"CatalogPage","commitId":"1d9481a6-73db-48e1-b224-34df475627ed","commitTimeStamp":"2015-02-04T17:59:10.9599962Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page423.json","@type":"CatalogPage","commitId":"1e446b03-3e5d-4a90-9edb-7aafe1fee419","commitTimeStamp":"2015-02-04T18:10:26.0045231Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page424.json","@type":"CatalogPage","commitId":"d0cac5c7-a885-4df4-82c0-5368db8d6dbe","commitTimeStamp":"2015-02-04T18:21:37.9929941Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page425.json","@type":"CatalogPage","commitId":"6b7f85f4-3a5e-492a-a566-9154c94e09a8","commitTimeStamp":"2015-02-04T18:35:04.8514372Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page426.json","@type":"CatalogPage","commitId":"c9fc28a1-7a18-4a9b-928b-4b9cca10e037","commitTimeStamp":"2015-02-04T18:47:25.9448342Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page427.json","@type":"CatalogPage","commitId":"9849abd0-84b6-44c5-9d02-58b3e7ae3550","commitTimeStamp":"2015-02-04T18:59:40.2683602Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page428.json","@type":"CatalogPage","commitId":"7ea4b90b-0739-4f34-a9d1-40ccae9b5f22","commitTimeStamp":"2015-02-04T19:11:24.3505991Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page429.json","@type":"CatalogPage","commitId":"0659dcc0-b637-4063-a799-ef1d4d182df9","commitTimeStamp":"2015-02-04T19:26:13.3516349Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page430.json","@type":"CatalogPage","commitId":"e67cbec9-7416-4d5a-bc67-84a3b5ab84e7","commitTimeStamp":"2015-02-04T19:36:00.6926103Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page431.json","@type":"CatalogPage","commitId":"26ba593c-54f7-4b1d-9518-a16cc5a122a5","commitTimeStamp":"2015-02-04T19:48:29.6882102Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page432.json","@type":"CatalogPage","commitId":"be7c72f2-fa1e-4106-9808-09de8c00e6fa","commitTimeStamp":"2015-02-04T19:59:36.7763098Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page433.json","@type":"CatalogPage","commitId":"311bacaa-d027-4357-a4e3-b4f96596f4d3","commitTimeStamp":"2015-02-04T20:10:32.3821632Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page434.json","@type":"CatalogPage","commitId":"b54fa66d-c1a1-49b6-9efc-904575c70695","commitTimeStamp":"2015-02-04T20:31:05.0513587Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page435.json","@type":"CatalogPage","commitId":"7f2a6bc1-9d6a-46bb-aeff-3d8246cd1026","commitTimeStamp":"2015-02-04T20:44:28.4212251Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page436.json","@type":"CatalogPage","commitId":"befd724f-543c-478b-b4cb-180604a37c42","commitTimeStamp":"2015-02-04T20:58:27.1081937Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page437.json","@type":"CatalogPage","commitId":"d4180d17-cd82-4e03-a330-88da89597d5a","commitTimeStamp":"2015-02-04T21:11:42.1672067Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page438.json","@type":"CatalogPage","commitId":"f70d672a-3c27-40e3-a4db-980abbf53cfd","commitTimeStamp":"2015-02-04T21:22:48.9210026Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page439.json","@type":"CatalogPage","commitId":"af279cfa-9395-46f3-9501-bc93db070246","commitTimeStamp":"2015-02-04T21:34:10.0274114Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page440.json","@type":"CatalogPage","commitId":"790c2eff-c7f4-4f51-97d6-8486002f2452","commitTimeStamp":"2015-02-04T21:43:37.1271435Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page441.json","@type":"CatalogPage","commitId":"5944d326-7865-4d9b-846b-14a6c7913506","commitTimeStamp":"2015-02-04T21:55:33.0499548Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page442.json","@type":"CatalogPage","commitId":"4e8a0d3c-04d6-4264-878a-5e958af32cb1","commitTimeStamp":"2015-02-04T22:07:30.4060687Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page443.json","@type":"CatalogPage","commitId":"65953040-01c1-4d5b-abc7-22db573452b3","commitTimeStamp":"2015-02-04T22:21:58.4880127Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page444.json","@type":"CatalogPage","commitId":"d55dff0d-4fc0-4114-906e-3d5e266621d7","commitTimeStamp":"2015-02-04T22:34:06.5387385Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page445.json","@type":"CatalogPage","commitId":"2d538415-a7c3-4394-a3ae-f687b4bc577d","commitTimeStamp":"2015-02-04T22:46:40.1271169Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page446.json","@type":"CatalogPage","commitId":"dce24475-b506-4460-8994-e89c3e0c443d","commitTimeStamp":"2015-02-04T22:57:53.5705273Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page447.json","@type":"CatalogPage","commitId":"f946be3a-9837-42e0-a3f9-b2b0590c9df3","commitTimeStamp":"2015-02-04T23:09:07.2438388Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page448.json","@type":"CatalogPage","commitId":"2a28b126-1641-49d9-8c28-72573932569d","commitTimeStamp":"2015-02-04T23:22:08.6450592Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page449.json","@type":"CatalogPage","commitId":"d118d21d-acf2-401a-ab4f-8663ea7f4b14","commitTimeStamp":"2015-02-04T23:35:04.5425541Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page450.json","@type":"CatalogPage","commitId":"d0c87d73-17b4-4745-aa81-acc25d0d0f71","commitTimeStamp":"2015-02-04T23:47:48.0061055Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page451.json","@type":"CatalogPage","commitId":"be0d1a43-15e4-4dc1-bca0-e0cd6b021aa9","commitTimeStamp":"2015-02-05T00:05:12.9556301Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page452.json","@type":"CatalogPage","commitId":"63a8c243-e41f-48ca-93d9-058588694fdd","commitTimeStamp":"2015-02-05T00:21:32.2493868Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page453.json","@type":"CatalogPage","commitId":"b4461b85-87f8-41ab-b754-22401caca71c","commitTimeStamp":"2015-02-05T00:36:48.8196356Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page454.json","@type":"CatalogPage","commitId":"1aefad59-a000-45be-a21a-8da15db9eea8","commitTimeStamp":"2015-02-05T00:50:26.4579058Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page455.json","@type":"CatalogPage","commitId":"af58a20a-f4a2-4802-9cd0-630925a59f05","commitTimeStamp":"2015-02-05T01:03:40.5594651Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page456.json","@type":"CatalogPage","commitId":"807ed9d9-7ec8-4f8c-9b3f-d5797eabfdb0","commitTimeStamp":"2015-02-05T01:17:12.6648449Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page457.json","@type":"CatalogPage","commitId":"5ff2fb89-d056-45b6-93a5-6db852f113a7","commitTimeStamp":"2015-02-05T01:28:03.2901165Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page458.json","@type":"CatalogPage","commitId":"91805cf2-1bd1-49c2-8ec0-b13ace91a569","commitTimeStamp":"2015-02-05T01:43:01.2569697Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page459.json","@type":"CatalogPage","commitId":"c0ecdcd6-d5ae-4443-892a-bb5d83e38789","commitTimeStamp":"2015-02-05T01:54:58.8272167Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page460.json","@type":"CatalogPage","commitId":"d0f7fb07-1780-4e20-a2b5-ac59caa93536","commitTimeStamp":"2015-02-05T02:05:24.1892056Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page461.json","@type":"CatalogPage","commitId":"9ec0f531-8051-4a12-82e5-a3f8ce09e1c3","commitTimeStamp":"2015-02-05T02:17:33.5499733Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page462.json","@type":"CatalogPage","commitId":"c1ddf138-e93f-4925-ba01-b78539f8f778","commitTimeStamp":"2015-02-05T02:33:38.5622561Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page463.json","@type":"CatalogPage","commitId":"bd2edbf9-0576-41f8-b7f8-01c891d42d3c","commitTimeStamp":"2015-02-05T02:47:52.4787772Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page464.json","@type":"CatalogPage","commitId":"a0458429-6994-4594-8d1d-d0aa3aeb235f","commitTimeStamp":"2015-02-05T03:03:45.6117836Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page465.json","@type":"CatalogPage","commitId":"fc1b5823-e541-4e78-9783-51849705ddba","commitTimeStamp":"2015-02-05T03:23:54.5620828Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page466.json","@type":"CatalogPage","commitId":"ff89bb42-f0f4-4e68-8b4e-fa8bb6888874","commitTimeStamp":"2015-02-05T03:39:12.4451214Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page467.json","@type":"CatalogPage","commitId":"2d37ee36-7a8b-4bd8-8cbd-b80c7327f943","commitTimeStamp":"2015-02-05T03:53:04.1990737Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page468.json","@type":"CatalogPage","commitId":"b155e151-5a31-46dd-9107-d23576c4f219","commitTimeStamp":"2015-02-05T04:07:54.6020069Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page469.json","@type":"CatalogPage","commitId":"b4c88bb8-aea2-49de-97ba-8ab1dcdecb11","commitTimeStamp":"2015-02-05T04:20:30.0443412Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page470.json","@type":"CatalogPage","commitId":"a3bc1f2f-61cf-408a-aa45-7a5c6fc49fb0","commitTimeStamp":"2015-02-05T04:32:06.3250687Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page471.json","@type":"CatalogPage","commitId":"946bdfd7-a7a2-4b18-a8ce-1ec494f19ebf","commitTimeStamp":"2015-02-05T04:42:40.9929423Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page472.json","@type":"CatalogPage","commitId":"d6f13103-dea5-439c-938b-87a0a11e0176","commitTimeStamp":"2015-02-05T04:54:48.6401829Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page473.json","@type":"CatalogPage","commitId":"51e4f890-abbc-403e-a1c2-c1d784f721db","commitTimeStamp":"2015-02-05T05:07:02.4099991Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page474.json","@type":"CatalogPage","commitId":"3dce58d3-cb3c-46c2-ba7f-4bc6bad56cbf","commitTimeStamp":"2015-02-05T05:20:34.7724144Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page475.json","@type":"CatalogPage","commitId":"fcddc850-2077-4bd6-a8de-f8269b3ca3ce","commitTimeStamp":"2015-02-05T05:31:11.6480563Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page476.json","@type":"CatalogPage","commitId":"5d09f505-55e8-40b5-baa0-b8baa3fbe149","commitTimeStamp":"2015-02-05T05:41:24.1546918Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page477.json","@type":"CatalogPage","commitId":"9cbc034d-4e58-4e60-9615-4610e538ed87","commitTimeStamp":"2015-02-05T05:53:25.4642977Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page478.json","@type":"CatalogPage","commitId":"bfd8412d-9bc0-4146-a68e-31743db8e57a","commitTimeStamp":"2015-02-05T06:04:18.1157119Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page479.json","@type":"CatalogPage","commitId":"89c81e30-d7a8-42d3-b11b-5b607446173e","commitTimeStamp":"2015-02-05T06:15:29.2498054Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page480.json","@type":"CatalogPage","commitId":"0deb6fad-14d7-44f7-b479-527b35495461","commitTimeStamp":"2015-02-05T06:28:20.0956887Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page481.json","@type":"CatalogPage","commitId":"c822e813-fb0b-4f31-8500-e70082f4b055","commitTimeStamp":"2015-02-05T06:37:58.9025458Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page482.json","@type":"CatalogPage","commitId":"1735f92c-b915-4b2e-be69-221fc2bb9fc7","commitTimeStamp":"2015-02-05T06:49:23.2463711Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page483.json","@type":"CatalogPage","commitId":"ef2f54e5-ea17-49ce-a6a2-15e54cc8e24a","commitTimeStamp":"2015-02-05T07:01:44.3257251Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page484.json","@type":"CatalogPage","commitId":"4f071553-33d1-40a0-981d-15c8a277ff7b","commitTimeStamp":"2015-02-05T07:13:03.3234195Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page485.json","@type":"CatalogPage","commitId":"95aa409a-1f13-4400-a8b0-76a1daf127c3","commitTimeStamp":"2015-02-05T07:23:56.8796314Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page486.json","@type":"CatalogPage","commitId":"448d7583-668c-49b5-82ba-b1d8475cb55f","commitTimeStamp":"2015-02-05T07:37:56.423408Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page487.json","@type":"CatalogPage","commitId":"646e914d-ec9a-46ba-af30-b6b27d5275bd","commitTimeStamp":"2015-02-05T07:49:26.5403309Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page488.json","@type":"CatalogPage","commitId":"093cfeae-7e71-44d9-8c1a-ca32c10cdbdb","commitTimeStamp":"2015-02-05T08:01:01.3653331Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page489.json","@type":"CatalogPage","commitId":"21f3c7f2-27dc-423a-94d9-a6408958337d","commitTimeStamp":"2015-02-05T08:17:15.782181Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page490.json","@type":"CatalogPage","commitId":"14ffc57b-b1f9-48d1-b705-487e9e15d8d6","commitTimeStamp":"2015-02-05T08:28:26.0343041Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page491.json","@type":"CatalogPage","commitId":"a676990e-a68f-4c2e-aab5-16eb8db651b9","commitTimeStamp":"2015-02-05T08:39:47.8196395Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page492.json","@type":"CatalogPage","commitId":"c9dc2f01-bd06-4541-b193-0d95ac9d3686","commitTimeStamp":"2015-02-05T08:51:24.199278Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page493.json","@type":"CatalogPage","commitId":"1fe61f96-7100-4899-a7e8-d12b6ba5a5d9","commitTimeStamp":"2015-02-05T09:00:00.8928332Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page494.json","@type":"CatalogPage","commitId":"cd75e2cd-681f-42cb-a3cb-cbef0c13da3d","commitTimeStamp":"2015-02-05T09:09:28.1955232Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page495.json","@type":"CatalogPage","commitId":"ed208279-7483-465f-9cb7-06366823d4e5","commitTimeStamp":"2015-02-05T09:21:02.046305Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page496.json","@type":"CatalogPage","commitId":"647b829c-63ae-4c16-b4f1-91c82088d58b","commitTimeStamp":"2015-02-05T09:34:16.7750559Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page497.json","@type":"CatalogPage","commitId":"46a361d2-2b06-46b9-9c47-b527ad6af1d2","commitTimeStamp":"2015-02-05T09:45:57.183807Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page498.json","@type":"CatalogPage","commitId":"8affb539-363e-4050-a007-a03a53e348a6","commitTimeStamp":"2015-02-05T09:59:44.1172593Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page499.json","@type":"CatalogPage","commitId":"19ce2f3f-242c-4164-b42e-35db3b746be1","commitTimeStamp":"2015-02-05T10:08:39.4010251Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page500.json","@type":"CatalogPage","commitId":"d1c9dfe7-3189-40c9-baee-04e1e9d5cdc7","commitTimeStamp":"2015-02-05T10:17:57.4181877Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page501.json","@type":"CatalogPage","commitId":"581dde51-3d21-400e-98c1-28ef3397154e","commitTimeStamp":"2015-02-05T10:29:20.1042386Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page502.json","@type":"CatalogPage","commitId":"26f66a25-7725-4a74-b5dc-b2b897c40f10","commitTimeStamp":"2015-02-05T10:40:55.6065182Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page503.json","@type":"CatalogPage","commitId":"bf3f32db-9ccc-4d20-be10-269a3230475a","commitTimeStamp":"2015-02-05T10:51:58.894143Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page504.json","@type":"CatalogPage","commitId":"df859c67-1e2e-48a1-b833-a62df30393ab","commitTimeStamp":"2015-02-05T11:04:27.3280347Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page505.json","@type":"CatalogPage","commitId":"66df1fb6-e939-4e7a-a195-a0673e2110fe","commitTimeStamp":"2015-02-05T11:17:08.7478522Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page506.json","@type":"CatalogPage","commitId":"102105f4-12c4-4fb6-94cc-4ec2ff318efc","commitTimeStamp":"2015-02-05T11:30:20.4962932Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page507.json","@type":"CatalogPage","commitId":"2cbb0399-984c-4b43-90aa-456cafb10cfb","commitTimeStamp":"2015-02-05T11:43:51.7345454Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page508.json","@type":"CatalogPage","commitId":"a493ad1e-560b-48c6-88ad-33c731bf0996","commitTimeStamp":"2015-02-05T11:54:37.8400733Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page509.json","@type":"CatalogPage","commitId":"ce68c992-bc29-44af-959b-ea70ea6307ad","commitTimeStamp":"2015-02-05T12:07:39.9265539Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page510.json","@type":"CatalogPage","commitId":"1e15f0a5-1fa0-4bd0-a07d-0f18ef2ffc09","commitTimeStamp":"2015-02-05T12:20:38.6038816Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page511.json","@type":"CatalogPage","commitId":"806508f3-18e3-47dc-acd2-55ad79ac596e","commitTimeStamp":"2015-02-05T12:31:24.5200813Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page512.json","@type":"CatalogPage","commitId":"40c23673-e359-4f63-b91c-2d4d45d8c488","commitTimeStamp":"2015-02-05T12:44:34.6392587Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page513.json","@type":"CatalogPage","commitId":"11d32072-50f4-4e47-abce-176b0dc27cca","commitTimeStamp":"2015-02-05T12:59:33.3353062Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page514.json","@type":"CatalogPage","commitId":"238106a5-c02e-43a1-9fed-3133ef9b62d7","commitTimeStamp":"2015-02-05T13:12:09.4297375Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page515.json","@type":"CatalogPage","commitId":"0bd10a9f-5449-42d7-87f3-073296e36ed0","commitTimeStamp":"2015-02-05T13:22:09.8886745Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page516.json","@type":"CatalogPage","commitId":"dc2674b0-7188-4c64-b389-ccb7a5ba5f7a","commitTimeStamp":"2015-02-05T13:35:40.9389477Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page517.json","@type":"CatalogPage","commitId":"86ef842a-0fe1-4506-a873-2571484b0567","commitTimeStamp":"2015-02-05T13:47:56.8199506Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page518.json","@type":"CatalogPage","commitId":"5b8f8c0e-878e-45ed-995a-861490898f6f","commitTimeStamp":"2015-02-05T14:01:39.05619Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page519.json","@type":"CatalogPage","commitId":"d176e111-5cd3-4047-bc5b-cb82eab33be0","commitTimeStamp":"2015-02-05T14:14:22.196008Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page520.json","@type":"CatalogPage","commitId":"8e6413ee-7cca-4be7-be77-efdc78e1c415","commitTimeStamp":"2015-02-05T14:26:12.9548316Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page521.json","@type":"CatalogPage","commitId":"88dd9b2f-9491-465a-ba55-5ce3224e067d","commitTimeStamp":"2015-02-05T14:40:27.9953061Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page522.json","@type":"CatalogPage","commitId":"985cae97-3e2a-4963-8103-1055949de92e","commitTimeStamp":"2015-02-05T14:52:08.0613686Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page523.json","@type":"CatalogPage","commitId":"67c3d233-fd5d-4b22-8af0-5a0213d1d697","commitTimeStamp":"2015-02-05T15:04:43.3233548Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page524.json","@type":"CatalogPage","commitId":"63611df0-a3b3-4764-b45c-42c52d435b2e","commitTimeStamp":"2015-02-05T15:15:03.8469073Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page525.json","@type":"CatalogPage","commitId":"d8172229-80dc-4f2f-b58e-c93f06bdbe31","commitTimeStamp":"2015-02-05T15:25:18.1165808Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page526.json","@type":"CatalogPage","commitId":"0af8d7b5-6fca-4295-957d-bda1624b1bdf","commitTimeStamp":"2015-02-05T15:35:14.1144786Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page527.json","@type":"CatalogPage","commitId":"75487f2b-a4f9-4d73-9287-e886fa62b3e6","commitTimeStamp":"2015-02-05T15:46:43.8537843Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page528.json","@type":"CatalogPage","commitId":"7bd88a22-9ff9-4a71-864d-9de51a9df513","commitTimeStamp":"2015-02-05T15:56:16.6922894Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page529.json","@type":"CatalogPage","commitId":"e8a4d86d-9797-48de-a1d2-dda381327418","commitTimeStamp":"2015-02-05T16:05:14.1055993Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page530.json","@type":"CatalogPage","commitId":"ecd7df28-6da1-4098-8594-7cc94682a5bb","commitTimeStamp":"2015-02-05T16:17:24.2037667Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page531.json","@type":"CatalogPage","commitId":"f599a49f-d3f9-4c45-8753-b9bc20b8cf3b","commitTimeStamp":"2015-02-05T16:30:33.7417353Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page532.json","@type":"CatalogPage","commitId":"28915472-3057-46d4-b3fd-0d19ee1fae7c","commitTimeStamp":"2015-02-05T16:42:11.1811432Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page533.json","@type":"CatalogPage","commitId":"d703cf18-8fd3-41d5-af0d-2d4452be466a","commitTimeStamp":"2015-02-05T16:53:57.9461452Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page534.json","@type":"CatalogPage","commitId":"6adbb18a-c83c-4299-860c-b704e813d1fa","commitTimeStamp":"2015-02-05T17:06:50.1226679Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page535.json","@type":"CatalogPage","commitId":"141b13a5-cb9e-4730-94a3-08a689783f85","commitTimeStamp":"2015-02-05T17:21:33.9793458Z","count":537},{"@id":"https://api.nuget.org/v3/catalog0/page536.json","@type":"CatalogPage","commitId":"97e5932a-4973-4fd0-98ff-3cbdb1ac4d0e","commitTimeStamp":"2015-02-05T17:35:24.8169132Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page537.json","@type":"CatalogPage","commitId":"bfbd711c-e2d5-4fe1-b1dd-7f4bec928cbc","commitTimeStamp":"2015-02-05T17:48:04.0383919Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page538.json","@type":"CatalogPage","commitId":"f55a7dc7-ab99-4bb4-9f72-74fc20bd33d1","commitTimeStamp":"2015-02-05T18:00:23.4360191Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page539.json","@type":"CatalogPage","commitId":"6b857720-6f42-41c5-aa76-0e9dc0bbb23f","commitTimeStamp":"2015-02-05T18:16:00.6210045Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page540.json","@type":"CatalogPage","commitId":"0e0eb9a0-0467-42ee-a5dc-45e50d175887","commitTimeStamp":"2015-02-05T18:29:27.3280424Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page541.json","@type":"CatalogPage","commitId":"5a2912a3-cc09-4a36-9cdd-46841e79e33e","commitTimeStamp":"2015-02-05T18:43:02.930595Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page542.json","@type":"CatalogPage","commitId":"261db014-c4ad-44f5-a5ab-d4ca40b8a875","commitTimeStamp":"2015-02-05T18:54:09.7076788Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page543.json","@type":"CatalogPage","commitId":"5636c8b9-72d3-4a9d-9d0b-4cf629851654","commitTimeStamp":"2015-02-05T19:05:56.9800317Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page544.json","@type":"CatalogPage","commitId":"973fe84d-8d15-4723-8f03-1a949ac42832","commitTimeStamp":"2015-02-05T19:16:58.1685472Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page545.json","@type":"CatalogPage","commitId":"e9c01248-426d-4949-a961-805d3dc8689b","commitTimeStamp":"2015-02-05T19:30:43.1943508Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page546.json","@type":"CatalogPage","commitId":"3976c500-f0e2-4b85-97fc-1d691bae407d","commitTimeStamp":"2015-02-05T19:43:48.5545712Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page547.json","@type":"CatalogPage","commitId":"a7018bb3-d621-4d83-bfb0-1f48e88a9a7b","commitTimeStamp":"2015-02-05T19:56:29.9518347Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page548.json","@type":"CatalogPage","commitId":"8726b157-e8a2-4ca6-a592-6b01da0344c0","commitTimeStamp":"2015-02-05T20:07:38.4967986Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page549.json","@type":"CatalogPage","commitId":"a6279aa7-7d16-4e6b-9a11-888f68d9f9fb","commitTimeStamp":"2015-02-05T20:19:41.7601267Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page550.json","@type":"CatalogPage","commitId":"8ef674cf-2f37-462f-a909-b44a5db90cc2","commitTimeStamp":"2015-02-05T20:31:45.802759Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page551.json","@type":"CatalogPage","commitId":"f3dfd823-5ee8-4c83-be97-0fcbdea4d98e","commitTimeStamp":"2015-02-05T20:43:32.8823248Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page552.json","@type":"CatalogPage","commitId":"87c1bced-6e95-4e67-afb0-b6c70d796ce8","commitTimeStamp":"2015-02-05T20:56:45.8856377Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page553.json","@type":"CatalogPage","commitId":"6afad203-8e89-4e82-9227-c48df9db3e28","commitTimeStamp":"2015-02-05T21:09:09.2884731Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page554.json","@type":"CatalogPage","commitId":"e7af090f-79c6-4755-928d-31c7c3765f54","commitTimeStamp":"2015-02-05T21:23:41.3726676Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page555.json","@type":"CatalogPage","commitId":"6674b872-075b-49d8-b132-474675f7708a","commitTimeStamp":"2015-02-05T21:36:26.5396136Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page556.json","@type":"CatalogPage","commitId":"d719fc5f-ac47-4584-80de-8b745f86bbe6","commitTimeStamp":"2015-02-05T21:48:15.2739527Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page557.json","@type":"CatalogPage","commitId":"34dbc756-46e4-4b0b-b986-2b4807a59539","commitTimeStamp":"2015-02-05T22:01:05.9239933Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page558.json","@type":"CatalogPage","commitId":"20ee33c0-eab1-4a1d-8e26-30e3ca022f0c","commitTimeStamp":"2015-02-05T22:17:51.0305352Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page559.json","@type":"CatalogPage","commitId":"49a5f6aa-3d50-460d-a359-6d959dde9b13","commitTimeStamp":"2015-02-05T22:38:45.3953305Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page560.json","@type":"CatalogPage","commitId":"78d719f7-de81-4457-83b8-3fc7de2f95af","commitTimeStamp":"2015-02-05T22:58:19.7399384Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page561.json","@type":"CatalogPage","commitId":"514c19d5-d726-4554-9273-75c51bfe0931","commitTimeStamp":"2015-02-05T23:10:23.8542721Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page562.json","@type":"CatalogPage","commitId":"cf0ca8a2-bbcf-4038-b77c-8d0198f56cfc","commitTimeStamp":"2015-02-05T23:22:39.2222835Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page563.json","@type":"CatalogPage","commitId":"f8544c16-5fd5-4f5b-abaf-8a1228f9cad1","commitTimeStamp":"2015-02-05T23:38:00.4686543Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page564.json","@type":"CatalogPage","commitId":"4b10372f-6b85-4cf0-9d42-8cb1b24aa61c","commitTimeStamp":"2015-02-05T23:49:18.8881366Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page565.json","@type":"CatalogPage","commitId":"d4d07855-bcf2-492a-a451-3597375a1f49","commitTimeStamp":"2015-02-06T00:01:24.9467785Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page566.json","@type":"CatalogPage","commitId":"b5dfbeb2-9d9b-4bea-9971-36b3e5693e68","commitTimeStamp":"2015-02-06T00:28:28.695396Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page567.json","@type":"CatalogPage","commitId":"c7b761b2-4829-4e62-a2ad-2ab36022eee1","commitTimeStamp":"2015-02-06T00:44:18.3444813Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page568.json","@type":"CatalogPage","commitId":"ef8f2597-16a4-4136-88f5-cfa9bffe49c4","commitTimeStamp":"2015-02-06T00:58:02.7884167Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page569.json","@type":"CatalogPage","commitId":"335710f3-4c69-4c53-99bc-b52f679ff4bb","commitTimeStamp":"2015-02-06T01:09:34.2267782Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page570.json","@type":"CatalogPage","commitId":"369bd99d-d3ee-421f-9d11-39b951ca18f2","commitTimeStamp":"2015-02-06T01:40:47.3612342Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page571.json","@type":"CatalogPage","commitId":"34ee0d73-6e41-43b8-b9e6-a1be25d3869b","commitTimeStamp":"2015-02-06T02:08:18.183294Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page572.json","@type":"CatalogPage","commitId":"c28a9c7a-a657-442c-8b33-2bc099533a1c","commitTimeStamp":"2015-02-06T02:22:45.7203859Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page573.json","@type":"CatalogPage","commitId":"bf1cbaaf-8555-4be7-ab72-34f320fbb243","commitTimeStamp":"2015-02-06T02:52:04.5560323Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page574.json","@type":"CatalogPage","commitId":"1904d7c8-c883-4e49-aa45-f22aee3137da","commitTimeStamp":"2015-02-06T03:04:09.7302948Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page575.json","@type":"CatalogPage","commitId":"ccbb8618-5bc5-4ca2-94aa-e0056f38bcac","commitTimeStamp":"2015-02-06T03:17:28.5649977Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page576.json","@type":"CatalogPage","commitId":"f8799308-92c0-488b-8178-2ec114bbb9c1","commitTimeStamp":"2015-02-06T03:30:39.620365Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page577.json","@type":"CatalogPage","commitId":"52381148-507a-43d2-a9a4-611859984b3d","commitTimeStamp":"2015-02-06T03:44:35.5345929Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page578.json","@type":"CatalogPage","commitId":"cfccf61e-04ee-4198-b78d-09ffb168c8de","commitTimeStamp":"2015-02-06T04:01:56.432777Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page579.json","@type":"CatalogPage","commitId":"e1c6183b-4684-4b90-a272-3e656f96abd5","commitTimeStamp":"2015-02-06T04:17:10.4130995Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page580.json","@type":"CatalogPage","commitId":"e656f989-ca47-40ab-8b7f-160d187f8ec3","commitTimeStamp":"2015-02-06T04:32:37.7962027Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page581.json","@type":"CatalogPage","commitId":"89947ce8-e286-4d61-ad2c-9b9ddb13e9b4","commitTimeStamp":"2015-02-06T04:44:57.7715254Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page582.json","@type":"CatalogPage","commitId":"b634f919-a34d-4306-ac4b-35f21bfea6a8","commitTimeStamp":"2015-02-06T04:57:18.3251858Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page583.json","@type":"CatalogPage","commitId":"5ddf6537-ed13-4974-91a2-edf8b5a1b940","commitTimeStamp":"2015-02-06T05:13:14.1632913Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page584.json","@type":"CatalogPage","commitId":"35e38d66-192a-40ae-88d8-16427d45d010","commitTimeStamp":"2015-02-06T05:24:08.52512Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page585.json","@type":"CatalogPage","commitId":"8e0c0839-553e-425c-a189-11600e8cc5c1","commitTimeStamp":"2015-02-06T05:39:28.7766115Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page586.json","@type":"CatalogPage","commitId":"b81a02d0-aaa8-4a4b-8715-ad9aad8f2808","commitTimeStamp":"2015-02-06T05:50:48.8664383Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page587.json","@type":"CatalogPage","commitId":"0eb7a752-afe2-4ac6-abf2-8ec54cee41c0","commitTimeStamp":"2015-02-06T06:11:50.5837607Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page588.json","@type":"CatalogPage","commitId":"27f633a7-2956-4462-9636-d5d6a96e9fb4","commitTimeStamp":"2015-02-06T06:32:24.6888922Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page589.json","@type":"CatalogPage","commitId":"2fee17a8-e057-473f-9669-4e768dd6cd94","commitTimeStamp":"2015-02-06T06:44:03.4562789Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page590.json","@type":"CatalogPage","commitId":"24f4e69c-fa98-420f-ab40-7b602eb28941","commitTimeStamp":"2015-02-06T06:58:51.8240113Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page591.json","@type":"CatalogPage","commitId":"ffd04bd6-2015-4ab8-8ef1-c07cca1dbfb1","commitTimeStamp":"2015-02-06T07:13:42.9588539Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page592.json","@type":"CatalogPage","commitId":"65d284c6-4681-4b4c-8d33-3ab01fcf1d9c","commitTimeStamp":"2015-02-06T07:30:26.8237168Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page593.json","@type":"CatalogPage","commitId":"a221dd61-385a-48b1-aef5-f036a1a0856e","commitTimeStamp":"2015-02-06T07:43:41.5072504Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page594.json","@type":"CatalogPage","commitId":"26c85ed3-4fa5-4757-8343-a03b30f1e6f9","commitTimeStamp":"2015-02-06T08:02:55.1561177Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page595.json","@type":"CatalogPage","commitId":"14fcc09d-7eff-4dc4-acff-4da784bc985a","commitTimeStamp":"2015-02-06T08:16:00.1238002Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page596.json","@type":"CatalogPage","commitId":"e489a4f7-81c2-479a-9693-843eef5890d3","commitTimeStamp":"2015-02-06T08:32:22.7059607Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page597.json","@type":"CatalogPage","commitId":"9353b0fe-8276-4180-ac41-6b21a04eb445","commitTimeStamp":"2015-02-06T08:45:11.7379198Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page598.json","@type":"CatalogPage","commitId":"4c3164dd-6b7a-4231-9081-1484f27912b4","commitTimeStamp":"2015-02-06T08:56:37.404425Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page599.json","@type":"CatalogPage","commitId":"8c1cb316-4f07-429d-95d2-b240999b2334","commitTimeStamp":"2015-02-06T09:08:37.2885989Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page600.json","@type":"CatalogPage","commitId":"79a17e71-d50e-457b-87bf-04a8e39c3df6","commitTimeStamp":"2015-02-06T09:24:10.0101227Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page601.json","@type":"CatalogPage","commitId":"585a8817-ef5c-490f-a6a0-ba8222f35ea3","commitTimeStamp":"2015-02-06T09:37:36.0597522Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page602.json","@type":"CatalogPage","commitId":"4db3757e-c7be-4e9f-a20d-5c56fb7074b6","commitTimeStamp":"2015-02-06T09:50:15.0452119Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page603.json","@type":"CatalogPage","commitId":"c0ec166b-73bb-4574-917a-1c7a1d314cca","commitTimeStamp":"2015-02-06T10:02:01.524223Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page604.json","@type":"CatalogPage","commitId":"9d95d038-3111-43a8-98ff-5fc951d5689d","commitTimeStamp":"2015-02-06T10:14:59.680449Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page605.json","@type":"CatalogPage","commitId":"0cc08944-b222-43a1-9764-e1e4566efe79","commitTimeStamp":"2015-02-06T10:26:57.4001165Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page606.json","@type":"CatalogPage","commitId":"6f037b40-e432-4310-8d38-8f8a7285aa48","commitTimeStamp":"2015-02-06T10:39:21.9460914Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page607.json","@type":"CatalogPage","commitId":"dd805940-7cb2-4193-bc58-ec446990899a","commitTimeStamp":"2015-02-06T10:53:08.3167261Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page608.json","@type":"CatalogPage","commitId":"a62ab954-261f-4a41-a740-7f8e6127767b","commitTimeStamp":"2015-02-06T11:07:11.9513369Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page609.json","@type":"CatalogPage","commitId":"130089ed-3bd1-47b2-ba3f-c641f22c9bd1","commitTimeStamp":"2015-02-06T11:22:27.1407662Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page610.json","@type":"CatalogPage","commitId":"0ed2ceaf-d65a-4bd4-add4-e77fc93132b9","commitTimeStamp":"2015-02-06T11:37:12.1329524Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page611.json","@type":"CatalogPage","commitId":"4d03168e-7a39-4777-8964-08982c9d4686","commitTimeStamp":"2015-02-06T11:49:23.9192486Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page612.json","@type":"CatalogPage","commitId":"209e2b8b-e87d-4bf2-a2e8-cc92feb96812","commitTimeStamp":"2015-02-06T12:02:02.8068302Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page613.json","@type":"CatalogPage","commitId":"3c88f469-6e1e-4a96-bc32-988361abfdd2","commitTimeStamp":"2015-02-06T12:16:23.8123675Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page614.json","@type":"CatalogPage","commitId":"1028ea5b-e13b-4474-9472-44230b50a7b8","commitTimeStamp":"2015-02-06T12:32:30.573971Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page615.json","@type":"CatalogPage","commitId":"0e6a6eab-01ac-4eb8-8e49-3b43fbf53b10","commitTimeStamp":"2015-02-06T12:47:23.4767762Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page616.json","@type":"CatalogPage","commitId":"54059edb-a428-42b1-98eb-86495580a061","commitTimeStamp":"2015-02-06T12:59:35.7865284Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page617.json","@type":"CatalogPage","commitId":"b47f54a9-2e95-4976-a5c0-51ebea16ff6b","commitTimeStamp":"2015-02-06T13:14:01.4710444Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page618.json","@type":"CatalogPage","commitId":"13dcf662-3274-4852-a955-5fdfada93924","commitTimeStamp":"2015-02-06T13:32:02.9082044Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page619.json","@type":"CatalogPage","commitId":"500f73ee-9a35-4a68-bb89-8f3d062a4c86","commitTimeStamp":"2015-02-06T13:46:43.6741994Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page620.json","@type":"CatalogPage","commitId":"f5167bf4-5be7-418e-9c0e-3cca728f4396","commitTimeStamp":"2015-02-06T13:59:45.7392316Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page621.json","@type":"CatalogPage","commitId":"0825eaaf-7e8d-4685-a058-014b138f0fe4","commitTimeStamp":"2015-02-06T14:14:02.5462112Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page622.json","@type":"CatalogPage","commitId":"d9f86d68-2047-4a26-a6b2-106063d08715","commitTimeStamp":"2015-02-06T14:31:34.4880451Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page623.json","@type":"CatalogPage","commitId":"c4d9c4bc-b9d2-40a8-9d84-038433330f0d","commitTimeStamp":"2015-02-06T14:46:17.7308643Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page624.json","@type":"CatalogPage","commitId":"7d7cc8b7-2625-446d-9d4b-7b92e2d812c1","commitTimeStamp":"2015-02-06T14:56:34.0495568Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page625.json","@type":"CatalogPage","commitId":"134a160d-d331-48fc-a01e-4a408bdbe222","commitTimeStamp":"2015-02-06T15:07:36.4062778Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page626.json","@type":"CatalogPage","commitId":"1a589684-1542-4cd8-9b1f-980e38f20a03","commitTimeStamp":"2015-02-06T15:22:03.5561877Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page627.json","@type":"CatalogPage","commitId":"e12fb742-eacb-4058-a7a9-d3bb2a702fc7","commitTimeStamp":"2015-02-06T15:34:42.1456612Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page628.json","@type":"CatalogPage","commitId":"c0798ae5-9693-41f3-8718-ae98b7a4e1c9","commitTimeStamp":"2015-02-06T15:47:31.1670348Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page629.json","@type":"CatalogPage","commitId":"ce66253b-d254-448f-8c3a-3f31183634d9","commitTimeStamp":"2015-02-06T16:02:44.2406919Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page630.json","@type":"CatalogPage","commitId":"fbec5edb-49ee-4b8f-a427-38a696a772e1","commitTimeStamp":"2015-02-06T16:20:37.6955816Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page631.json","@type":"CatalogPage","commitId":"1e2e32b3-dfd5-4fd4-8d77-5ed252dc8a31","commitTimeStamp":"2015-02-06T16:33:05.1147921Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page632.json","@type":"CatalogPage","commitId":"4d3bb55f-ba32-4462-8e47-ee9080b0bace","commitTimeStamp":"2015-02-06T16:50:03.4679209Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page633.json","@type":"CatalogPage","commitId":"a9cfc632-6c78-4c10-a382-e6267ab08a42","commitTimeStamp":"2015-02-06T17:02:57.6085262Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page634.json","@type":"CatalogPage","commitId":"4b173dcb-1d57-4444-96bf-5505b46b6166","commitTimeStamp":"2015-02-06T17:15:07.4696551Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page635.json","@type":"CatalogPage","commitId":"d1d37d4c-bee7-48a7-8be9-6b9477509a92","commitTimeStamp":"2015-02-06T17:44:13.0208781Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page636.json","@type":"CatalogPage","commitId":"4049636c-39fe-47ad-a315-875ea518fe5a","commitTimeStamp":"2015-02-06T17:59:18.0352789Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page637.json","@type":"CatalogPage","commitId":"f78a9198-7c26-4691-87a4-ba50eb10e9ed","commitTimeStamp":"2015-02-06T18:20:11.1375788Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page638.json","@type":"CatalogPage","commitId":"c2057d80-0160-49b8-b0aa-065e6433e4b8","commitTimeStamp":"2015-02-06T18:48:29.0083259Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page639.json","@type":"CatalogPage","commitId":"88cd21c6-ed10-4c46-abee-972db0d6c193","commitTimeStamp":"2015-02-06T19:00:30.5610982Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page640.json","@type":"CatalogPage","commitId":"3fa4161b-9138-4faf-8d44-1728d296096d","commitTimeStamp":"2015-02-06T19:27:39.7563011Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page641.json","@type":"CatalogPage","commitId":"5fb6df18-48b6-4021-9ee8-c825672fb9b4","commitTimeStamp":"2015-02-06T19:41:37.3391634Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page642.json","@type":"CatalogPage","commitId":"a6b6c510-c075-4200-878d-a0c91dc3395d","commitTimeStamp":"2015-02-06T19:56:01.0837611Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page643.json","@type":"CatalogPage","commitId":"99bd6594-71b2-4cd4-a122-160291f3df15","commitTimeStamp":"2015-02-06T20:08:36.0412397Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page644.json","@type":"CatalogPage","commitId":"0b10d802-fbe2-4859-a4b0-e7c6b3bafaa8","commitTimeStamp":"2015-02-06T20:21:56.2980553Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page645.json","@type":"CatalogPage","commitId":"68d37c57-b71c-4ee1-8f4b-7937ea8b3bf8","commitTimeStamp":"2015-02-06T20:33:48.6029549Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page646.json","@type":"CatalogPage","commitId":"b456ee4e-6fe0-4dc4-a5a0-c84c723b1701","commitTimeStamp":"2015-02-06T20:50:03.4878842Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page647.json","@type":"CatalogPage","commitId":"53f76eef-fc3d-472f-bd4d-0fd1c554752b","commitTimeStamp":"2015-02-06T21:03:09.5635341Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page648.json","@type":"CatalogPage","commitId":"9f4b736f-4e94-4cfc-9d58-2143c54c2cd9","commitTimeStamp":"2015-02-06T21:31:24.0092948Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page649.json","@type":"CatalogPage","commitId":"2789c579-6194-45a7-9e37-bd1f36bfed87","commitTimeStamp":"2015-02-06T21:48:30.1924073Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page650.json","@type":"CatalogPage","commitId":"40d5a6d4-f3ba-4699-8bbe-234d9de53d67","commitTimeStamp":"2015-02-06T22:07:03.587477Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page651.json","@type":"CatalogPage","commitId":"0d10230f-0635-4fdc-b1e1-16f122880749","commitTimeStamp":"2015-02-06T22:22:52.960358Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page652.json","@type":"CatalogPage","commitId":"7f00d5e4-6524-4525-8bdb-11dde6612442","commitTimeStamp":"2015-02-06T22:38:22.9795855Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page653.json","@type":"CatalogPage","commitId":"1d442e19-1768-46d9-8a38-84ac2db645d6","commitTimeStamp":"2015-02-06T22:56:26.0454256Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page654.json","@type":"CatalogPage","commitId":"3855c53d-cff4-4e18-b67f-3a0a13ee686e","commitTimeStamp":"2015-02-06T23:34:47.7044068Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page655.json","@type":"CatalogPage","commitId":"161d8c62-dd1e-4cb9-beaf-da5606a178c5","commitTimeStamp":"2015-02-06T23:50:43.4299662Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page656.json","@type":"CatalogPage","commitId":"1dbbc0ca-1b2b-4b6a-94e1-f7bb18080c29","commitTimeStamp":"2015-02-07T00:08:20.1067487Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page657.json","@type":"CatalogPage","commitId":"30641d5d-81f5-4669-8920-19e60d2a7e9c","commitTimeStamp":"2015-02-07T00:33:27.9869287Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page658.json","@type":"CatalogPage","commitId":"1ae0eaa8-4e71-4975-8885-32a0911b8e4d","commitTimeStamp":"2015-02-07T00:52:13.8660537Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page659.json","@type":"CatalogPage","commitId":"19ed8289-5974-488a-9836-e398304901b4","commitTimeStamp":"2015-02-07T01:13:30.1981534Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page660.json","@type":"CatalogPage","commitId":"8392b10f-d9a5-43e1-80c7-ed935d2251d9","commitTimeStamp":"2015-02-07T01:35:10.8162936Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page661.json","@type":"CatalogPage","commitId":"6f1d3f10-a674-48e0-a1ad-c0a5b60ec6a1","commitTimeStamp":"2015-02-07T01:51:57.6541317Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page662.json","@type":"CatalogPage","commitId":"d8448573-9588-42d6-95d3-5913ba9946f1","commitTimeStamp":"2015-02-07T02:09:37.6399642Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page663.json","@type":"CatalogPage","commitId":"4acf3c1c-2124-4b0f-94ca-51bcfb5ab722","commitTimeStamp":"2015-02-07T02:24:36.4542151Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page664.json","@type":"CatalogPage","commitId":"bee5b3d8-814a-4ce4-9f92-744f127089e5","commitTimeStamp":"2015-02-07T02:41:58.3712222Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page665.json","@type":"CatalogPage","commitId":"306ce7b0-3848-4ca0-99bc-75d92d236f91","commitTimeStamp":"2015-02-07T02:58:43.2707965Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page666.json","@type":"CatalogPage","commitId":"67b714e9-2faf-45b3-b69e-2eaf3f36b4fb","commitTimeStamp":"2015-02-07T03:14:06.1024739Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page667.json","@type":"CatalogPage","commitId":"d7576f0d-4ddd-48fb-ac16-f845782f8f21","commitTimeStamp":"2015-02-07T03:30:00.6419573Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page668.json","@type":"CatalogPage","commitId":"8f3d4fce-b306-4b8f-a5af-fec7e217c6f1","commitTimeStamp":"2015-02-07T03:48:11.3959753Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page669.json","@type":"CatalogPage","commitId":"49d2a778-b99f-4b87-8515-8961dfcf81cf","commitTimeStamp":"2015-02-07T04:07:52.2904984Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page670.json","@type":"CatalogPage","commitId":"f600d732-cb3c-4677-889d-5d5137736755","commitTimeStamp":"2015-02-07T04:25:24.2951057Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page671.json","@type":"CatalogPage","commitId":"0a9a1b51-aac1-4b59-83dd-e80d05151557","commitTimeStamp":"2015-02-07T04:48:17.3045902Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page672.json","@type":"CatalogPage","commitId":"cfe7a9ee-2436-4773-aac8-bcae04e9cb9b","commitTimeStamp":"2015-02-07T05:08:41.3211155Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page673.json","@type":"CatalogPage","commitId":"67d863d8-a544-43b0-a31a-385d0cad527b","commitTimeStamp":"2015-02-07T05:27:59.4799494Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page674.json","@type":"CatalogPage","commitId":"77cb07cb-76fe-47d9-9fd7-065a04dc8b80","commitTimeStamp":"2015-02-07T05:45:44.9788869Z","count":538},{"@id":"https://api.nuget.org/v3/catalog0/page675.json","@type":"CatalogPage","commitId":"ee37c6bd-aa8f-45fd-ad64-870e79cced30","commitTimeStamp":"2015-02-07T06:06:52.0319936Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page676.json","@type":"CatalogPage","commitId":"44658169-cab5-4e58-a42e-5b2b36558de5","commitTimeStamp":"2015-02-07T06:27:27.9783262Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page677.json","@type":"CatalogPage","commitId":"837acbfc-bd32-445e-bc40-1ed31478d404","commitTimeStamp":"2015-02-07T06:51:17.0222745Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page678.json","@type":"CatalogPage","commitId":"c49757ab-da92-49d6-b405-a0985698fc68","commitTimeStamp":"2015-02-07T07:09:59.9430414Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page679.json","@type":"CatalogPage","commitId":"8fc543b2-4ceb-4ec8-8aa6-686e0a8ad561","commitTimeStamp":"2015-02-07T07:29:26.1296855Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page680.json","@type":"CatalogPage","commitId":"77f3928d-361e-429b-bf16-e8ebd33739de","commitTimeStamp":"2015-02-07T07:48:30.3610127Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page681.json","@type":"CatalogPage","commitId":"0be2ed51-8b94-4e22-a966-1afca10e47ad","commitTimeStamp":"2015-02-07T08:14:20.3986631Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page682.json","@type":"CatalogPage","commitId":"90b7458a-7b79-4b35-9f32-68d0c83888cc","commitTimeStamp":"2015-02-07T08:27:56.8510882Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page683.json","@type":"CatalogPage","commitId":"a1621616-9e84-4394-88ab-b0fb40e36210","commitTimeStamp":"2015-02-07T08:39:20.9003182Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page684.json","@type":"CatalogPage","commitId":"4e384f9f-bb57-4e2b-af6f-9be41f5acfc6","commitTimeStamp":"2015-02-07T08:51:56.1566102Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page685.json","@type":"CatalogPage","commitId":"ad7865d0-f0fc-4998-a0b1-6e8207b869bf","commitTimeStamp":"2015-02-07T09:05:52.4614984Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page686.json","@type":"CatalogPage","commitId":"265846f1-dc2c-46e7-8a43-8a383055b826","commitTimeStamp":"2015-02-07T09:18:54.3087489Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page687.json","@type":"CatalogPage","commitId":"a2886ef1-98e9-48de-90cb-30bb7968c230","commitTimeStamp":"2015-02-07T09:32:34.2718267Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page688.json","@type":"CatalogPage","commitId":"1cc01d14-6257-4af4-a920-30ce02bc1476","commitTimeStamp":"2015-02-07T09:45:27.2594393Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page689.json","@type":"CatalogPage","commitId":"f34d74f8-958f-4e09-b662-026ffd776d40","commitTimeStamp":"2015-02-07T09:56:13.9310275Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page690.json","@type":"CatalogPage","commitId":"0dbe45db-0c33-4ec9-8d09-a8da907638a3","commitTimeStamp":"2015-02-07T10:09:16.0635637Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page691.json","@type":"CatalogPage","commitId":"7e46b99b-fdc6-4f8c-ade6-5346e27b6ecd","commitTimeStamp":"2015-02-07T10:21:14.7358769Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page692.json","@type":"CatalogPage","commitId":"01f33390-e174-41c9-b494-82ebb8be8bc7","commitTimeStamp":"2015-02-07T10:36:51.4020282Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page693.json","@type":"CatalogPage","commitId":"ef328e42-8f25-4401-aaab-5fe685bb44b6","commitTimeStamp":"2015-02-07T10:50:38.5518572Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page694.json","@type":"CatalogPage","commitId":"59dfe3bc-1f10-40bf-bb98-fc41e2578ea9","commitTimeStamp":"2015-02-07T11:03:24.3712107Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page695.json","@type":"CatalogPage","commitId":"e3c4cf3b-c458-4deb-b7df-98fd56692581","commitTimeStamp":"2015-02-07T11:15:41.805569Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page696.json","@type":"CatalogPage","commitId":"a1c9a2a9-c2b2-4d0c-a16d-208427007267","commitTimeStamp":"2015-02-07T11:27:57.8018355Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page697.json","@type":"CatalogPage","commitId":"f5900724-2b45-4449-a9d2-cebab5c754d5","commitTimeStamp":"2015-02-07T11:41:16.394469Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page698.json","@type":"CatalogPage","commitId":"cb947864-eceb-4c2b-95ce-3f1004f63b31","commitTimeStamp":"2015-02-07T11:53:32.4684679Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page699.json","@type":"CatalogPage","commitId":"a2b4cadc-cfd4-4217-becc-91c299ff40b9","commitTimeStamp":"2015-02-07T12:05:26.8409509Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page700.json","@type":"CatalogPage","commitId":"b47f7254-996b-4251-a065-1653db7f93a9","commitTimeStamp":"2015-02-07T12:16:49.8061624Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page701.json","@type":"CatalogPage","commitId":"27a42d8c-7bd7-472e-b02b-99d7ae29c726","commitTimeStamp":"2015-02-07T12:30:10.3657714Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page702.json","@type":"CatalogPage","commitId":"619bb2fb-db43-4784-9671-d5e20900495c","commitTimeStamp":"2015-02-07T12:42:09.1784402Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page703.json","@type":"CatalogPage","commitId":"c3871b31-6b63-42ce-b639-8375091bdcfe","commitTimeStamp":"2015-02-07T12:53:20.5158521Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page704.json","@type":"CatalogPage","commitId":"f8736449-b849-4910-8fa7-88061b8da7e6","commitTimeStamp":"2015-02-07T13:04:41.5720501Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page705.json","@type":"CatalogPage","commitId":"4fd819f0-a17b-4c1a-aac8-ea5f392a8bd2","commitTimeStamp":"2015-02-07T13:16:45.0864441Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page706.json","@type":"CatalogPage","commitId":"adc20961-4d48-4e52-8433-438664bc9ab1","commitTimeStamp":"2015-02-07T13:28:12.5817226Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page707.json","@type":"CatalogPage","commitId":"084dfff9-24e3-47d2-a36f-465aea4a4bb0","commitTimeStamp":"2015-02-07T13:42:08.6747805Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page708.json","@type":"CatalogPage","commitId":"50ffae6f-05ec-485f-a00b-e09adcf5db6b","commitTimeStamp":"2015-02-07T13:55:13.1122118Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page709.json","@type":"CatalogPage","commitId":"ef9bd9af-7148-4d25-be95-de613c2df88f","commitTimeStamp":"2015-02-07T14:07:41.9070289Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page710.json","@type":"CatalogPage","commitId":"f646a356-72ea-43e5-85d2-54124940c3ff","commitTimeStamp":"2015-02-07T14:21:21.6837634Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page711.json","@type":"CatalogPage","commitId":"ec532dbb-61b6-43ed-9e9d-d45652bb66e8","commitTimeStamp":"2015-02-07T14:33:19.3863918Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page712.json","@type":"CatalogPage","commitId":"0fb6bbf4-b802-43d9-85c8-3be72dfaa774","commitTimeStamp":"2015-02-07T14:44:53.4906305Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page713.json","@type":"CatalogPage","commitId":"5da3c63f-2293-476f-8aaa-f39f08034970","commitTimeStamp":"2015-02-07T14:56:40.6353843Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page714.json","@type":"CatalogPage","commitId":"0195921f-e92f-414a-85dd-3adbb12fc8fc","commitTimeStamp":"2015-02-07T15:08:16.9829625Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page715.json","@type":"CatalogPage","commitId":"93b49dfa-308f-4ad2-bea0-0427924bdb2e","commitTimeStamp":"2015-02-07T15:21:37.0497413Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page716.json","@type":"CatalogPage","commitId":"01e3a362-cab9-4d69-aca3-106512e95d4d","commitTimeStamp":"2015-02-07T15:34:31.68034Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page717.json","@type":"CatalogPage","commitId":"96470074-3401-44a4-937e-70ce2af7a3c7","commitTimeStamp":"2015-02-07T15:47:40.7153456Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page718.json","@type":"CatalogPage","commitId":"42dee30b-b717-49e6-b175-429f7ffef601","commitTimeStamp":"2015-02-07T15:59:57.6634984Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page719.json","@type":"CatalogPage","commitId":"85a8c484-6c2a-4314-a3fa-d05aa0ac0450","commitTimeStamp":"2015-02-07T16:11:08.6286977Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page720.json","@type":"CatalogPage","commitId":"13d22d24-5a28-4ec3-9d88-892eefa8e5b1","commitTimeStamp":"2015-02-07T16:24:08.8589597Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page721.json","@type":"CatalogPage","commitId":"0118718a-f138-4a7d-9a41-fbcbe7865469","commitTimeStamp":"2015-02-07T16:37:03.4353601Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page722.json","@type":"CatalogPage","commitId":"42c3f5ef-6c0b-4230-9e73-18faf7b5e55d","commitTimeStamp":"2015-02-07T16:48:47.9385943Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page723.json","@type":"CatalogPage","commitId":"e5e2b7ec-2862-409b-a67e-7f4cc156921b","commitTimeStamp":"2015-02-07T17:02:18.6114683Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page724.json","@type":"CatalogPage","commitId":"2771f7d8-a6c3-498e-a31c-02ca27de16c4","commitTimeStamp":"2015-02-07T17:14:26.7328809Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page725.json","@type":"CatalogPage","commitId":"71f63f92-c528-4e86-a7f6-f5fed45566b0","commitTimeStamp":"2015-02-07T17:27:05.7343841Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page726.json","@type":"CatalogPage","commitId":"3c282f6c-a6c4-495c-ab60-b8459a4a2456","commitTimeStamp":"2015-02-07T17:39:25.1424499Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page727.json","@type":"CatalogPage","commitId":"78addef6-9751-4978-83cf-67093e336f0a","commitTimeStamp":"2015-02-07T17:51:27.1223913Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page728.json","@type":"CatalogPage","commitId":"6d8571c8-378a-4b8a-ae8e-dc3580ed6c93","commitTimeStamp":"2015-02-07T18:04:42.825249Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page729.json","@type":"CatalogPage","commitId":"900796ed-6bf8-4d5e-a177-76c028bf1942","commitTimeStamp":"2015-02-07T18:17:29.3676456Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page730.json","@type":"CatalogPage","commitId":"44e199ae-3230-485b-bbe6-e85724400867","commitTimeStamp":"2015-02-07T18:30:36.7643937Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page731.json","@type":"CatalogPage","commitId":"38cbbece-f92b-4bf5-bcd2-41445e6733fa","commitTimeStamp":"2015-02-07T18:44:05.8031577Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page732.json","@type":"CatalogPage","commitId":"13090076-6400-4f2e-99bb-523d0a3bb58a","commitTimeStamp":"2015-02-07T18:56:52.2447619Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page733.json","@type":"CatalogPage","commitId":"30d919de-d18c-4ca9-8329-96913aaa9be8","commitTimeStamp":"2015-02-07T19:08:48.843098Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page734.json","@type":"CatalogPage","commitId":"4d110db9-bb51-46a3-8661-e039b3ec65a2","commitTimeStamp":"2015-02-07T19:23:28.7209847Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page735.json","@type":"CatalogPage","commitId":"f9c93417-ef6f-49c0-aa83-b0152f9f1bc2","commitTimeStamp":"2015-02-07T19:35:34.133513Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page736.json","@type":"CatalogPage","commitId":"03459f02-8740-43a4-aafb-63b4e7b031a5","commitTimeStamp":"2015-02-07T19:50:13.9789455Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page737.json","@type":"CatalogPage","commitId":"3d965836-cc62-41d9-a362-0d87863dced2","commitTimeStamp":"2015-02-07T19:59:40.3400023Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page738.json","@type":"CatalogPage","commitId":"604c30bb-c6b4-4b66-9d13-d9f1084349dc","commitTimeStamp":"2015-02-07T20:12:38.4005714Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page739.json","@type":"CatalogPage","commitId":"60d6b728-caec-4be5-b813-9e8a5b0c50fb","commitTimeStamp":"2015-02-07T20:24:07.0857637Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page740.json","@type":"CatalogPage","commitId":"54f06d6a-c0be-4164-b56f-5809e6761c4d","commitTimeStamp":"2015-02-07T20:36:01.2637057Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page741.json","@type":"CatalogPage","commitId":"41e32876-2f28-4054-9c5f-de90800c60de","commitTimeStamp":"2015-02-07T20:53:21.3411624Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page742.json","@type":"CatalogPage","commitId":"9cb51462-9c67-4253-9813-e1e049a0b398","commitTimeStamp":"2015-02-07T21:07:07.6591213Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page743.json","@type":"CatalogPage","commitId":"9bfdec88-c9ef-439d-8939-d3fb0d8c93c3","commitTimeStamp":"2015-02-07T21:19:39.467832Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page744.json","@type":"CatalogPage","commitId":"03b0aa8b-f393-4a40-8685-fb227cc68dbf","commitTimeStamp":"2015-02-07T21:31:41.36332Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page745.json","@type":"CatalogPage","commitId":"c94397c2-d18d-4811-868b-eb8c16f6cc30","commitTimeStamp":"2015-02-07T21:46:33.686963Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page746.json","@type":"CatalogPage","commitId":"24a39658-66e6-4b1f-b2c2-7c57e18a68ad","commitTimeStamp":"2015-02-07T22:00:30.0317501Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page747.json","@type":"CatalogPage","commitId":"42facf50-6862-475d-8151-34102a45fc97","commitTimeStamp":"2015-02-07T22:11:34.3766533Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page748.json","@type":"CatalogPage","commitId":"c2ba796c-4555-4528-b6a6-8eb87902210d","commitTimeStamp":"2015-02-07T22:24:35.847751Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page749.json","@type":"CatalogPage","commitId":"056ce7c4-2b2a-4996-9c88-efb49e5e4407","commitTimeStamp":"2015-02-07T22:37:58.3981751Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page750.json","@type":"CatalogPage","commitId":"deb82867-c692-405a-a636-0a8def6f4e8d","commitTimeStamp":"2015-02-07T22:50:51.929027Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page751.json","@type":"CatalogPage","commitId":"10b07739-f711-4e97-b5b6-59037230f53a","commitTimeStamp":"2015-02-07T23:04:39.7834282Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page752.json","@type":"CatalogPage","commitId":"879be5a7-11ec-4ada-b6ae-dc101d0bd712","commitTimeStamp":"2015-02-07T23:17:11.1577444Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page753.json","@type":"CatalogPage","commitId":"4eb725ea-835c-4501-84e1-03042aef9ab4","commitTimeStamp":"2015-02-07T23:32:28.7551086Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page754.json","@type":"CatalogPage","commitId":"d785879c-1aad-4453-8546-d6a16610a034","commitTimeStamp":"2015-02-07T23:48:12.7215342Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page755.json","@type":"CatalogPage","commitId":"46c4efda-156e-41c3-b9d5-01ed566fe880","commitTimeStamp":"2015-02-08T00:05:17.80274Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page756.json","@type":"CatalogPage","commitId":"d51b0a2b-eea5-42f8-b04e-45a3329fc512","commitTimeStamp":"2015-02-08T00:21:15.1045777Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page757.json","@type":"CatalogPage","commitId":"64fa1a7c-7eac-4cbd-aea8-f20913e4e8ae","commitTimeStamp":"2015-02-08T00:43:06.7341457Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page758.json","@type":"CatalogPage","commitId":"51992647-fab1-4695-8eb7-8762fe35002a","commitTimeStamp":"2015-02-08T01:02:38.4877534Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page759.json","@type":"CatalogPage","commitId":"02b45ca1-2650-4b12-ab23-4c0bc96d4b62","commitTimeStamp":"2015-02-08T01:29:11.896261Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page760.json","@type":"CatalogPage","commitId":"aafc42ba-93dc-40b1-bc62-30de79e13d57","commitTimeStamp":"2015-02-08T01:49:11.6851667Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page761.json","@type":"CatalogPage","commitId":"a9a800d6-5618-4207-b250-98435be183a9","commitTimeStamp":"2015-02-08T02:05:18.9153951Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page762.json","@type":"CatalogPage","commitId":"8d7c4c32-acf9-4b56-9bb8-d1e8810a8e9a","commitTimeStamp":"2015-02-08T02:21:01.0356109Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page763.json","@type":"CatalogPage","commitId":"67b6bfed-1322-4971-b56b-96ff64336c67","commitTimeStamp":"2015-02-08T02:37:04.6405693Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page764.json","@type":"CatalogPage","commitId":"8431ee59-6e91-4dc5-88e5-fefd24f2d770","commitTimeStamp":"2015-02-08T02:51:19.781203Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page765.json","@type":"CatalogPage","commitId":"979aef45-5a32-421a-83ca-3db1915abc10","commitTimeStamp":"2015-02-08T03:08:42.3937934Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page766.json","@type":"CatalogPage","commitId":"49ecfe58-a0c5-4014-9d05-a110752da640","commitTimeStamp":"2015-02-08T03:23:42.7693449Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page767.json","@type":"CatalogPage","commitId":"55856e12-688a-4429-9289-9dc11629d06d","commitTimeStamp":"2015-02-08T03:40:31.3576961Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page768.json","@type":"CatalogPage","commitId":"9478764d-a0b9-4d56-ae51-ca21cc47bf8a","commitTimeStamp":"2015-02-08T03:51:07.3890411Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page769.json","@type":"CatalogPage","commitId":"1ca76597-ffdd-466d-be65-d7d704bd2fea","commitTimeStamp":"2015-02-08T04:03:57.4196231Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page770.json","@type":"CatalogPage","commitId":"7245d9c2-5e56-49f1-a25f-7fbba777224d","commitTimeStamp":"2015-02-08T10:57:04.2359153Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page771.json","@type":"CatalogPage","commitId":"443adca5-6c04-44bb-b1cf-a0229ebd622a","commitTimeStamp":"2015-02-09T08:50:41.4564859Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page772.json","@type":"CatalogPage","commitId":"b06b1024-57e8-4251-b49e-789a483de0c6","commitTimeStamp":"2015-02-09T18:51:21.6624732Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page773.json","@type":"CatalogPage","commitId":"e49253ec-43d0-4d0b-8155-a3e1a2f19d19","commitTimeStamp":"2015-02-12T00:23:46.7758898Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page774.json","@type":"CatalogPage","commitId":"e88a4222-8eb6-4f88-881e-3ca174f14293","commitTimeStamp":"2015-02-12T00:32:18.6026804Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page775.json","@type":"CatalogPage","commitId":"49327d64-65d7-4ec0-8d69-0021615ec0b3","commitTimeStamp":"2015-02-12T00:38:59.4147732Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page776.json","@type":"CatalogPage","commitId":"f44aad37-ec8b-4de6-993d-b43d2c41423d","commitTimeStamp":"2015-02-12T00:46:31.2758228Z","count":537},{"@id":"https://api.nuget.org/v3/catalog0/page777.json","@type":"CatalogPage","commitId":"b23282ff-9191-4047-8977-2b34584c16d0","commitTimeStamp":"2015-02-12T01:00:31.9290275Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page778.json","@type":"CatalogPage","commitId":"7acbbe3d-b950-4393-bcbe-164092df8a55","commitTimeStamp":"2015-02-12T15:53:28.4525516Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page779.json","@type":"CatalogPage","commitId":"75f6eb41-d788-47af-bef2-191ed6c4830a","commitTimeStamp":"2015-02-13T09:04:05.2511705Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page780.json","@type":"CatalogPage","commitId":"bb0d8e71-babd-4910-9d16-b3cb381baf3e","commitTimeStamp":"2015-02-13T20:06:57.694701Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page781.json","@type":"CatalogPage","commitId":"508f9dba-9407-491a-bfc4-0530b54e2359","commitTimeStamp":"2015-02-14T22:15:24.1788502Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page782.json","@type":"CatalogPage","commitId":"1ce2adc6-219e-408d-bbfc-4e77e1126962","commitTimeStamp":"2015-02-15T23:48:29.8199426Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page783.json","@type":"CatalogPage","commitId":"019917a5-ed9e-4dab-996a-203abdc5f5e2","commitTimeStamp":"2015-02-16T08:48:12.6995622Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page784.json","@type":"CatalogPage","commitId":"3dd8469b-f9d0-4997-b4a0-f2791389b21e","commitTimeStamp":"2015-02-16T14:36:08.3677223Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page785.json","@type":"CatalogPage","commitId":"e2392e5f-fe2e-4f1e-bab1-476ff2367428","commitTimeStamp":"2015-02-17T12:17:11.6154757Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page786.json","@type":"CatalogPage","commitId":"d72ef02f-52e0-4757-b03a-4deb29d22ac7","commitTimeStamp":"2015-02-18T06:20:04.8419004Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page787.json","@type":"CatalogPage","commitId":"fda3c549-9866-43ea-a5ea-03fee609d0ba","commitTimeStamp":"2015-02-18T20:37:11.6818999Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page788.json","@type":"CatalogPage","commitId":"b1b9a97b-10f4-4357-b3fa-93114d624890","commitTimeStamp":"2015-02-19T14:21:29.6027097Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page789.json","@type":"CatalogPage","commitId":"a8e5a9ba-0a31-4157-ae65-ea5253a7257e","commitTimeStamp":"2015-02-20T02:14:57.4739794Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page790.json","@type":"CatalogPage","commitId":"50f09f1b-1a0c-40b0-b906-53de06057c84","commitTimeStamp":"2015-02-20T10:27:04.6265451Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page791.json","@type":"CatalogPage","commitId":"1e369c8b-10f4-488c-8e9e-7cea4306b40e","commitTimeStamp":"2015-02-21T09:34:36.1390528Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page792.json","@type":"CatalogPage","commitId":"aace5c01-3e3e-41be-8543-5604a9e32a78","commitTimeStamp":"2015-02-22T11:51:39.6418389Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page793.json","@type":"CatalogPage","commitId":"87121a1d-a610-4ba7-a2a9-59223f05c7a4","commitTimeStamp":"2015-02-23T14:58:40.6802592Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page794.json","@type":"CatalogPage","commitId":"2c621e2f-17a0-459c-b5e1-bfe9cbabd4cd","commitTimeStamp":"2015-02-24T07:17:47.9341467Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page795.json","@type":"CatalogPage","commitId":"06825ee7-c67b-4618-b5e1-153123b06b13","commitTimeStamp":"2015-02-24T20:51:21.5770403Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page796.json","@type":"CatalogPage","commitId":"efbf3e74-edb7-46c0-b82e-3d3c057f0f21","commitTimeStamp":"2015-02-25T13:30:37.1308181Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page797.json","@type":"CatalogPage","commitId":"ccec3267-8a97-4276-97e5-77e813f17978","commitTimeStamp":"2015-02-26T08:06:19.6492776Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page798.json","@type":"CatalogPage","commitId":"f6ab8a2c-b668-47c0-a583-21ef908ce63b","commitTimeStamp":"2015-02-26T22:13:40.0892685Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page799.json","@type":"CatalogPage","commitId":"03c379e7-094c-4eb6-b70a-64ae2b22a7c8","commitTimeStamp":"2015-02-27T19:54:18.9116976Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page800.json","@type":"CatalogPage","commitId":"efcd5477-146e-4fa3-a901-ae9611aca6a8","commitTimeStamp":"2015-02-28T21:48:19.8661096Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page801.json","@type":"CatalogPage","commitId":"718435f6-abee-428c-acc6-56fe8d8226df","commitTimeStamp":"2015-03-02T06:04:13.788839Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page802.json","@type":"CatalogPage","commitId":"df1d90cb-bb98-4695-b7e3-e5d81d295fab","commitTimeStamp":"2015-03-02T20:19:07.6994943Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page803.json","@type":"CatalogPage","commitId":"dbf7f651-27db-4fb6-a21c-b755690115db","commitTimeStamp":"2015-03-03T12:41:40.424268Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page804.json","@type":"CatalogPage","commitId":"a6caf105-969e-4d8d-9580-aed588aedada","commitTimeStamp":"2015-03-04T04:02:13.4430613Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page805.json","@type":"CatalogPage","commitId":"19f0d0f5-5e91-464f-af75-976c685b9250","commitTimeStamp":"2015-03-04T15:54:40.5068036Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page806.json","@type":"CatalogPage","commitId":"933ed058-f24f-469e-811f-acaff21f9204","commitTimeStamp":"2015-03-05T10:51:56.7479071Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page807.json","@type":"CatalogPage","commitId":"f17ef4e7-96f9-4670-820f-bf529810e61e","commitTimeStamp":"2015-03-05T19:45:56.2324582Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page808.json","@type":"CatalogPage","commitId":"75f45e40-5ea9-4db9-83a2-a2ec4086dd7e","commitTimeStamp":"2015-03-06T13:00:51.2393732Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page809.json","@type":"CatalogPage","commitId":"6b1c9467-78f9-4613-8dac-201890a3110c","commitTimeStamp":"2015-03-07T09:10:13.2329646Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page810.json","@type":"CatalogPage","commitId":"5235a2e9-6bba-4157-847b-ac48be64a065","commitTimeStamp":"2015-03-08T12:22:30.5205753Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page811.json","@type":"CatalogPage","commitId":"80509e08-45ba-48d9-b607-c156d9eb4286","commitTimeStamp":"2015-03-09T06:24:22.7995798Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page812.json","@type":"CatalogPage","commitId":"d06b2e62-b11c-40b5-b904-0f06c3b841a4","commitTimeStamp":"2015-03-09T22:03:29.2927114Z","count":544},{"@id":"https://api.nuget.org/v3/catalog0/page813.json","@type":"CatalogPage","commitId":"1169a02a-4597-40ff-b538-a7bfe90dd66f","commitTimeStamp":"2015-03-10T14:03:12.3296446Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page814.json","@type":"CatalogPage","commitId":"e71e6b04-c23a-47d4-9218-f56913b2d50e","commitTimeStamp":"2015-03-11T08:44:46.8063354Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page815.json","@type":"CatalogPage","commitId":"57facfee-affe-43d0-b049-02487323a3ce","commitTimeStamp":"2015-03-11T17:22:04.773717Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page816.json","@type":"CatalogPage","commitId":"531b382d-ad63-4e7a-a11b-45eef2e87384","commitTimeStamp":"2015-03-12T09:30:58.8339912Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page817.json","@type":"CatalogPage","commitId":"d4095372-9c08-4588-9eaa-743e7eff178d","commitTimeStamp":"2015-03-12T19:59:30.7871758Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page818.json","@type":"CatalogPage","commitId":"e4dd30d2-ee4a-46ee-b6bc-eae79b57395f","commitTimeStamp":"2015-03-12T22:11:27.3867975Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page819.json","@type":"CatalogPage","commitId":"6e442762-e695-492e-97a0-96a202d6f835","commitTimeStamp":"2015-03-13T14:04:12.5286959Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page820.json","@type":"CatalogPage","commitId":"0fbb68bf-5828-4b56-851e-4cddf85224c7","commitTimeStamp":"2015-03-14T08:38:01.9461551Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page821.json","@type":"CatalogPage","commitId":"7f04715f-5235-4e47-b3d3-6c70357d7ed5","commitTimeStamp":"2015-03-14T20:05:28.7922919Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page822.json","@type":"CatalogPage","commitId":"9b0b309e-5708-48b8-8b9b-0f5f516a8ac2","commitTimeStamp":"2015-03-15T17:32:35.0540057Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page823.json","@type":"CatalogPage","commitId":"18d03c94-bed3-4a6d-8f67-8f55ef12dca3","commitTimeStamp":"2015-03-16T16:28:14.8025101Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page824.json","@type":"CatalogPage","commitId":"dd64cb5a-2374-412c-8b56-3b3b6dc32a46","commitTimeStamp":"2015-03-17T11:49:48.1611956Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page825.json","@type":"CatalogPage","commitId":"d6ed7e0b-89f0-40b9-900d-351b72fc2b53","commitTimeStamp":"2015-03-17T23:38:21.1730847Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page826.json","@type":"CatalogPage","commitId":"061eaa8f-c119-4031-9d38-dfe66df51a38","commitTimeStamp":"2015-03-18T23:48:27.5493432Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page827.json","@type":"CatalogPage","commitId":"6fadb962-ae06-4b07-8866-7c61198e6118","commitTimeStamp":"2015-03-19T13:56:04.1787138Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page828.json","@type":"CatalogPage","commitId":"1cd40cf0-c617-4339-8ae0-6f1fe25f0c0d","commitTimeStamp":"2015-03-20T11:22:53.3944946Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page829.json","@type":"CatalogPage","commitId":"87dcc656-54c2-4f9a-bce9-c0b0354996c8","commitTimeStamp":"2015-03-20T23:05:40.4975427Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page830.json","@type":"CatalogPage","commitId":"6879207d-59b5-418d-8d16-439ecb5049ba","commitTimeStamp":"2015-03-22T01:12:29.2955279Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page831.json","@type":"CatalogPage","commitId":"96051529-8fe5-4a02-920c-db71344bb0bc","commitTimeStamp":"2015-03-23T06:21:02.7845582Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page832.json","@type":"CatalogPage","commitId":"550b948b-4742-4c83-acfc-715f65559ea5","commitTimeStamp":"2015-03-23T17:18:52.7456559Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page833.json","@type":"CatalogPage","commitId":"e9a417d0-dd35-4fdc-8713-21337e1116f1","commitTimeStamp":"2015-03-24T09:37:54.1645552Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page834.json","@type":"CatalogPage","commitId":"ceb47156-8832-4de2-9a20-a849cfb72b49","commitTimeStamp":"2015-03-25T00:43:32.6724301Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page835.json","@type":"CatalogPage","commitId":"5ed7ce16-6641-4256-ba33-8553cc0e6f96","commitTimeStamp":"2015-03-25T17:41:11.7577209Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page836.json","@type":"CatalogPage","commitId":"d0b143f9-586f-4754-b50e-14cc9051ff55","commitTimeStamp":"2015-03-26T06:12:46.4500399Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page837.json","@type":"CatalogPage","commitId":"c53a4c79-6ea0-4885-9108-d432e34db286","commitTimeStamp":"2015-03-26T22:27:42.0855681Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page838.json","@type":"CatalogPage","commitId":"592ecd70-05f1-4954-8258-87066db76d2f","commitTimeStamp":"2015-03-27T10:25:46.3896291Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page839.json","@type":"CatalogPage","commitId":"d6414063-fa2c-4181-b0ea-c1d7c50de14c","commitTimeStamp":"2015-03-28T03:19:58.3628752Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page840.json","@type":"CatalogPage","commitId":"dffeee68-2d2b-4750-b673-58f9601ed053","commitTimeStamp":"2015-03-29T09:49:23.6881707Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page841.json","@type":"CatalogPage","commitId":"c6604b38-3d43-4251-81c9-eb90bef73487","commitTimeStamp":"2015-03-30T09:22:07.6511292Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page842.json","@type":"CatalogPage","commitId":"95769c6f-cd7a-4ada-98a7-64cca009a9d5","commitTimeStamp":"2015-03-31T04:59:23.8990079Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page843.json","@type":"CatalogPage","commitId":"b573b89a-0ab4-46b6-95ea-c2116e1c6fe1","commitTimeStamp":"2015-03-31T20:43:38.8039526Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page844.json","@type":"CatalogPage","commitId":"23186e04-b405-4c37-be5a-1539387ea263","commitTimeStamp":"2015-04-01T13:04:03.4431089Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page845.json","@type":"CatalogPage","commitId":"956b0360-a505-4de5-91cb-6e6789d3c2dd","commitTimeStamp":"2015-04-01T22:27:06.4676986Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page846.json","@type":"CatalogPage","commitId":"068a2781-2b4b-4192-9a6f-e1f5dc573dbf","commitTimeStamp":"2015-04-02T17:51:23.2319756Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page847.json","@type":"CatalogPage","commitId":"4ec8897c-d8e0-49b2-8668-9464f0062f02","commitTimeStamp":"2015-04-03T15:34:02.0698496Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page848.json","@type":"CatalogPage","commitId":"54771cb9-3214-4afd-bc10-675bf773dcc8","commitTimeStamp":"2015-04-04T14:49:25.445208Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page849.json","@type":"CatalogPage","commitId":"4a2f6659-8180-4694-8453-41177a5f7ede","commitTimeStamp":"2015-04-05T22:09:34.158241Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page850.json","@type":"CatalogPage","commitId":"9f6c9889-b588-47d5-a4dc-0e0d70138249","commitTimeStamp":"2015-04-06T20:28:52.1104075Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page851.json","@type":"CatalogPage","commitId":"0d232e8f-80de-41c9-a483-36589034df08","commitTimeStamp":"2015-04-07T11:57:59.0803479Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page852.json","@type":"CatalogPage","commitId":"fd0ec229-8eb8-4b7b-976b-67100021ef5e","commitTimeStamp":"2015-04-07T17:28:37.6513485Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page853.json","@type":"CatalogPage","commitId":"fa9d30f5-dce8-468b-bd72-2abc15ad5144","commitTimeStamp":"2015-04-07T18:31:47.5379056Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page854.json","@type":"CatalogPage","commitId":"b528a29f-a9c7-498d-be9d-3912f4188b20","commitTimeStamp":"2015-04-08T06:06:29.8805651Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page855.json","@type":"CatalogPage","commitId":"d7fb97d6-b20c-498a-b727-cd6e8d269703","commitTimeStamp":"2015-04-09T16:33:04.2865455Z","count":542},{"@id":"https://api.nuget.org/v3/catalog0/page856.json","@type":"CatalogPage","commitId":"52046680-3e3c-4149-95ad-5ea65b47c608","commitTimeStamp":"2015-04-09T16:41:12.5838526Z","count":536},{"@id":"https://api.nuget.org/v3/catalog0/page857.json","@type":"CatalogPage","commitId":"fdf510aa-04af-4081-9397-d5a82a76b652","commitTimeStamp":"2015-04-10T09:57:19.4473347Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page858.json","@type":"CatalogPage","commitId":"5fffe202-31dc-433f-b391-405801722068","commitTimeStamp":"2015-04-11T06:10:35.389418Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page859.json","@type":"CatalogPage","commitId":"8738166f-1a16-4a2a-ae7e-97b3b7f58654","commitTimeStamp":"2015-04-12T12:59:13.8857324Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page860.json","@type":"CatalogPage","commitId":"3cd2807c-715d-4c05-9d5f-596356715292","commitTimeStamp":"2015-04-13T14:00:59.1166504Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page861.json","@type":"CatalogPage","commitId":"19a898cb-cf25-40d3-8565-97f17c231c9e","commitTimeStamp":"2015-04-14T08:11:57.5174631Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page862.json","@type":"CatalogPage","commitId":"5a45af23-4ec1-42c9-9bb6-9c6d0d01c222","commitTimeStamp":"2015-04-14T21:11:28.8214302Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page863.json","@type":"CatalogPage","commitId":"8626bb4d-2947-43d7-a1da-e41247f82b60","commitTimeStamp":"2015-04-16T17:34:01.6642929Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page864.json","@type":"CatalogPage","commitId":"4f2ea2b3-87df-4d7c-8b2f-2568fea83b13","commitTimeStamp":"2015-04-16T17:41:32.6846301Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page865.json","@type":"CatalogPage","commitId":"6b2c7321-79f2-4f51-85c5-09a19bacc2c9","commitTimeStamp":"2015-04-17T02:24:38.7971038Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page866.json","@type":"CatalogPage","commitId":"324cb2db-aafd-4781-bffb-4d895585ab95","commitTimeStamp":"2015-04-17T14:24:42.2241646Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page867.json","@type":"CatalogPage","commitId":"b4eb4ad3-f0ae-455a-a4b0-e8812227cc54","commitTimeStamp":"2015-04-17T23:10:44.9757058Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page868.json","@type":"CatalogPage","commitId":"0710b4c0-e32a-40a4-9269-baefa9d1f3f3","commitTimeStamp":"2015-04-18T16:36:03.6679883Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page869.json","@type":"CatalogPage","commitId":"4d928b50-5a09-4c04-9fb4-96aee74b925a","commitTimeStamp":"2015-04-19T18:08:51.4476734Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page870.json","@type":"CatalogPage","commitId":"6afa35b6-981e-4827-83ef-1373411850e2","commitTimeStamp":"2015-04-20T13:09:51.631163Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page871.json","@type":"CatalogPage","commitId":"41e1469a-1aad-4a0c-8aa9-67fcf8028f0c","commitTimeStamp":"2015-04-21T18:51:29.4369391Z","count":533},{"@id":"https://api.nuget.org/v3/catalog0/page872.json","@type":"CatalogPage","commitId":"b3be01ff-a501-4156-a557-4ba5be5f4524","commitTimeStamp":"2015-04-21T18:56:53.2160891Z","count":541},{"@id":"https://api.nuget.org/v3/catalog0/page873.json","@type":"CatalogPage","commitId":"9f65b6ce-e195-404b-937e-16e92be10ae6","commitTimeStamp":"2015-04-21T22:17:47.2692294Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page874.json","@type":"CatalogPage","commitId":"3df17602-63a8-4573-8850-c23cb6a2fdcc","commitTimeStamp":"2015-04-22T11:08:52.9958229Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page875.json","@type":"CatalogPage","commitId":"dd132306-ca89-454d-83cc-af5f12012559","commitTimeStamp":"2015-04-23T01:01:07.5413463Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page876.json","@type":"CatalogPage","commitId":"fadbd75b-0df8-4078-a5a9-a4fba749a350","commitTimeStamp":"2015-04-23T15:46:42.3688925Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page877.json","@type":"CatalogPage","commitId":"4e3a75fc-477f-4ccd-a30d-e862ac152f9e","commitTimeStamp":"2015-04-24T10:11:10.6519814Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page878.json","@type":"CatalogPage","commitId":"ab49a92f-fdc6-47e7-a605-869449f103fd","commitTimeStamp":"2015-04-27T21:07:22.5051697Z","count":541},{"@id":"https://api.nuget.org/v3/catalog0/page879.json","@type":"CatalogPage","commitId":"dfa780ce-489f-4fdb-9f21-1a56bc8451fa","commitTimeStamp":"2015-04-27T21:13:37.3122763Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page880.json","@type":"CatalogPage","commitId":"c01ee9f4-745b-4e8b-82f8-ddddfbd6ef84","commitTimeStamp":"2015-04-27T21:19:15.548057Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page881.json","@type":"CatalogPage","commitId":"f2ae4139-1399-4965-82e1-9c5769f97d2c","commitTimeStamp":"2015-04-27T21:29:21.768306Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page882.json","@type":"CatalogPage","commitId":"d7551a8f-6b38-4be1-8c7b-a2ea0697cd07","commitTimeStamp":"2015-04-27T21:36:39.8000977Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page883.json","@type":"CatalogPage","commitId":"e237cb67-e210-4f93-a36c-ac53071b3903","commitTimeStamp":"2015-04-28T14:20:05.0567974Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page884.json","@type":"CatalogPage","commitId":"a7b1d3ce-4f21-4207-8d7b-182277917240","commitTimeStamp":"2015-04-29T03:47:43.4115949Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page885.json","@type":"CatalogPage","commitId":"3f434851-bb65-44e8-b4bd-c7eb3ada1f12","commitTimeStamp":"2015-04-29T14:10:20.2467981Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page886.json","@type":"CatalogPage","commitId":"0b04be33-3def-40a7-82f2-ba118023024f","commitTimeStamp":"2015-04-29T20:58:05.0871517Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page887.json","@type":"CatalogPage","commitId":"a82853e9-ef18-4665-a770-6f50e17679b5","commitTimeStamp":"2015-04-30T18:18:37.9307986Z","count":543},{"@id":"https://api.nuget.org/v3/catalog0/page888.json","@type":"CatalogPage","commitId":"d20a4958-79e5-45d9-9d76-313daa841c65","commitTimeStamp":"2015-05-01T07:50:44.18541Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page889.json","@type":"CatalogPage","commitId":"ec5c82ba-9ff2-4812-8690-5e0519128228","commitTimeStamp":"2015-05-01T20:18:04.3684275Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page890.json","@type":"CatalogPage","commitId":"f25a1d82-cf19-46dd-a9c1-fd7c565cbac3","commitTimeStamp":"2015-05-04T16:39:59.2714915Z","count":541},{"@id":"https://api.nuget.org/v3/catalog0/page891.json","@type":"CatalogPage","commitId":"436eab4e-85ee-4a0a-9bc5-401f8b29740a","commitTimeStamp":"2015-05-04T16:48:00.4721353Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page892.json","@type":"CatalogPage","commitId":"b88c8808-2c6e-4510-b417-573c99c72a98","commitTimeStamp":"2015-05-04T17:09:44.4948942Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page893.json","@type":"CatalogPage","commitId":"d6679758-8c7a-4ecf-bdfb-682f67d7545c","commitTimeStamp":"2015-05-04T21:19:17.5216804Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page894.json","@type":"CatalogPage","commitId":"65a6b41a-3a38-48a7-850f-0843c909137a","commitTimeStamp":"2015-05-05T18:01:59.5795726Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page895.json","@type":"CatalogPage","commitId":"8eae0e30-fe6c-42b4-870b-a0db73645d21","commitTimeStamp":"2015-05-06T17:43:46.6100714Z","count":538},{"@id":"https://api.nuget.org/v3/catalog0/page896.json","@type":"CatalogPage","commitId":"d54bc2ab-e685-4796-ab50-e4340f33b7cf","commitTimeStamp":"2015-05-07T05:59:23.5630806Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page897.json","@type":"CatalogPage","commitId":"b42451b8-c3c9-4652-9fd5-7b731a69968b","commitTimeStamp":"2015-05-07T18:51:15.1228904Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page898.json","@type":"CatalogPage","commitId":"6b0d7092-ad6a-4b01-ba3c-7e526af166f4","commitTimeStamp":"2015-05-08T14:09:21.7057467Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page899.json","@type":"CatalogPage","commitId":"9b272a1a-b63c-42ef-a804-ed520be33991","commitTimeStamp":"2015-05-09T23:30:08.9792606Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page900.json","@type":"CatalogPage","commitId":"8de63ecd-4355-4128-9551-3d6b89c96dae","commitTimeStamp":"2015-05-11T14:09:57.4042462Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page901.json","@type":"CatalogPage","commitId":"808daacc-d29e-4511-bb15-b2b3a6322b00","commitTimeStamp":"2015-05-12T12:10:06.1305419Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page902.json","@type":"CatalogPage","commitId":"ce7e4e4a-a554-4a70-8fca-a492cc1b7158","commitTimeStamp":"2015-05-12T22:32:42.3743535Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page903.json","@type":"CatalogPage","commitId":"b96171ca-46c3-4965-90bc-d9c657122a6c","commitTimeStamp":"2015-05-13T16:37:49.3533194Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page904.json","@type":"CatalogPage","commitId":"e0c7c6c4-c1ca-40ea-9de8-087266b0b029","commitTimeStamp":"2015-05-14T12:06:26.7108685Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page905.json","@type":"CatalogPage","commitId":"dbec35d5-814f-45a8-945f-47e3bd95cccc","commitTimeStamp":"2015-05-15T05:31:12.2785706Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page906.json","@type":"CatalogPage","commitId":"8efbcdd3-e670-4774-8b86-39b3848feda3","commitTimeStamp":"2015-05-15T15:23:07.4242738Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page907.json","@type":"CatalogPage","commitId":"8e78adcd-98eb-4549-a8e6-e9f441c6c175","commitTimeStamp":"2015-05-16T09:53:14.7157316Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page908.json","@type":"CatalogPage","commitId":"7fab05c8-2d10-4d29-af20-4138ece25c01","commitTimeStamp":"2015-05-17T03:14:27.3160184Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page909.json","@type":"CatalogPage","commitId":"54de8112-c6d4-4dab-a50c-b08d100163c4","commitTimeStamp":"2015-05-18T05:22:38.9745624Z","count":551},{"@id":"https://api.nuget.org/v3/catalog0/page910.json","@type":"CatalogPage","commitId":"fb068daf-48b8-448d-8c15-5c5cd1a492f9","commitTimeStamp":"2015-05-18T15:29:18.8237836Z","count":552},{"@id":"https://api.nuget.org/v3/catalog0/page911.json","@type":"CatalogPage","commitId":"a0bdba81-0170-4762-878e-cc5e40a9722c","commitTimeStamp":"2015-05-19T17:55:48.9862115Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page912.json","@type":"CatalogPage","commitId":"02c8ac73-dec9-499b-85cf-9c8d8e6b759c","commitTimeStamp":"2015-05-20T06:42:12.2445542Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page913.json","@type":"CatalogPage","commitId":"948c8268-71e3-4ed0-a6e3-6a0bd2d67221","commitTimeStamp":"2015-05-20T18:25:48.8375424Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page914.json","@type":"CatalogPage","commitId":"e999fc44-2213-411e-8bad-e6429685d440","commitTimeStamp":"2015-05-21T15:25:34.4322378Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page915.json","@type":"CatalogPage","commitId":"188458ba-8b6f-4a31-a195-674951600e5b","commitTimeStamp":"2015-05-22T08:10:55.9734081Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page916.json","@type":"CatalogPage","commitId":"bd4801f5-b78e-4922-ba44-f2fae418d320","commitTimeStamp":"2015-05-22T20:12:19.1986688Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page917.json","@type":"CatalogPage","commitId":"23cfd57c-e17d-4a9d-8c1f-d9e7e35a189e","commitTimeStamp":"2015-05-23T23:24:38.4651546Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page918.json","@type":"CatalogPage","commitId":"92c593fd-7942-44fe-a310-0752d46a95bb","commitTimeStamp":"2015-05-25T03:49:35.495416Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page919.json","@type":"CatalogPage","commitId":"85c0c2e7-b2d1-42c9-abad-6c4fc1f10a72","commitTimeStamp":"2015-05-26T03:28:37.4826522Z","count":535},{"@id":"https://api.nuget.org/v3/catalog0/page920.json","@type":"CatalogPage","commitId":"40c57eb8-3381-4530-874c-591dc6248b01","commitTimeStamp":"2015-05-26T13:35:49.5578989Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page921.json","@type":"CatalogPage","commitId":"645d17f9-19e7-455d-8ef9-614b0c177e7f","commitTimeStamp":"2015-05-27T04:12:34.899437Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page922.json","@type":"CatalogPage","commitId":"5ed476b4-a854-4731-83b0-6456adbb78ab","commitTimeStamp":"2015-05-27T21:58:38.6795215Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page923.json","@type":"CatalogPage","commitId":"c810ed31-a3ab-47d5-bbb0-301f58b9f2de","commitTimeStamp":"2015-05-28T15:20:53.9880476Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page924.json","@type":"CatalogPage","commitId":"f6968977-af34-4983-bc55-77487d35b937","commitTimeStamp":"2015-05-29T08:41:28.7955901Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page925.json","@type":"CatalogPage","commitId":"dae8a469-a99f-4ed7-a653-3c3d543f940d","commitTimeStamp":"2015-05-29T17:55:21.9246572Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page926.json","@type":"CatalogPage","commitId":"7ac449e8-c83b-4af8-bdaa-dc20ead7b2b7","commitTimeStamp":"2015-05-30T16:59:18.7085257Z","count":551},{"@id":"https://api.nuget.org/v3/catalog0/page927.json","@type":"CatalogPage","commitId":"72b8a90a-8cb5-4424-839d-540b8b2924c7","commitTimeStamp":"2015-05-31T08:50:16.9616097Z","count":551},{"@id":"https://api.nuget.org/v3/catalog0/page928.json","@type":"CatalogPage","commitId":"125da764-e802-48b4-ba38-b0cba87a6465","commitTimeStamp":"2015-05-31T15:40:36.28128Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page929.json","@type":"CatalogPage","commitId":"d1873068-f12c-41a3-8019-ca91db42344a","commitTimeStamp":"2015-06-01T05:59:13.5912663Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page930.json","@type":"CatalogPage","commitId":"6450449d-82d1-4cb6-a43f-ff31b768d4df","commitTimeStamp":"2015-06-01T12:47:16.098618Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page931.json","@type":"CatalogPage","commitId":"0dca9d15-7d9e-4533-a762-c71f8566c604","commitTimeStamp":"2015-06-01T16:52:44.9946807Z","count":551},{"@id":"https://api.nuget.org/v3/catalog0/page932.json","@type":"CatalogPage","commitId":"5d248fc9-ad02-4a0c-b8b7-bfc8dc45aea2","commitTimeStamp":"2015-06-02T09:15:22.354313Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page933.json","@type":"CatalogPage","commitId":"26ef12b3-588c-4109-aa52-5cf53f13cb63","commitTimeStamp":"2015-06-03T01:47:03.8582037Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page934.json","@type":"CatalogPage","commitId":"7bbada91-d41a-46db-ad37-3215b2d760d8","commitTimeStamp":"2015-06-03T19:12:47.6002671Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page935.json","@type":"CatalogPage","commitId":"c3979399-b4d4-47b2-9fa5-0ce5e5a8e1d1","commitTimeStamp":"2015-06-04T11:57:52.0414898Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page936.json","@type":"CatalogPage","commitId":"169a7412-3f60-4afd-8f0c-4451f4b72541","commitTimeStamp":"2015-06-04T21:49:22.0387124Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page937.json","@type":"CatalogPage","commitId":"d8be5455-bb0b-44e1-b65a-f5b48f71316f","commitTimeStamp":"2015-06-05T17:02:13.5699427Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page938.json","@type":"CatalogPage","commitId":"ede48cb0-5e53-42f9-8d12-81270311cc15","commitTimeStamp":"2015-06-07T05:16:28.2029028Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page939.json","@type":"CatalogPage","commitId":"85d39bde-e6a1-4976-a570-004681e90399","commitTimeStamp":"2015-06-08T05:57:06.9473534Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page940.json","@type":"CatalogPage","commitId":"9fe865d8-786f-4b36-b09c-5746cd67a81b","commitTimeStamp":"2015-06-08T20:43:52.3358062Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page941.json","@type":"CatalogPage","commitId":"544d3387-b401-4484-8b32-a8aae671f536","commitTimeStamp":"2015-06-09T11:42:30.2787225Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page942.json","@type":"CatalogPage","commitId":"f41733ee-748f-47ac-97bb-43e66c13f851","commitTimeStamp":"2015-06-09T23:33:54.0545116Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page943.json","@type":"CatalogPage","commitId":"42d5a883-3683-459b-b213-1c8e41bf42b2","commitTimeStamp":"2015-06-10T16:19:01.176625Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page944.json","@type":"CatalogPage","commitId":"269c6796-1df7-4ee9-996e-06be37d344c7","commitTimeStamp":"2015-06-11T13:54:38.5424039Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page945.json","@type":"CatalogPage","commitId":"b05a5b1d-52cb-4d14-880c-5fbff2d52a68","commitTimeStamp":"2015-06-12T11:25:40.1920012Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page946.json","@type":"CatalogPage","commitId":"a63764c6-e069-4e8c-b50a-c3f278e70842","commitTimeStamp":"2015-06-13T07:07:41.4475426Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page947.json","@type":"CatalogPage","commitId":"d98deb21-8cd8-4ae2-bca9-790c16b7eb91","commitTimeStamp":"2015-06-15T00:35:23.131463Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page948.json","@type":"CatalogPage","commitId":"176a68d9-7f9c-48da-a905-f51b3dfd4842","commitTimeStamp":"2015-06-15T18:45:56.1732349Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page949.json","@type":"CatalogPage","commitId":"19900cdd-ef21-4c73-aaab-f216e5c67019","commitTimeStamp":"2015-06-16T17:17:39.5457755Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page950.json","@type":"CatalogPage","commitId":"e11639ed-8c47-4b99-9599-fbce996483d5","commitTimeStamp":"2015-06-17T12:23:57.6463757Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page951.json","@type":"CatalogPage","commitId":"b48ec80c-da0d-41be-9004-12811617b704","commitTimeStamp":"2015-06-18T00:12:12.0058285Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page952.json","@type":"CatalogPage","commitId":"5a1c0b0b-2504-4b57-a243-23e9827ab9e1","commitTimeStamp":"2015-06-18T19:40:57.1346388Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page953.json","@type":"CatalogPage","commitId":"764c5b44-8592-4472-9c46-e67907527f44","commitTimeStamp":"2015-06-19T16:48:09.8492028Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page954.json","@type":"CatalogPage","commitId":"50fe6d33-b2e8-40e0-8bf4-16b027be867d","commitTimeStamp":"2015-06-20T23:24:04.3037601Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page955.json","@type":"CatalogPage","commitId":"7349e7b6-3566-40c6-bb31-6bf5aeb13ad1","commitTimeStamp":"2015-06-22T08:38:45.2340958Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page956.json","@type":"CatalogPage","commitId":"6dd6654f-19b2-46a1-9e47-4cf667a9c38f","commitTimeStamp":"2015-06-22T21:34:21.6184789Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page957.json","@type":"CatalogPage","commitId":"dc58194c-e26e-4185-b68e-e7cfb9923261","commitTimeStamp":"2015-06-23T10:44:53.59165Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page958.json","@type":"CatalogPage","commitId":"18016642-3b9e-4845-9483-3eb4ea720743","commitTimeStamp":"2015-06-24T03:51:55.1029299Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page959.json","@type":"CatalogPage","commitId":"e50d48f3-f62c-4dcc-9b26-3a24a7815094","commitTimeStamp":"2015-06-24T17:12:58.2112336Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page960.json","@type":"CatalogPage","commitId":"dfdf94f8-7f52-4cdc-8fc6-4c2a8c2e1744","commitTimeStamp":"2015-06-25T14:23:26.9846666Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page961.json","@type":"CatalogPage","commitId":"a2c58cb3-2fb9-4b22-8136-56b11f83f3b2","commitTimeStamp":"2015-06-26T08:23:17.0301672Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page962.json","@type":"CatalogPage","commitId":"6e79ee9a-61c7-4262-8d4b-fe7657c89492","commitTimeStamp":"2015-06-27T09:15:30.8099777Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page963.json","@type":"CatalogPage","commitId":"b0292c38-0d4b-4dc5-a496-bd29efb6bd7a","commitTimeStamp":"2015-06-28T21:01:20.7774358Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page964.json","@type":"CatalogPage","commitId":"63db1010-9ede-4a88-b274-ad0b61db2199","commitTimeStamp":"2015-06-29T18:37:42.5998606Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page965.json","@type":"CatalogPage","commitId":"fc2f9382-48c1-4262-b6fd-aeeb8db68ef6","commitTimeStamp":"2015-06-30T13:46:20.1319067Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page966.json","@type":"CatalogPage","commitId":"29406cc1-7351-4d6e-b8d7-abf1f4ff1c49","commitTimeStamp":"2015-06-30T20:53:13.1842241Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page967.json","@type":"CatalogPage","commitId":"eca815e6-8103-42e5-a326-6ef43a19a6cf","commitTimeStamp":"2015-07-01T16:49:46.3942473Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page968.json","@type":"CatalogPage","commitId":"39e97f21-0e7c-49e1-95cf-b7a78cc73b9f","commitTimeStamp":"2015-07-02T05:19:00.3796547Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page969.json","@type":"CatalogPage","commitId":"4516073c-e681-4a98-bf0c-ef67ef875d20","commitTimeStamp":"2015-07-02T17:30:22.2004858Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page970.json","@type":"CatalogPage","commitId":"f8368245-0740-429f-818c-1c67b785c300","commitTimeStamp":"2015-07-03T09:53:40.0789951Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page971.json","@type":"CatalogPage","commitId":"6f7483f2-6047-4da2-bcbd-0ceb33ea5128","commitTimeStamp":"2015-07-04T12:33:29.263643Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page972.json","@type":"CatalogPage","commitId":"35826232-752d-4b6c-bd07-b9d65fa8970a","commitTimeStamp":"2015-07-06T00:55:31.5360132Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page973.json","@type":"CatalogPage","commitId":"850042aa-3432-4971-ae86-dabd91886571","commitTimeStamp":"2015-07-06T17:52:00.1250889Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page974.json","@type":"CatalogPage","commitId":"9300a919-fd28-4563-af55-0428d86380a0","commitTimeStamp":"2015-07-07T11:21:59.3186139Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page975.json","@type":"CatalogPage","commitId":"32152225-918e-498f-b732-e5d4967f8956","commitTimeStamp":"2015-07-07T23:49:10.9432856Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page976.json","@type":"CatalogPage","commitId":"e9cefa4b-70b9-4c6b-ae7e-e17debb86e67","commitTimeStamp":"2015-07-08T15:01:27.7482223Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page977.json","@type":"CatalogPage","commitId":"79c59cc6-b000-4990-bccb-692c9b6966bc","commitTimeStamp":"2015-07-09T12:58:59.9945004Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page978.json","@type":"CatalogPage","commitId":"bd9635b3-fbe4-4115-a701-7bf63e9c7e1f","commitTimeStamp":"2015-07-10T03:55:59.1243203Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page979.json","@type":"CatalogPage","commitId":"1df9a979-fb88-40c5-a97f-158865c2c45d","commitTimeStamp":"2015-07-10T21:32:13.7487276Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page980.json","@type":"CatalogPage","commitId":"69b9141d-125e-4ac4-b24c-3d0afe1c6d2c","commitTimeStamp":"2015-07-11T20:57:03.8595568Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page981.json","@type":"CatalogPage","commitId":"7d69ff60-be6f-40dc-96c5-a3b030b3c66c","commitTimeStamp":"2015-07-12T18:18:25.5430436Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page982.json","@type":"CatalogPage","commitId":"b73ed3e1-751d-4c7f-b8ed-7c19fd0b37aa","commitTimeStamp":"2015-07-13T10:54:46.7059886Z","count":551},{"@id":"https://api.nuget.org/v3/catalog0/page983.json","@type":"CatalogPage","commitId":"91b15051-b946-4f1a-aa15-b50e82dfd9a1","commitTimeStamp":"2015-07-13T20:16:12.4053088Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page984.json","@type":"CatalogPage","commitId":"f897509a-3284-4ff9-b116-79ec441837d6","commitTimeStamp":"2015-07-14T09:08:45.3683659Z","count":552},{"@id":"https://api.nuget.org/v3/catalog0/page985.json","@type":"CatalogPage","commitId":"d1d05d5f-956d-4d4d-80b7-aebbea16f185","commitTimeStamp":"2015-07-14T16:22:55.4720271Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page986.json","@type":"CatalogPage","commitId":"70cae255-c636-4ff8-954a-0ac19760dc39","commitTimeStamp":"2015-07-15T08:39:14.8709587Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page987.json","@type":"CatalogPage","commitId":"48771a92-292f-4200-8729-a83779b3435b","commitTimeStamp":"2015-07-15T12:47:27.9312788Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page988.json","@type":"CatalogPage","commitId":"5ad8fbee-7e48-49b6-b061-4d59b26106d3","commitTimeStamp":"2015-07-16T05:35:54.3838095Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page989.json","@type":"CatalogPage","commitId":"30c7363f-3837-4386-a40e-6f881b5d39a4","commitTimeStamp":"2015-07-16T16:27:42.4562876Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page990.json","@type":"CatalogPage","commitId":"96e1f984-5723-453c-ba93-56ba10b58fa9","commitTimeStamp":"2015-07-17T02:24:46.9029404Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page991.json","@type":"CatalogPage","commitId":"108b4b7f-a09e-4f95-9945-26cb790cfd3f","commitTimeStamp":"2015-07-17T12:37:59.0573928Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page992.json","@type":"CatalogPage","commitId":"6f062eda-8b0b-45c3-b0d0-ec34bdaf9e4b","commitTimeStamp":"2015-07-18T01:33:55.4523764Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page993.json","@type":"CatalogPage","commitId":"91d1e57d-3616-4b19-ab46-e326754ea5a3","commitTimeStamp":"2015-07-18T12:58:09.8473034Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page994.json","@type":"CatalogPage","commitId":"69eb0337-b76d-44eb-921b-aa7e0efffcf8","commitTimeStamp":"2015-07-20T07:36:01.2104122Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page995.json","@type":"CatalogPage","commitId":"7d947f98-f9b9-4290-b201-87b6b7ed373e","commitTimeStamp":"2015-07-20T19:38:59.7131636Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page996.json","@type":"CatalogPage","commitId":"6b23fe99-6f89-4b5e-b34d-a9d89ad361a5","commitTimeStamp":"2015-07-21T08:19:01.000453Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page997.json","@type":"CatalogPage","commitId":"dbd669ae-e87a-440e-88fd-ab12fb1c0116","commitTimeStamp":"2015-07-21T18:10:38.530009Z","count":551},{"@id":"https://api.nuget.org/v3/catalog0/page998.json","@type":"CatalogPage","commitId":"dbb9f5c0-0c88-4cc3-b7e2-f5b744c11dd5","commitTimeStamp":"2015-07-22T08:00:42.4409393Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page999.json","@type":"CatalogPage","commitId":"77d373a7-0953-4b8d-ab57-09aa5efb1dc2","commitTimeStamp":"2015-07-22T14:19:13.6817918Z","count":551},{"@id":"https://api.nuget.org/v3/catalog0/page1000.json","@type":"CatalogPage","commitId":"38748a61-cc79-428a-a994-b924e92a9981","commitTimeStamp":"2015-07-23T00:14:59.5780714Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1001.json","@type":"CatalogPage","commitId":"7b4a812a-8ac5-4d53-8320-a6ff2abc14e4","commitTimeStamp":"2015-07-23T10:36:08.9166395Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1002.json","@type":"CatalogPage","commitId":"876b9d76-2316-4eae-bb9d-c683989347ea","commitTimeStamp":"2015-07-23T19:20:36.4266341Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1003.json","@type":"CatalogPage","commitId":"60d57116-8b83-4948-851b-e914dbc63b0e","commitTimeStamp":"2015-07-24T11:10:58.2059676Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1004.json","@type":"CatalogPage","commitId":"a493bf22-a96f-4cef-869e-2247317e27b7","commitTimeStamp":"2015-07-25T08:02:00.689977Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1005.json","@type":"CatalogPage","commitId":"adbb1b6b-ad68-493c-8bfb-6ea4484a6ed8","commitTimeStamp":"2015-07-26T18:16:22.5851192Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1006.json","@type":"CatalogPage","commitId":"7103b42d-6c21-4158-81e1-0923862368a3","commitTimeStamp":"2015-07-27T11:33:03.418905Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1007.json","@type":"CatalogPage","commitId":"4d324283-25b2-46b2-a435-b8a394fbd0ea","commitTimeStamp":"2015-07-27T18:29:29.8937737Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page1008.json","@type":"CatalogPage","commitId":"a68a88e9-1c9f-4990-9197-010bf03f7bab","commitTimeStamp":"2015-07-28T09:31:04.5113901Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1009.json","@type":"CatalogPage","commitId":"e5676a8c-9fc4-4bd3-a023-a3d8afc7edeb","commitTimeStamp":"2015-07-28T21:14:17.506104Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1010.json","@type":"CatalogPage","commitId":"61b4ba7e-f812-4717-a79d-dd222a38705b","commitTimeStamp":"2015-07-29T09:15:07.9969673Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1011.json","@type":"CatalogPage","commitId":"435ecc6a-f5c5-4447-ac0f-53401c6dad58","commitTimeStamp":"2015-07-29T15:42:35.8773624Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1012.json","@type":"CatalogPage","commitId":"c4abfee2-7dca-4ba6-9e11-f68d4d475ece","commitTimeStamp":"2015-07-30T01:48:06.6465394Z","count":551},{"@id":"https://api.nuget.org/v3/catalog0/page1013.json","@type":"CatalogPage","commitId":"df615807-cadc-441e-9e8f-5d94d9d2bbed","commitTimeStamp":"2015-07-30T12:27:15.614311Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1014.json","@type":"CatalogPage","commitId":"29a365e1-312e-4adf-884e-4baee9e21d36","commitTimeStamp":"2015-07-30T22:04:35.8303462Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1015.json","@type":"CatalogPage","commitId":"b16e1ac4-130b-4f5e-b6fe-15c7b58e96a1","commitTimeStamp":"2015-07-31T11:14:08.2922056Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1016.json","@type":"CatalogPage","commitId":"123d1125-965d-4aa0-a12f-d9ba70090fcb","commitTimeStamp":"2015-08-01T03:38:33.1155504Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1017.json","@type":"CatalogPage","commitId":"5d0883de-eafc-48ae-959a-1b28b4c00481","commitTimeStamp":"2015-08-02T06:05:47.9146096Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1018.json","@type":"CatalogPage","commitId":"bd7f5e90-c340-4590-b502-eeca4cc6ad25","commitTimeStamp":"2015-08-03T03:13:04.3859565Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1019.json","@type":"CatalogPage","commitId":"b72b1233-2d5f-40e0-b971-78a70e6b2da9","commitTimeStamp":"2015-08-03T19:25:35.2251119Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1020.json","@type":"CatalogPage","commitId":"09cab9b5-2238-4ddf-80a4-d1a7e419fc5d","commitTimeStamp":"2015-08-04T12:52:46.6202013Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1021.json","@type":"CatalogPage","commitId":"7919e056-f280-427d-8b10-bcef24150103","commitTimeStamp":"2015-08-05T00:24:01.8682053Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1022.json","@type":"CatalogPage","commitId":"9f19fcca-959a-4366-a8f4-f491a068f8ed","commitTimeStamp":"2015-08-05T19:33:47.3382602Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1023.json","@type":"CatalogPage","commitId":"0969f794-8184-48bc-8d8f-5ae2b3c3cf2e","commitTimeStamp":"2015-08-06T11:36:18.5278964Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1024.json","@type":"CatalogPage","commitId":"3280da5f-8e8d-449a-8e2d-b9e2609eea85","commitTimeStamp":"2015-08-06T20:08:44.197389Z","count":543},{"@id":"https://api.nuget.org/v3/catalog0/page1025.json","@type":"CatalogPage","commitId":"d737ad48-3805-4c7e-8e20-5c3a96f627f5","commitTimeStamp":"2015-08-07T07:43:41.9618365Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1026.json","@type":"CatalogPage","commitId":"2b08ecd1-5e67-45ee-b63d-05663ff18213","commitTimeStamp":"2015-08-08T01:33:05.812028Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1027.json","@type":"CatalogPage","commitId":"8b2e974d-45b2-4198-ac8b-d48ff0b3a662","commitTimeStamp":"2015-08-08T23:47:09.1754849Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1028.json","@type":"CatalogPage","commitId":"7b2e59f7-f16c-44ad-9783-d5bbd5faf3d5","commitTimeStamp":"2015-08-10T03:20:02.8711102Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1029.json","@type":"CatalogPage","commitId":"fc19e638-a392-4f7b-81af-b10dedf8ccae","commitTimeStamp":"2015-08-10T19:57:21.0802628Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1030.json","@type":"CatalogPage","commitId":"f3fb2b6a-d1aa-4a42-b69e-7180c6d519b6","commitTimeStamp":"2015-08-11T14:09:36.8822476Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1031.json","@type":"CatalogPage","commitId":"a1b2ee3e-f673-4b31-b22a-b5ea56526de5","commitTimeStamp":"2015-08-12T03:02:27.3988701Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1032.json","@type":"CatalogPage","commitId":"af07a658-aadf-4a8b-8608-3d8658890240","commitTimeStamp":"2015-08-12T12:47:51.3615759Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1033.json","@type":"CatalogPage","commitId":"525932b9-b1ad-46e4-aada-7f8b9db5d467","commitTimeStamp":"2015-08-12T21:58:34.7188177Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1034.json","@type":"CatalogPage","commitId":"059c4a93-e53c-480a-8596-13d59810b8d5","commitTimeStamp":"2015-08-13T10:44:47.156238Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1035.json","@type":"CatalogPage","commitId":"a7c22932-f4de-42ad-ab4e-8d4406a4bd69","commitTimeStamp":"2015-08-13T18:18:42.4038206Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1036.json","@type":"CatalogPage","commitId":"7b8f794c-dcde-4603-b7d7-c2f2a04ee94e","commitTimeStamp":"2015-08-14T08:09:09.0906922Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1037.json","@type":"CatalogPage","commitId":"31c41cb3-97a6-41a4-b99e-c44bfdcfb195","commitTimeStamp":"2015-08-14T17:36:18.4728064Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1038.json","@type":"CatalogPage","commitId":"824562de-6c6d-45ca-b119-eaae5394343e","commitTimeStamp":"2015-08-15T06:58:01.1839258Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1039.json","@type":"CatalogPage","commitId":"f1133084-4a5e-40b2-a0f6-9abccc305d89","commitTimeStamp":"2015-08-16T13:04:29.3400053Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1040.json","@type":"CatalogPage","commitId":"632f45aa-99e2-4f2e-8358-e649e0637cd2","commitTimeStamp":"2015-08-17T12:35:44.0911277Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1041.json","@type":"CatalogPage","commitId":"882944d1-ccfd-47eb-a486-f7f9a2e241d2","commitTimeStamp":"2015-08-18T00:35:48.3322781Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1042.json","@type":"CatalogPage","commitId":"0e2188a3-180b-4d41-91f7-93ccfb948f1c","commitTimeStamp":"2015-08-18T17:54:41.2212562Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1043.json","@type":"CatalogPage","commitId":"ac772f7c-fcfd-4dd5-80c0-2396891ad8ce","commitTimeStamp":"2015-08-19T12:12:37.8660414Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1044.json","@type":"CatalogPage","commitId":"a7a5e1b9-9da2-4e55-baa0-854a844ad4da","commitTimeStamp":"2015-08-19T19:34:28.7498331Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1045.json","@type":"CatalogPage","commitId":"8a54714e-a767-4ae3-afc4-14bfcfccccf6","commitTimeStamp":"2015-08-20T11:58:23.7799642Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1046.json","@type":"CatalogPage","commitId":"e8933c8f-1c61-472d-92fb-35580c38f461","commitTimeStamp":"2015-08-21T04:46:00.2237858Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1047.json","@type":"CatalogPage","commitId":"33210397-ceb3-4d92-b41d-745b5bf67877","commitTimeStamp":"2015-08-21T18:56:11.3334585Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1048.json","@type":"CatalogPage","commitId":"b74a1e56-10c8-4e9a-a15e-56805cdd55cd","commitTimeStamp":"2015-08-22T23:17:02.011737Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1049.json","@type":"CatalogPage","commitId":"201c46b7-d355-47d0-a2c9-fa0d6710f477","commitTimeStamp":"2015-08-24T05:12:21.779258Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1050.json","@type":"CatalogPage","commitId":"c43d9247-1a91-4abb-89bc-52c780297ebb","commitTimeStamp":"2015-08-24T18:06:31.667194Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1051.json","@type":"CatalogPage","commitId":"e0eee1a0-9064-401b-93f3-0aa0d4f90aed","commitTimeStamp":"2015-08-25T10:39:41.8286193Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1052.json","@type":"CatalogPage","commitId":"7d757800-9dbe-4077-8ca6-28581376e138","commitTimeStamp":"2015-08-25T23:25:54.8671775Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1053.json","@type":"CatalogPage","commitId":"192318ae-72a3-457c-8293-101e90eaa805","commitTimeStamp":"2015-08-26T09:31:43.2772623Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1054.json","@type":"CatalogPage","commitId":"6e2b8314-67b5-4f26-a6a8-f11b75dcf889","commitTimeStamp":"2015-08-26T20:12:33.903492Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1055.json","@type":"CatalogPage","commitId":"6603dca0-5640-4aa4-8970-2449a736855c","commitTimeStamp":"2015-08-27T12:50:06.7938926Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1056.json","@type":"CatalogPage","commitId":"f4e8d192-35c9-4658-b926-d7cbb5347247","commitTimeStamp":"2015-08-28T00:21:41.1861275Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1057.json","@type":"CatalogPage","commitId":"95baaac3-64cc-4826-87ce-8f96ef577ec7","commitTimeStamp":"2015-08-28T16:16:02.8632073Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1058.json","@type":"CatalogPage","commitId":"7c9bee00-beeb-4300-ac0c-dabc82a7c258","commitTimeStamp":"2015-08-29T18:07:45.3985512Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1059.json","@type":"CatalogPage","commitId":"708ecf7a-46bf-4ee6-a232-0f01662dbff9","commitTimeStamp":"2015-08-30T08:36:38.0702302Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1060.json","@type":"CatalogPage","commitId":"2039b873-379a-4a48-9573-b0ee792fa980","commitTimeStamp":"2015-08-31T03:59:12.8394401Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1061.json","@type":"CatalogPage","commitId":"9327456a-5a60-4f27-9ff2-36593255ef55","commitTimeStamp":"2015-08-31T18:55:17.2066478Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1062.json","@type":"CatalogPage","commitId":"6466948d-852b-4f78-9e37-90edf52d03f5","commitTimeStamp":"2015-09-01T07:39:24.9995578Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page1063.json","@type":"CatalogPage","commitId":"bcb98247-f832-4849-94ef-b433d68fc7cb","commitTimeStamp":"2015-09-01T13:42:08.3484177Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1064.json","@type":"CatalogPage","commitId":"5ecf7fe0-fb49-4625-ac97-97d4fb80f1df","commitTimeStamp":"2015-09-01T20:15:30.187315Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1065.json","@type":"CatalogPage","commitId":"210c0ed0-ab31-4c3b-b0a5-41ec7e987685","commitTimeStamp":"2015-09-02T02:19:46.3238995Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1066.json","@type":"CatalogPage","commitId":"3c83efcc-3b87-471c-b54e-466593012915","commitTimeStamp":"2015-09-02T16:55:08.4569691Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1067.json","@type":"CatalogPage","commitId":"4e7dd2cc-0cf9-4d70-950d-581d9de84989","commitTimeStamp":"2015-09-03T07:09:55.1385033Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1068.json","@type":"CatalogPage","commitId":"e1500c88-0023-4074-8bef-60c8bb42b227","commitTimeStamp":"2015-09-03T17:43:01.4844087Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1069.json","@type":"CatalogPage","commitId":"5f57849a-3662-4a44-be24-b2287f9ec652","commitTimeStamp":"2015-09-04T10:12:10.4538249Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1070.json","@type":"CatalogPage","commitId":"770ce3fd-0d8b-4b2d-a486-7dab03eec44e","commitTimeStamp":"2015-09-04T22:56:14.8650969Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1071.json","@type":"CatalogPage","commitId":"2f842794-3d03-4556-89d7-8826e9fdccda","commitTimeStamp":"2015-09-06T02:24:05.6768546Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1072.json","@type":"CatalogPage","commitId":"14f3b40f-bba9-4466-9a3b-a8dc0d75dbc0","commitTimeStamp":"2015-09-06T21:16:09.0659432Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1073.json","@type":"CatalogPage","commitId":"9b7233de-809e-45ba-ab58-70e4192009a9","commitTimeStamp":"2015-09-07T15:25:04.8506275Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1074.json","@type":"CatalogPage","commitId":"07371744-2a67-41a0-aeec-97974b297528","commitTimeStamp":"2015-09-08T02:21:41.6740834Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1075.json","@type":"CatalogPage","commitId":"c6407b5f-142d-41b6-9845-5cab7df5fbbe","commitTimeStamp":"2015-09-08T14:05:53.5418214Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1076.json","@type":"CatalogPage","commitId":"a6b6e64d-53a2-47b1-8ce1-7084c741bb31","commitTimeStamp":"2015-09-09T04:10:00.4504001Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1077.json","@type":"CatalogPage","commitId":"d8eaf0a3-e728-4436-9123-6411d3d0f783","commitTimeStamp":"2015-09-09T17:07:26.8615975Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1078.json","@type":"CatalogPage","commitId":"98716f1f-466d-47fc-95ff-af9c1a6ad065","commitTimeStamp":"2015-09-10T09:34:39.0122902Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1079.json","@type":"CatalogPage","commitId":"89b40c7c-5902-4ad1-861a-6d6ef5b755b2","commitTimeStamp":"2015-09-10T21:46:04.9756589Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1080.json","@type":"CatalogPage","commitId":"bf5242f7-0cdb-4ae5-b8eb-4ee76978414d","commitTimeStamp":"2015-09-11T13:35:34.8179225Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1081.json","@type":"CatalogPage","commitId":"32d33ff7-f2c7-40a7-aace-19327ed0fdb5","commitTimeStamp":"2015-09-12T07:57:16.5091548Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1082.json","@type":"CatalogPage","commitId":"bfa64329-2275-4983-9de6-088fbecc9a83","commitTimeStamp":"2015-09-13T13:49:06.806229Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1083.json","@type":"CatalogPage","commitId":"3053a850-42e6-4929-ab90-bd09e2343bb9","commitTimeStamp":"2015-09-14T07:45:28.1641908Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1084.json","@type":"CatalogPage","commitId":"6de73b89-8a4f-4d0f-810b-df889dcb0884","commitTimeStamp":"2015-09-14T18:26:10.6100225Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1085.json","@type":"CatalogPage","commitId":"00ee3c6c-6a63-4db1-a00d-b271d987b789","commitTimeStamp":"2015-09-15T12:21:59.9168011Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1086.json","@type":"CatalogPage","commitId":"4beb9e51-dd35-4491-ac9e-b75e7c448e80","commitTimeStamp":"2015-09-16T07:01:29.6823709Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1087.json","@type":"CatalogPage","commitId":"536d40cf-93d3-444f-b2f0-f1dc26549a1f","commitTimeStamp":"2015-09-16T17:21:53.3679321Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1088.json","@type":"CatalogPage","commitId":"115104c1-ba12-43c5-ac60-2eb5907a55b8","commitTimeStamp":"2015-09-17T05:35:16.5515888Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1089.json","@type":"CatalogPage","commitId":"63b76ae5-a024-4b9b-bdde-30e65caa3439","commitTimeStamp":"2015-09-17T18:33:14.1644107Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1090.json","@type":"CatalogPage","commitId":"2da587b6-cef9-48dc-bf72-069eae2571cd","commitTimeStamp":"2015-09-18T11:31:33.7622927Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1091.json","@type":"CatalogPage","commitId":"d6eae5b7-6f86-4c8f-ad0f-731ab7f3cb5f","commitTimeStamp":"2015-09-18T23:42:05.8430418Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1092.json","@type":"CatalogPage","commitId":"379ee16f-921f-465c-9b3a-48e4aea8a5c1","commitTimeStamp":"2015-09-20T11:07:33.406439Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1093.json","@type":"CatalogPage","commitId":"eb755c6b-a794-4d44-a978-91de0bcaedc0","commitTimeStamp":"2015-09-21T11:03:52.5893849Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1094.json","@type":"CatalogPage","commitId":"76fa03c8-f81d-4480-bd69-38631d37d58c","commitTimeStamp":"2015-09-21T21:59:15.756433Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1095.json","@type":"CatalogPage","commitId":"58f5f855-ce6d-41c8-a12d-8fa5050565e2","commitTimeStamp":"2015-09-22T11:39:55.211341Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1096.json","@type":"CatalogPage","commitId":"be704f17-1b54-4f36-8cf3-6d6e314459fe","commitTimeStamp":"2015-09-22T20:27:24.799278Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1097.json","@type":"CatalogPage","commitId":"35dde721-d805-4d8f-9051-0efb91cf5d36","commitTimeStamp":"2015-09-23T09:38:10.7650885Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1098.json","@type":"CatalogPage","commitId":"2d2e573d-c02e-454a-b7df-2b4ee605549f","commitTimeStamp":"2015-09-23T23:19:31.2138508Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1099.json","@type":"CatalogPage","commitId":"c6743e1d-0b99-4fa5-ae82-d46526c66f4c","commitTimeStamp":"2015-09-24T12:43:24.6513763Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1100.json","@type":"CatalogPage","commitId":"acdf94f0-b339-48f8-bd76-ab945f19d30c","commitTimeStamp":"2015-09-25T07:45:33.8244123Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1101.json","@type":"CatalogPage","commitId":"9cbbd92b-6e03-4c8d-a40a-5af1286c8ace","commitTimeStamp":"2015-09-25T18:41:40.267258Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1102.json","@type":"CatalogPage","commitId":"6b6abc64-7d2c-463c-a333-8c6010234981","commitTimeStamp":"2015-09-26T18:26:17.6307813Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1103.json","@type":"CatalogPage","commitId":"88cd272c-fe7e-41ba-bdca-e73a938ab90f","commitTimeStamp":"2015-09-27T22:51:21.2482324Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1104.json","@type":"CatalogPage","commitId":"72fe5431-8b00-485f-bc1a-26871377177a","commitTimeStamp":"2015-09-28T12:55:06.2879569Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1105.json","@type":"CatalogPage","commitId":"1e5680f6-28fe-4b99-a524-2ae28045a5b5","commitTimeStamp":"2015-09-29T06:31:07.4252301Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1106.json","@type":"CatalogPage","commitId":"249d60c5-e562-4fb9-a26c-2938b1b45321","commitTimeStamp":"2015-09-29T20:26:51.0668927Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1107.json","@type":"CatalogPage","commitId":"d05d50c0-04a1-4506-a0be-c72722a191ad","commitTimeStamp":"2015-09-30T14:40:58.0462581Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1108.json","@type":"CatalogPage","commitId":"9a4d30d6-6bf7-4530-ba03-1d640ed53aac","commitTimeStamp":"2015-09-30T21:15:14.471136Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1109.json","@type":"CatalogPage","commitId":"7a97ecee-8c9d-431d-b7d2-b520e8cee410","commitTimeStamp":"2015-10-01T12:49:57.0306955Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1110.json","@type":"CatalogPage","commitId":"1efbac15-79d2-489b-86f6-4d8083321d1f","commitTimeStamp":"2015-10-02T00:17:29.3638859Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1111.json","@type":"CatalogPage","commitId":"91ce9c89-47b1-43c2-8884-50d46d7fda95","commitTimeStamp":"2015-10-02T14:09:33.4726319Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1112.json","@type":"CatalogPage","commitId":"4b68eeb9-186c-4012-ba04-b92cb3b7cb13","commitTimeStamp":"2015-10-03T13:24:02.1605243Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1113.json","@type":"CatalogPage","commitId":"b1cd11c2-4716-436a-8919-843f754a5a9e","commitTimeStamp":"2015-10-04T04:28:58.2152123Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1114.json","@type":"CatalogPage","commitId":"9d91f212-40c6-498c-91ed-847fe6d5d522","commitTimeStamp":"2015-10-04T07:41:52.7804757Z","count":533},{"@id":"https://api.nuget.org/v3/catalog0/page1115.json","@type":"CatalogPage","commitId":"92f6ed32-b6ec-4a1d-9faa-42c9d27f4135","commitTimeStamp":"2015-10-04T07:45:51.1230979Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page1116.json","@type":"CatalogPage","commitId":"c4e8c2e4-9075-44dc-9468-7f53b802839b","commitTimeStamp":"2015-10-04T07:48:58.8658581Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page1117.json","@type":"CatalogPage","commitId":"8fe02e74-aa3b-498c-8f40-438d0f22e79c","commitTimeStamp":"2015-10-04T07:51:41.6226398Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page1118.json","@type":"CatalogPage","commitId":"1d437cb4-7e37-44f4-b5c7-6df53a9fa284","commitTimeStamp":"2015-10-04T07:54:49.2215187Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page1119.json","@type":"CatalogPage","commitId":"4b39b1ce-bc90-4bee-be82-2541c1cd3fbe","commitTimeStamp":"2015-10-04T07:57:49.3221129Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page1120.json","@type":"CatalogPage","commitId":"418b7b51-4b52-489b-a51d-5494bcb5c89d","commitTimeStamp":"2015-10-04T08:01:24.2299994Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page1121.json","@type":"CatalogPage","commitId":"fcc5b1e9-cd54-480f-afc6-d65b043ab552","commitTimeStamp":"2015-10-04T08:05:14.7498338Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page1122.json","@type":"CatalogPage","commitId":"d4ab37e1-b906-4d5f-a83c-8698ffd9b51d","commitTimeStamp":"2015-10-05T00:34:30.2455219Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1123.json","@type":"CatalogPage","commitId":"4cd30ad4-c690-4a61-9afd-77c4909e701a","commitTimeStamp":"2015-10-05T15:37:49.7190373Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1124.json","@type":"CatalogPage","commitId":"ad46fd1b-38f4-4f70-b3b6-c91c7b8c57b1","commitTimeStamp":"2015-10-06T09:45:26.0884845Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1125.json","@type":"CatalogPage","commitId":"a60be053-cbd4-45f2-83a3-cd111359353d","commitTimeStamp":"2015-10-06T18:02:03.908456Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1126.json","@type":"CatalogPage","commitId":"a1c3b14f-16f9-4ba4-b6dc-9526d0396988","commitTimeStamp":"2015-10-07T08:18:24.2564183Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1127.json","@type":"CatalogPage","commitId":"e2b00f90-5cfb-4408-8c8e-a1a125d04e97","commitTimeStamp":"2015-10-07T17:19:31.2480528Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1128.json","@type":"CatalogPage","commitId":"9fbf18de-26d2-4e03-977f-ee9f2717cb16","commitTimeStamp":"2015-10-08T10:12:14.9674096Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1129.json","@type":"CatalogPage","commitId":"ecc732c7-1be6-4bc9-b2c3-9db9c75bc847","commitTimeStamp":"2015-10-08T18:01:34.7471491Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1130.json","@type":"CatalogPage","commitId":"71f9a227-5615-4e4c-949b-d7a929bbb986","commitTimeStamp":"2015-10-09T10:48:21.7893432Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page1131.json","@type":"CatalogPage","commitId":"0454b4de-536d-4634-b6c1-2a0d5779416b","commitTimeStamp":"2015-10-10T08:09:01.5049984Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page1132.json","@type":"CatalogPage","commitId":"4ef0169b-9248-41a5-89cc-f66d7208e399","commitTimeStamp":"2015-10-11T03:50:29.0587324Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1133.json","@type":"CatalogPage","commitId":"689264f7-602e-4662-bf28-7f92e6099226","commitTimeStamp":"2015-10-12T09:09:38.3667946Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1134.json","@type":"CatalogPage","commitId":"26702433-0b23-4e7c-9d0b-d0f117d4c867","commitTimeStamp":"2015-10-12T19:56:28.0884643Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1135.json","@type":"CatalogPage","commitId":"9cbb4106-3805-4fad-9dfa-e8d9f6aac100","commitTimeStamp":"2015-10-13T12:38:24.9435514Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1136.json","@type":"CatalogPage","commitId":"095dcee7-0a42-4aa5-a685-b444200333bf","commitTimeStamp":"2015-10-13T21:58:51.5856953Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1137.json","@type":"CatalogPage","commitId":"a37f5cc9-cc70-4e76-a109-b37c7a17fd10","commitTimeStamp":"2015-10-14T09:18:56.6951747Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1138.json","@type":"CatalogPage","commitId":"c5f9a10b-302b-473f-94e9-a35bd54ad7b8","commitTimeStamp":"2015-10-14T19:33:40.7568507Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1139.json","@type":"CatalogPage","commitId":"30006da1-6a83-4dee-aaee-73e53a9f70bd","commitTimeStamp":"2015-10-15T09:16:16.8448528Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1140.json","@type":"CatalogPage","commitId":"e77e0734-ff96-412c-a959-cfe25e74dccf","commitTimeStamp":"2015-10-15T15:53:45.4680135Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1141.json","@type":"CatalogPage","commitId":"fe4d9e3b-2c8b-4449-8229-ac95301f3668","commitTimeStamp":"2015-10-15T19:27:22.4420776Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1142.json","@type":"CatalogPage","commitId":"cd5055cc-fd5f-4ed9-b77c-506e52dde05d","commitTimeStamp":"2015-10-16T09:39:06.7981448Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1143.json","@type":"CatalogPage","commitId":"bc8b7b0a-d8ed-4a16-ac97-af66629d69be","commitTimeStamp":"2015-10-16T16:02:41.8230693Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1144.json","@type":"CatalogPage","commitId":"7a27976d-e77a-40f3-902b-c58cee577293","commitTimeStamp":"2015-10-17T14:35:11.9220389Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1145.json","@type":"CatalogPage","commitId":"93bd6944-b42e-4be6-9718-4e6183ac6747","commitTimeStamp":"2015-10-18T20:36:45.9552377Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1146.json","@type":"CatalogPage","commitId":"1a034783-b73f-4d88-a953-5a25816a6423","commitTimeStamp":"2015-10-19T12:20:25.6575055Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1147.json","@type":"CatalogPage","commitId":"55b7d251-ac69-483d-9f1a-df3019fa9c80","commitTimeStamp":"2015-10-19T22:37:36.4395168Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1148.json","@type":"CatalogPage","commitId":"43d7b2b0-a7f2-4a85-ae4d-af864872a60e","commitTimeStamp":"2015-10-20T11:57:35.5450752Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1149.json","@type":"CatalogPage","commitId":"9ea69064-6a3e-4c1f-b588-176b6b0f3f0d","commitTimeStamp":"2015-10-20T22:47:18.6344016Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1150.json","@type":"CatalogPage","commitId":"da518f48-f995-4251-bca6-376c203f83d3","commitTimeStamp":"2015-10-21T15:40:23.0597507Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1151.json","@type":"CatalogPage","commitId":"2df284e1-0185-4a1e-b1b1-a9a476588974","commitTimeStamp":"2015-10-22T07:12:21.9782247Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1152.json","@type":"CatalogPage","commitId":"fd1fd37f-7176-4e37-8d0d-a8b38a2bf0cd","commitTimeStamp":"2015-10-22T19:21:34.2727966Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1153.json","@type":"CatalogPage","commitId":"768110f4-ee45-40be-a55d-8748082902f0","commitTimeStamp":"2015-10-23T12:21:03.022191Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1154.json","@type":"CatalogPage","commitId":"446af7a4-b74d-4919-95a4-9227b695fd21","commitTimeStamp":"2015-10-24T09:56:49.1692989Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1155.json","@type":"CatalogPage","commitId":"ac4d0cdd-8982-4850-9af3-3e621a396f0f","commitTimeStamp":"2015-10-25T03:52:37.5949348Z","count":533},{"@id":"https://api.nuget.org/v3/catalog0/page1156.json","@type":"CatalogPage","commitId":"82526609-6961-4784-a1ff-eb173839f183","commitTimeStamp":"2015-10-26T02:37:34.2641085Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1157.json","@type":"CatalogPage","commitId":"7b188bb4-3de2-496a-8a29-e1802c955533","commitTimeStamp":"2015-10-26T15:51:04.8440061Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1158.json","@type":"CatalogPage","commitId":"14381849-9612-41e7-adfb-ad627d905cff","commitTimeStamp":"2015-10-27T04:58:52.9427071Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1159.json","@type":"CatalogPage","commitId":"0a9db8b2-3388-47a7-a566-c595fc100df9","commitTimeStamp":"2015-10-27T14:48:43.9955105Z","count":542},{"@id":"https://api.nuget.org/v3/catalog0/page1160.json","@type":"CatalogPage","commitId":"75ba5489-6a21-4f91-9184-9ab9c44fb0a2","commitTimeStamp":"2015-10-27T17:09:25.9664365Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1161.json","@type":"CatalogPage","commitId":"d98da0de-b6fc-482a-b829-6c0b771574c2","commitTimeStamp":"2015-10-28T09:17:56.2441213Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1162.json","@type":"CatalogPage","commitId":"a5adfc67-66de-4502-9a56-721494967bd3","commitTimeStamp":"2015-10-28T17:58:43.6632928Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1163.json","@type":"CatalogPage","commitId":"56c4a703-c718-410b-8b16-998c75857be8","commitTimeStamp":"2015-10-29T09:25:08.7257005Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1164.json","@type":"CatalogPage","commitId":"ac764ec1-4c7a-44b7-80d7-94f317e4ecf4","commitTimeStamp":"2015-10-29T17:41:55.036968Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1165.json","@type":"CatalogPage","commitId":"2c130d4d-382e-4882-a694-dd41c527b942","commitTimeStamp":"2015-10-30T09:25:25.9829614Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1166.json","@type":"CatalogPage","commitId":"c9b8cace-29a8-4d9a-8fb9-e447054bdae8","commitTimeStamp":"2015-10-31T01:17:29.6714107Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1167.json","@type":"CatalogPage","commitId":"c44dcf2f-0149-43fa-850b-dcb110fb2797","commitTimeStamp":"2015-11-01T04:35:05.5129847Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1168.json","@type":"CatalogPage","commitId":"4c022714-2a75-4756-91cc-601ec4913b28","commitTimeStamp":"2015-11-01T23:44:47.1498726Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1169.json","@type":"CatalogPage","commitId":"914cd4a5-6e97-4b2d-9efd-eb376832c00c","commitTimeStamp":"2015-11-02T11:43:25.2113988Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1170.json","@type":"CatalogPage","commitId":"eabdb469-e14c-4b01-86a8-5307c9ddef7b","commitTimeStamp":"2015-11-02T21:00:57.460113Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1171.json","@type":"CatalogPage","commitId":"e2193186-0857-4ebe-a604-407c8cdf7815","commitTimeStamp":"2015-11-03T13:32:17.4473024Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1172.json","@type":"CatalogPage","commitId":"77956395-b17c-4fdd-af54-0eb1303f3bf7","commitTimeStamp":"2015-11-04T00:40:13.0589773Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1173.json","@type":"CatalogPage","commitId":"723ca571-ec44-4e00-beb6-e382c823ed3c","commitTimeStamp":"2015-11-04T15:38:15.5493394Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1174.json","@type":"CatalogPage","commitId":"deb60173-bc94-42d7-b244-a0fa7d1494e7","commitTimeStamp":"2015-11-05T05:38:42.1678138Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1175.json","@type":"CatalogPage","commitId":"3e30256f-0421-400b-be4b-642c1cd37766","commitTimeStamp":"2015-11-05T19:43:15.2134458Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1176.json","@type":"CatalogPage","commitId":"d46e49d4-ebd5-4e6b-a61e-06428d353026","commitTimeStamp":"2015-11-06T10:18:44.2272196Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1177.json","@type":"CatalogPage","commitId":"7a65ce36-f7ae-4873-ab58-62882c07acdd","commitTimeStamp":"2015-11-06T21:43:42.9249146Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1178.json","@type":"CatalogPage","commitId":"10c21bbf-10cc-485c-bf20-c8c4c0aba2da","commitTimeStamp":"2015-11-08T07:46:02.6762837Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1179.json","@type":"CatalogPage","commitId":"35cc664a-b161-4eff-9d98-54e9438b1bd0","commitTimeStamp":"2015-11-09T05:46:53.3037863Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1180.json","@type":"CatalogPage","commitId":"ce72850c-c9e5-4480-9933-8ed496e79341","commitTimeStamp":"2015-11-09T19:15:42.7160333Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1181.json","@type":"CatalogPage","commitId":"36e0bc8c-263b-4cb8-9af4-672bc27a8e91","commitTimeStamp":"2015-11-10T14:07:04.1858693Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1182.json","@type":"CatalogPage","commitId":"fe867b96-69f6-4590-be45-3f0cbf1c2a15","commitTimeStamp":"2015-11-11T02:55:02.5639286Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1183.json","@type":"CatalogPage","commitId":"9c4a0f67-d94e-4b25-a05a-637929b7663b","commitTimeStamp":"2015-11-11T18:01:30.8460633Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1184.json","@type":"CatalogPage","commitId":"6e1bf44a-03d7-436e-9d45-de24e9205fd2","commitTimeStamp":"2015-11-12T08:03:52.0861041Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page1185.json","@type":"CatalogPage","commitId":"135e1bc5-94c3-4563-81af-0c551fc73a52","commitTimeStamp":"2015-11-12T16:11:43.1505429Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1186.json","@type":"CatalogPage","commitId":"52676fc9-e0d5-428d-bed1-42ddc155cd37","commitTimeStamp":"2015-11-13T06:56:51.4418874Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1187.json","@type":"CatalogPage","commitId":"e9566ee9-89f9-4c5a-8292-3e3078f87582","commitTimeStamp":"2015-11-13T17:15:08.5309646Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1188.json","@type":"CatalogPage","commitId":"8348944f-9485-4521-a517-72759573b0ee","commitTimeStamp":"2015-11-14T13:46:16.011612Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1189.json","@type":"CatalogPage","commitId":"ebeedaad-dab3-4937-b759-39fef400233e","commitTimeStamp":"2015-11-15T15:24:45.1987126Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1190.json","@type":"CatalogPage","commitId":"b4adbbf9-aab7-4888-abd1-b23446ff69c9","commitTimeStamp":"2015-11-16T11:07:32.0276633Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1191.json","@type":"CatalogPage","commitId":"6bc9070b-5712-46bb-8d9f-f3b37aa28edf","commitTimeStamp":"2015-11-16T19:32:01.1697344Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1192.json","@type":"CatalogPage","commitId":"ca351e86-50f9-4835-9ee7-593276b49fda","commitTimeStamp":"2015-11-17T12:19:00.4923516Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page1193.json","@type":"CatalogPage","commitId":"0fb78389-da77-4ea9-a939-8140b2047e92","commitTimeStamp":"2015-11-17T20:10:15.3531397Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1194.json","@type":"CatalogPage","commitId":"33b75393-72b4-4c3c-a299-31e75e95ae7a","commitTimeStamp":"2015-11-18T12:55:36.6382892Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1195.json","@type":"CatalogPage","commitId":"79636d70-14fa-4f07-8ffa-09ff045596f5","commitTimeStamp":"2015-11-18T16:32:54.6512386Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1196.json","@type":"CatalogPage","commitId":"06b2020c-5756-4a8b-81df-9ad946a15fa0","commitTimeStamp":"2015-11-19T09:18:30.042033Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1197.json","@type":"CatalogPage","commitId":"74529395-a50a-4cba-8e0c-34a100402a66","commitTimeStamp":"2015-11-19T18:58:10.5651505Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1198.json","@type":"CatalogPage","commitId":"b6fea39c-ed0a-4c76-ac3b-a29fe23bc69d","commitTimeStamp":"2015-11-20T10:34:30.0321991Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1199.json","@type":"CatalogPage","commitId":"3df47a76-0e47-4b73-ac7f-e5be658f2686","commitTimeStamp":"2015-11-20T19:14:25.2815836Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1200.json","@type":"CatalogPage","commitId":"c64e1c95-b50a-4fa3-bfc6-c061401ef3f0","commitTimeStamp":"2015-11-21T15:48:39.2648508Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1201.json","@type":"CatalogPage","commitId":"fcd5a542-6d88-45fb-9f8e-85c491051d49","commitTimeStamp":"2015-11-23T00:58:59.0393366Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1202.json","@type":"CatalogPage","commitId":"2fc130cc-bdd7-4352-98a3-082b401f6c73","commitTimeStamp":"2015-11-23T14:50:32.3256484Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1203.json","@type":"CatalogPage","commitId":"d0fb64c3-3c32-413e-be5d-766be056ee8e","commitTimeStamp":"2015-11-24T08:29:07.5489969Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1204.json","@type":"CatalogPage","commitId":"2ecd200a-8d0f-4773-8074-622c14ee8fed","commitTimeStamp":"2015-11-24T16:55:11.4579157Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1205.json","@type":"CatalogPage","commitId":"c910e88e-b0b5-477c-85c8-18207a1968da","commitTimeStamp":"2015-11-25T08:09:28.5378342Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1206.json","@type":"CatalogPage","commitId":"5552df73-125d-4363-afb2-e0771c80c988","commitTimeStamp":"2015-11-25T18:17:10.4759678Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1207.json","@type":"CatalogPage","commitId":"00a49830-769e-4684-bf16-5a32b12b75e3","commitTimeStamp":"2015-11-26T08:33:51.9676544Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1208.json","@type":"CatalogPage","commitId":"99ce8e84-c2b3-4ac0-b912-02cb7f71d043","commitTimeStamp":"2015-11-26T18:54:10.0119672Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1209.json","@type":"CatalogPage","commitId":"e4b83f5d-fccd-4af0-bd63-8a47a3ad5974","commitTimeStamp":"2015-11-27T12:47:35.0013812Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1210.json","@type":"CatalogPage","commitId":"6fc4f9c4-fb8e-4cd9-9b1d-2b9590713c69","commitTimeStamp":"2015-11-28T02:27:24.7316448Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1211.json","@type":"CatalogPage","commitId":"9b3252e0-0d29-4ea9-9ca0-6fc85f1caaa0","commitTimeStamp":"2015-11-28T19:16:29.6147853Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1212.json","@type":"CatalogPage","commitId":"8c3025de-1601-4387-9d22-f7619d4fe5a2","commitTimeStamp":"2015-11-29T23:08:07.2500752Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1213.json","@type":"CatalogPage","commitId":"208abca5-a14f-4ae9-9dff-2e6d5867f258","commitTimeStamp":"2015-11-30T13:35:30.1848561Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1214.json","@type":"CatalogPage","commitId":"083295a7-0ce5-4e99-9e68-d80f8c1ea935","commitTimeStamp":"2015-12-01T04:01:26.8824971Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1215.json","@type":"CatalogPage","commitId":"4539e865-e3dc-42e3-93af-6235f5da57c4","commitTimeStamp":"2015-12-01T14:09:36.3549133Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1216.json","@type":"CatalogPage","commitId":"25292f72-7350-42e3-a9e8-cc33fc45c68d","commitTimeStamp":"2015-12-01T20:34:24.9428498Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1217.json","@type":"CatalogPage","commitId":"2f20259c-e8e6-4f90-9fde-c1e42be18561","commitTimeStamp":"2015-12-02T08:00:49.3608094Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1218.json","@type":"CatalogPage","commitId":"acb76f8d-fe5b-4fe3-b419-ce504dd803e4","commitTimeStamp":"2015-12-02T14:57:48.3207646Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page1219.json","@type":"CatalogPage","commitId":"36400169-41df-44b8-aef5-8fd665560e2a","commitTimeStamp":"2015-12-03T04:11:38.2964827Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1220.json","@type":"CatalogPage","commitId":"430cb892-f7bb-48dd-a879-c52bbaddef59","commitTimeStamp":"2015-12-03T14:42:57.4559666Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1221.json","@type":"CatalogPage","commitId":"4fc1b04d-7da8-4a5b-a9eb-e410d9e7e059","commitTimeStamp":"2015-12-03T22:09:58.7590949Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1222.json","@type":"CatalogPage","commitId":"2ec69b52-5ba3-4c7b-af5a-9af29b0d43ab","commitTimeStamp":"2015-12-04T13:45:09.5723183Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1223.json","@type":"CatalogPage","commitId":"b48932e5-7280-435e-88e2-d591585d266f","commitTimeStamp":"2015-12-05T06:31:29.5956857Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1224.json","@type":"CatalogPage","commitId":"461f4e73-abd5-4406-882e-750978c5f465","commitTimeStamp":"2015-12-06T10:42:16.0622672Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1225.json","@type":"CatalogPage","commitId":"30fc7a87-6cec-4ace-bd7f-6ef144324c53","commitTimeStamp":"2015-12-07T09:18:20.1657619Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1226.json","@type":"CatalogPage","commitId":"cca6124d-39d7-42ff-8612-b01f2b0e3c51","commitTimeStamp":"2015-12-07T20:59:35.0002203Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1227.json","@type":"CatalogPage","commitId":"03de1ece-9bb9-4f92-9066-b0ce9e8a2471","commitTimeStamp":"2015-12-08T09:53:29.4488172Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1228.json","@type":"CatalogPage","commitId":"c573fae7-9d68-4270-8e07-daffa45418a9","commitTimeStamp":"2015-12-08T18:23:41.5580672Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1229.json","@type":"CatalogPage","commitId":"e785fb02-c46c-45aa-8b84-72d79125883f","commitTimeStamp":"2015-12-09T10:43:02.0085642Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1230.json","@type":"CatalogPage","commitId":"c7fb6c05-67e9-440a-841e-907a77712471","commitTimeStamp":"2015-12-09T18:58:54.8814747Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1231.json","@type":"CatalogPage","commitId":"a96c9949-87b3-4e13-b035-7984086b107d","commitTimeStamp":"2015-12-10T05:39:41.0599789Z","count":551},{"@id":"https://api.nuget.org/v3/catalog0/page1232.json","@type":"CatalogPage","commitId":"fd84c014-1c34-424b-8447-5535de60a247","commitTimeStamp":"2015-12-10T14:13:40.9897139Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1233.json","@type":"CatalogPage","commitId":"06d776ab-2110-483e-b98f-e05e03334262","commitTimeStamp":"2015-12-10T19:51:45.1973671Z","count":551},{"@id":"https://api.nuget.org/v3/catalog0/page1234.json","@type":"CatalogPage","commitId":"84c44e1d-31b7-4231-9cce-256fc47b51a3","commitTimeStamp":"2015-12-11T05:57:05.5399775Z","count":551},{"@id":"https://api.nuget.org/v3/catalog0/page1235.json","@type":"CatalogPage","commitId":"246809c3-13d0-42a7-b3de-772d0effce8c","commitTimeStamp":"2015-12-11T11:32:55.6484105Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1236.json","@type":"CatalogPage","commitId":"083e0fc7-4077-4c4e-97e9-98a32f98e3b5","commitTimeStamp":"2015-12-11T16:34:52.0239177Z","count":554},{"@id":"https://api.nuget.org/v3/catalog0/page1237.json","@type":"CatalogPage","commitId":"48824139-dd7a-4918-b011-44d81c283d0a","commitTimeStamp":"2015-12-12T03:25:47.4265328Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1238.json","@type":"CatalogPage","commitId":"cee8c4d0-49e0-408f-b313-93ec1bcdf2fc","commitTimeStamp":"2015-12-12T19:01:23.2766958Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1239.json","@type":"CatalogPage","commitId":"040e645f-7271-4d63-b4f7-f9bcdce65aed","commitTimeStamp":"2015-12-13T17:06:54.4057517Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1240.json","@type":"CatalogPage","commitId":"e377f654-120b-4eff-ae3e-07a108f91e9d","commitTimeStamp":"2015-12-14T09:47:20.2913091Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1241.json","@type":"CatalogPage","commitId":"962367b3-bb54-425d-8144-62c7a872df34","commitTimeStamp":"2015-12-14T15:19:55.3652265Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1242.json","@type":"CatalogPage","commitId":"620cfdbe-cb0e-450c-b540-c7e32392d0bf","commitTimeStamp":"2015-12-15T06:09:06.3648576Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1243.json","@type":"CatalogPage","commitId":"ada4c796-519f-48f7-b9fb-4459086b68dc","commitTimeStamp":"2015-12-15T17:09:34.676873Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1244.json","@type":"CatalogPage","commitId":"202fa187-29e6-4ada-8b8e-76382e982e15","commitTimeStamp":"2015-12-15T23:55:50.0075095Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page1245.json","@type":"CatalogPage","commitId":"9d9db4f2-209e-4c90-b5e5-7088ca8e9e5c","commitTimeStamp":"2015-12-16T14:03:55.8433985Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1246.json","@type":"CatalogPage","commitId":"6bbebe11-63f5-4e31-9783-b17d93ab8659","commitTimeStamp":"2015-12-17T03:57:23.6005067Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1247.json","@type":"CatalogPage","commitId":"9dfc7fc9-824d-42b0-9f46-40080ea1e791","commitTimeStamp":"2015-12-17T16:35:05.0577391Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1248.json","@type":"CatalogPage","commitId":"fb41cc04-496b-4520-b329-d19473319324","commitTimeStamp":"2015-12-18T07:16:10.229815Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1249.json","@type":"CatalogPage","commitId":"7751f2c3-75ec-4d91-b226-61b61976415a","commitTimeStamp":"2015-12-18T17:49:36.1347509Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1250.json","@type":"CatalogPage","commitId":"e1f2f27f-b09d-459d-97e0-b37a28b3e9b5","commitTimeStamp":"2015-12-19T15:00:23.7287684Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1251.json","@type":"CatalogPage","commitId":"f01a04d0-c1e4-40cc-a0ba-5319b8c20c17","commitTimeStamp":"2015-12-20T05:19:44.3136067Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1252.json","@type":"CatalogPage","commitId":"ecb42bbf-e099-4daa-956f-af549490c060","commitTimeStamp":"2015-12-21T13:08:09.6553121Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1253.json","@type":"CatalogPage","commitId":"4edd7303-ef17-4a22-bdc4-bc79dd569518","commitTimeStamp":"2015-12-22T06:36:15.6061356Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1254.json","@type":"CatalogPage","commitId":"90621b39-881d-4c7e-a3b1-e405f8bc48ec","commitTimeStamp":"2015-12-22T17:05:31.8013188Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page1255.json","@type":"CatalogPage","commitId":"28c2e806-7702-475a-bb59-a38c760a6a63","commitTimeStamp":"2015-12-23T04:07:03.095502Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1256.json","@type":"CatalogPage","commitId":"9b4e5030-8ecb-4cb2-8f02-f4b3e519b881","commitTimeStamp":"2015-12-23T09:23:22.7595487Z","count":536},{"@id":"https://api.nuget.org/v3/catalog0/page1257.json","@type":"CatalogPage","commitId":"67e2b87d-57e8-4c09-91ac-3f78af5a9e21","commitTimeStamp":"2015-12-23T15:56:50.1605415Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1258.json","@type":"CatalogPage","commitId":"737ce7b6-bcb9-42b5-8e7e-a85b94c81d5b","commitTimeStamp":"2015-12-24T09:46:12.3177653Z","count":551},{"@id":"https://api.nuget.org/v3/catalog0/page1259.json","@type":"CatalogPage","commitId":"0f67a53e-59ac-4690-b2e8-8c5853636ab9","commitTimeStamp":"2015-12-24T15:41:22.4539619Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1260.json","@type":"CatalogPage","commitId":"4827a0bd-130a-49c5-b114-8dc9608b5406","commitTimeStamp":"2015-12-25T08:14:25.0427142Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1261.json","@type":"CatalogPage","commitId":"d71a83aa-096a-4cb2-8570-a480fc26532d","commitTimeStamp":"2015-12-26T02:43:43.3699155Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1262.json","@type":"CatalogPage","commitId":"59271934-6ab5-48dd-a3b6-dffb4697ed2f","commitTimeStamp":"2015-12-27T02:48:27.634649Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1263.json","@type":"CatalogPage","commitId":"3402b14c-2614-4be7-bbc9-ac110a1db263","commitTimeStamp":"2015-12-27T22:38:48.5240233Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1264.json","@type":"CatalogPage","commitId":"0ea13e5b-20bd-4bc2-9769-e4576a200b51","commitTimeStamp":"2015-12-28T17:46:09.4357295Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1265.json","@type":"CatalogPage","commitId":"2eaf6981-3c99-4d1c-9ef7-f0293b2d9cee","commitTimeStamp":"2015-12-29T09:41:48.2103068Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1266.json","@type":"CatalogPage","commitId":"7bbf5d37-8b91-4197-90f2-2b91e21bb180","commitTimeStamp":"2015-12-29T20:47:05.1305069Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1267.json","@type":"CatalogPage","commitId":"4b1c8361-6cf7-4b97-b3a8-572d8dd8bce4","commitTimeStamp":"2015-12-30T16:40:59.5728392Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1268.json","@type":"CatalogPage","commitId":"3b865561-72b7-441f-9bac-a8f25a0f942e","commitTimeStamp":"2015-12-31T15:00:18.9624292Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1269.json","@type":"CatalogPage","commitId":"28d66861-3c0f-4def-aaeb-b1fca71d6002","commitTimeStamp":"2016-01-01T21:13:12.1905966Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1270.json","@type":"CatalogPage","commitId":"f4ff6e17-b722-4b63-8852-66b4b6516f49","commitTimeStamp":"2016-01-03T01:47:55.1056238Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1271.json","@type":"CatalogPage","commitId":"fc06d0cc-875a-469c-b10a-518c4e89a7ea","commitTimeStamp":"2016-01-04T01:05:26.0974103Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1272.json","@type":"CatalogPage","commitId":"6cb54ede-9f29-49c9-9af1-9af5bbbf7529","commitTimeStamp":"2016-01-04T16:10:12.074023Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1273.json","@type":"CatalogPage","commitId":"2dee47ad-ef0f-4807-ad85-a8743f160f54","commitTimeStamp":"2016-01-05T08:42:19.0999329Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1274.json","@type":"CatalogPage","commitId":"e054f262-d86a-4951-a371-1e7662c8f479","commitTimeStamp":"2016-01-05T16:01:11.8880426Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1275.json","@type":"CatalogPage","commitId":"618a3cc8-7161-48a5-9447-d89e6cfc84e8","commitTimeStamp":"2016-01-06T04:09:37.1279396Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1276.json","@type":"CatalogPage","commitId":"672367f1-95d3-4ab3-a538-e63768051d9e","commitTimeStamp":"2016-01-06T13:41:48.7864889Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1277.json","@type":"CatalogPage","commitId":"47be32df-6c0d-4e22-aacf-78781eafde86","commitTimeStamp":"2016-01-06T20:37:29.9372472Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1278.json","@type":"CatalogPage","commitId":"d3f5189b-f0cb-4b0d-9eb8-7c2372982fea","commitTimeStamp":"2016-01-07T06:50:59.8827912Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1279.json","@type":"CatalogPage","commitId":"ca6194a1-e71e-428d-b3c3-0fd70707d94a","commitTimeStamp":"2016-01-07T16:04:19.6824671Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1280.json","@type":"CatalogPage","commitId":"6d2defca-66bf-4f49-80a6-42169fe8a325","commitTimeStamp":"2016-01-08T02:04:31.9572146Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1281.json","@type":"CatalogPage","commitId":"c07788bd-69c3-4613-80eb-c52232afc1c9","commitTimeStamp":"2016-01-08T13:31:44.6111172Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1282.json","@type":"CatalogPage","commitId":"44fc3a87-bc88-45a1-bdec-cb30317ded15","commitTimeStamp":"2016-01-08T23:53:21.2585494Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1283.json","@type":"CatalogPage","commitId":"fc574007-390a-471a-bb64-d1c6c1fa2092","commitTimeStamp":"2016-01-09T12:17:27.4738887Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1284.json","@type":"CatalogPage","commitId":"c35f01b5-5e50-49bb-a20e-d334036748ad","commitTimeStamp":"2016-01-10T00:07:17.9972902Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1285.json","@type":"CatalogPage","commitId":"5a191db4-8574-461e-ae71-4ab031d4a1bc","commitTimeStamp":"2016-01-10T12:03:37.7831894Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1286.json","@type":"CatalogPage","commitId":"d66dffd5-32b5-4d05-aaf8-c029fa71a2b1","commitTimeStamp":"2016-01-10T21:43:58.951002Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1287.json","@type":"CatalogPage","commitId":"e9813358-d203-4b0d-985e-95f49af6c170","commitTimeStamp":"2016-01-11T07:44:17.1451Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1288.json","@type":"CatalogPage","commitId":"a2baa563-339c-4a04-9c1c-4c84ad95bc1b","commitTimeStamp":"2016-01-11T14:03:46.2439965Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1289.json","@type":"CatalogPage","commitId":"25a341ca-7c2c-4e7b-bc53-7ba7f0444448","commitTimeStamp":"2016-01-11T18:32:10.7486934Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1290.json","@type":"CatalogPage","commitId":"9fdb6d7b-97bb-4b87-9a71-aae4e40c7ec3","commitTimeStamp":"2016-01-12T01:33:31.5416717Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1291.json","@type":"CatalogPage","commitId":"69f7932c-22fe-4da6-b91c-af548f39f0ac","commitTimeStamp":"2016-01-12T08:27:31.7776428Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1292.json","@type":"CatalogPage","commitId":"da73ae5f-98bb-45b1-9dab-99969de5ae95","commitTimeStamp":"2016-01-12T14:06:46.8602011Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1293.json","@type":"CatalogPage","commitId":"68f75953-4297-49d6-92f3-5ea44b1119a1","commitTimeStamp":"2016-01-12T18:10:14.986442Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1294.json","@type":"CatalogPage","commitId":"7bc11ee8-8f42-4cd9-a0a6-32d532ed59cd","commitTimeStamp":"2016-01-13T02:03:59.3737099Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1295.json","@type":"CatalogPage","commitId":"92fafd09-cd8c-4d0f-b1b7-8db5fa3ca99d","commitTimeStamp":"2016-01-13T08:03:20.0554039Z","count":551},{"@id":"https://api.nuget.org/v3/catalog0/page1296.json","@type":"CatalogPage","commitId":"6d81ecb4-145b-488c-898e-998ee577fc61","commitTimeStamp":"2016-01-13T10:31:00.7790306Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1297.json","@type":"CatalogPage","commitId":"ced44878-2591-4dae-a2dd-e0af89c6520c","commitTimeStamp":"2016-01-13T13:43:47.8605926Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1298.json","@type":"CatalogPage","commitId":"7a026857-9f36-461a-8367-3baaaf7b0ff4","commitTimeStamp":"2016-01-13T16:05:19.7480665Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1299.json","@type":"CatalogPage","commitId":"42ccf3cf-bdd4-4660-98a0-7e85b72e16bc","commitTimeStamp":"2016-01-13T18:32:49.4355024Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1300.json","@type":"CatalogPage","commitId":"7c51a2eb-dc87-40a8-831b-83469b2526d7","commitTimeStamp":"2016-01-13T22:11:37.7649356Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1301.json","@type":"CatalogPage","commitId":"e8ac41de-7e27-4800-8734-93bfc963b581","commitTimeStamp":"2016-01-14T02:11:36.8776109Z","count":558},{"@id":"https://api.nuget.org/v3/catalog0/page1302.json","@type":"CatalogPage","commitId":"40197b86-8476-49ef-a658-043d6ccf1faf","commitTimeStamp":"2016-01-14T06:04:46.4846191Z","count":553},{"@id":"https://api.nuget.org/v3/catalog0/page1303.json","@type":"CatalogPage","commitId":"242439f2-f5cb-4502-8d10-557434520f3d","commitTimeStamp":"2016-01-14T08:31:42.7203776Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1304.json","@type":"CatalogPage","commitId":"093d341b-f3d6-41d1-bb64-8f15c776ba00","commitTimeStamp":"2016-01-14T12:09:30.9757295Z","count":552},{"@id":"https://api.nuget.org/v3/catalog0/page1305.json","@type":"CatalogPage","commitId":"594c118a-cef0-4bb0-a768-faa81713b56e","commitTimeStamp":"2016-01-14T15:27:52.4861527Z","count":551},{"@id":"https://api.nuget.org/v3/catalog0/page1306.json","@type":"CatalogPage","commitId":"4b65eb31-7e76-4d20-b31e-308593af4868","commitTimeStamp":"2016-01-14T18:11:07.4945951Z","count":552},{"@id":"https://api.nuget.org/v3/catalog0/page1307.json","@type":"CatalogPage","commitId":"eda5522b-ff40-4fdf-8eb9-92c360ba06a0","commitTimeStamp":"2016-01-14T22:05:00.4864953Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1308.json","@type":"CatalogPage","commitId":"fa026695-3f54-4a4d-9cdb-09cba26f7592","commitTimeStamp":"2016-01-15T01:37:40.565487Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1309.json","@type":"CatalogPage","commitId":"02842ef9-7e5c-4df5-9dad-fa09bf7675da","commitTimeStamp":"2016-01-15T04:02:48.8858301Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1310.json","@type":"CatalogPage","commitId":"58d8856f-51f1-45b8-ae9a-744ed275ba75","commitTimeStamp":"2016-01-15T08:05:02.7506195Z","count":552},{"@id":"https://api.nuget.org/v3/catalog0/page1311.json","@type":"CatalogPage","commitId":"56bf4d8e-047c-41ab-b698-c8113623eab9","commitTimeStamp":"2016-01-15T11:17:33.5429105Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1312.json","@type":"CatalogPage","commitId":"732ed97d-86fa-4f73-a5ab-8966986e6caf","commitTimeStamp":"2016-01-15T14:05:00.6271222Z","count":552},{"@id":"https://api.nuget.org/v3/catalog0/page1313.json","@type":"CatalogPage","commitId":"c652a5a3-a0ad-4986-bcf3-229aa33af5b0","commitTimeStamp":"2016-01-15T16:18:09.8452301Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1314.json","@type":"CatalogPage","commitId":"f362e4f0-e7b3-469b-9f63-5551a3a5ec3f","commitTimeStamp":"2016-01-15T20:08:09.150867Z","count":552},{"@id":"https://api.nuget.org/v3/catalog0/page1315.json","@type":"CatalogPage","commitId":"b9182d85-0396-4fcc-ab41-4f6f46048037","commitTimeStamp":"2016-01-16T00:08:17.7388537Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1316.json","@type":"CatalogPage","commitId":"ee67ddf0-a956-43d5-a869-6df3238a43f4","commitTimeStamp":"2016-01-16T03:38:34.7076983Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1317.json","@type":"CatalogPage","commitId":"8d7cb231-d0de-4a7e-a6e8-4bd820c422f6","commitTimeStamp":"2016-01-16T20:54:08.9489887Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1318.json","@type":"CatalogPage","commitId":"b3caaeab-0dc4-4503-b18c-1f0c7083bcd5","commitTimeStamp":"2016-01-17T18:06:33.7078505Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1319.json","@type":"CatalogPage","commitId":"2e55b690-d6c4-487c-8602-a2bf6ebd6ed7","commitTimeStamp":"2016-01-18T10:48:07.6713799Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1320.json","@type":"CatalogPage","commitId":"72533a57-2e77-44e2-b104-ca7e2c332c6b","commitTimeStamp":"2016-01-18T18:51:38.2775612Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1321.json","@type":"CatalogPage","commitId":"0e4fbdbd-34a1-47de-a3fd-a53bc5219ba5","commitTimeStamp":"2016-01-19T07:19:30.2224457Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1322.json","@type":"CatalogPage","commitId":"a31fbfd2-a0e0-4615-8d1f-04248fe4dc61","commitTimeStamp":"2016-01-19T14:26:16.3083829Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1323.json","@type":"CatalogPage","commitId":"7feb2410-c278-421b-abaf-8e5ce713beb2","commitTimeStamp":"2016-01-20T02:00:34.8868577Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1324.json","@type":"CatalogPage","commitId":"b2ab16e5-7ae0-4a86-a196-b5f18fe73820","commitTimeStamp":"2016-01-20T11:43:48.7771459Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1325.json","@type":"CatalogPage","commitId":"b4980306-be53-462f-9582-57cc9ebff7ad","commitTimeStamp":"2016-01-20T21:01:48.9635806Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1326.json","@type":"CatalogPage","commitId":"ab705804-8d0d-48c4-be24-04abecf82bd5","commitTimeStamp":"2016-01-21T14:30:06.0512904Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1327.json","@type":"CatalogPage","commitId":"43ac1ff5-a3dc-4d8a-8f3f-f9a5627f3a65","commitTimeStamp":"2016-01-22T00:57:58.8251016Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1328.json","@type":"CatalogPage","commitId":"902deb9d-f7ba-4ee8-a5e7-81b04ac1e11b","commitTimeStamp":"2016-01-22T13:45:54.964249Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1329.json","@type":"CatalogPage","commitId":"e41c091d-f2d6-4d9f-89ac-790f3730a87c","commitTimeStamp":"2016-01-23T02:09:29.7851893Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1330.json","@type":"CatalogPage","commitId":"0a4f8564-40a0-4faa-934e-4b273abc09b1","commitTimeStamp":"2016-01-23T18:00:15.3856108Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page1331.json","@type":"CatalogPage","commitId":"cd382108-64a3-4d3a-ae9b-94c565882869","commitTimeStamp":"2016-01-24T17:31:40.9407434Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1332.json","@type":"CatalogPage","commitId":"a2ad5507-e351-4ab3-93e5-58e01a4f3334","commitTimeStamp":"2016-01-25T09:40:51.9382531Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1333.json","@type":"CatalogPage","commitId":"6a300530-1c10-4443-a522-4d2e1b3d51dc","commitTimeStamp":"2016-01-25T16:49:42.2188681Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1334.json","@type":"CatalogPage","commitId":"44e5b0cc-a5cc-485e-8dd5-599e38a0827f","commitTimeStamp":"2016-01-26T02:36:52.8718224Z","count":534},{"@id":"https://api.nuget.org/v3/catalog0/page1335.json","@type":"CatalogPage","commitId":"e114b218-b552-49df-8c69-c89481abc06f","commitTimeStamp":"2016-01-26T13:19:50.2755861Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1336.json","@type":"CatalogPage","commitId":"aac694c2-168f-42e2-84f5-3ce79e01910e","commitTimeStamp":"2016-01-27T04:10:20.8633167Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1337.json","@type":"CatalogPage","commitId":"1976602e-0ed8-4cf0-8a3b-f33c02785b46","commitTimeStamp":"2016-01-27T14:02:46.8557087Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1338.json","@type":"CatalogPage","commitId":"f13bb214-3748-44d4-8101-265731ad6539","commitTimeStamp":"2016-01-27T20:00:09.1195827Z","count":538},{"@id":"https://api.nuget.org/v3/catalog0/page1339.json","@type":"CatalogPage","commitId":"fc7ec1ee-314e-45a6-9399-c842e5a40f18","commitTimeStamp":"2016-01-27T20:05:53.3833994Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page1340.json","@type":"CatalogPage","commitId":"c12f0995-9a44-43d2-b450-4a1c55751a67","commitTimeStamp":"2016-01-27T20:37:41.3205126Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1341.json","@type":"CatalogPage","commitId":"3c4036ce-ba5a-477a-85f4-69d0256aa537","commitTimeStamp":"2016-01-27T21:23:49.3776015Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page1342.json","@type":"CatalogPage","commitId":"684897b6-4e4b-43be-816b-adc09c79ccc5","commitTimeStamp":"2016-01-27T22:36:59.3154202Z","count":541},{"@id":"https://api.nuget.org/v3/catalog0/page1343.json","@type":"CatalogPage","commitId":"70868067-b3fd-46eb-9c50-934266e6b242","commitTimeStamp":"2016-01-28T11:58:11.3566727Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1344.json","@type":"CatalogPage","commitId":"71749b4c-daf5-4d40-8f93-b429166ed780","commitTimeStamp":"2016-01-28T21:27:31.9699657Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1345.json","@type":"CatalogPage","commitId":"02132485-c40f-44d8-8e99-72eef6a0b940","commitTimeStamp":"2016-01-29T11:04:33.5768282Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1346.json","@type":"CatalogPage","commitId":"6172d8bd-0e36-461b-bcfe-2c1b8d2852d6","commitTimeStamp":"2016-01-30T07:23:09.8608817Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1347.json","@type":"CatalogPage","commitId":"1f15b520-8954-4ea7-a592-783f62864e25","commitTimeStamp":"2016-01-31T07:34:43.0607213Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1348.json","@type":"CatalogPage","commitId":"48055064-01c7-4250-9af9-eb92a9d388a6","commitTimeStamp":"2016-02-01T06:33:21.3939216Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1349.json","@type":"CatalogPage","commitId":"12734508-c3d0-4af1-8919-38d1f1e7dcf4","commitTimeStamp":"2016-02-01T14:37:04.0154318Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1350.json","@type":"CatalogPage","commitId":"7ee2c9ba-3422-4705-8bce-77f45032aef4","commitTimeStamp":"2016-02-02T01:05:18.083501Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1351.json","@type":"CatalogPage","commitId":"db758bb1-6fa9-41b0-8b7f-8132c610047b","commitTimeStamp":"2016-02-02T13:08:27.9296616Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1352.json","@type":"CatalogPage","commitId":"7d901406-18d9-49c6-a097-715ccca2577b","commitTimeStamp":"2016-02-02T22:39:42.1669353Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1353.json","@type":"CatalogPage","commitId":"2445e64a-1d7c-4362-922f-7e9ffed1ce6f","commitTimeStamp":"2016-02-03T13:00:46.3636001Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1354.json","@type":"CatalogPage","commitId":"ae76e6c4-d686-4a2f-8a46-13db1b4341d4","commitTimeStamp":"2016-02-03T20:35:03.7343201Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1355.json","@type":"CatalogPage","commitId":"1f7cef44-c599-4268-b312-8d1f71caf277","commitTimeStamp":"2016-02-04T11:41:03.786145Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1356.json","@type":"CatalogPage","commitId":"e0ff8353-e32f-4d0b-89f1-3b103c3d79c5","commitTimeStamp":"2016-02-04T20:41:21.8556985Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page1357.json","@type":"CatalogPage","commitId":"6e8cc376-aee5-42b0-a7ba-816e0687e34b","commitTimeStamp":"2016-02-05T08:39:50.0965094Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1358.json","@type":"CatalogPage","commitId":"bdcc3b5e-f4a3-4099-a6a5-96c58847734b","commitTimeStamp":"2016-02-05T19:22:16.8134966Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1359.json","@type":"CatalogPage","commitId":"518e9bd4-cd78-4c4f-a24c-27931ca19633","commitTimeStamp":"2016-02-06T16:53:48.8139677Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1360.json","@type":"CatalogPage","commitId":"44981589-8109-4093-a03a-068b386e7590","commitTimeStamp":"2016-02-07T19:35:24.8597104Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1361.json","@type":"CatalogPage","commitId":"320fe2c4-dc25-4e0d-956d-fed6cfdfc19e","commitTimeStamp":"2016-02-08T11:57:39.7085713Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page1362.json","@type":"CatalogPage","commitId":"dfe157a4-1070-4cef-a9b4-a318a1f72760","commitTimeStamp":"2016-02-08T22:02:21.7504478Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1363.json","@type":"CatalogPage","commitId":"64041c53-4ad1-4fe4-82e2-489092bdb853","commitTimeStamp":"2016-02-09T11:36:58.4034291Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1364.json","@type":"CatalogPage","commitId":"bd390d09-9b54-4a2a-a4d7-99a0671e3312","commitTimeStamp":"2016-02-09T20:06:13.9234538Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1365.json","@type":"CatalogPage","commitId":"ac2c8599-d729-4bb5-99dd-bb443a35fd8e","commitTimeStamp":"2016-02-10T05:41:18.2258587Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1366.json","@type":"CatalogPage","commitId":"3b0b9b48-a0ef-4c38-ad53-5136657f0f06","commitTimeStamp":"2016-02-10T19:44:56.856772Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1367.json","@type":"CatalogPage","commitId":"a6fb5dc0-ab0d-4d6d-9f66-65f1c7b0e188","commitTimeStamp":"2016-02-11T10:00:49.8705942Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1368.json","@type":"CatalogPage","commitId":"a5786f68-c791-4000-a474-cc78154abaa6","commitTimeStamp":"2016-02-11T15:08:41.1201889Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1369.json","@type":"CatalogPage","commitId":"eaf5358b-e3c1-424b-9490-aebc0b05d230","commitTimeStamp":"2016-02-11T20:42:53.2699024Z","count":552},{"@id":"https://api.nuget.org/v3/catalog0/page1370.json","@type":"CatalogPage","commitId":"361e1fbf-8c95-42d8-8e19-2df95a8bb0c3","commitTimeStamp":"2016-02-12T10:34:37.710404Z","count":551},{"@id":"https://api.nuget.org/v3/catalog0/page1371.json","@type":"CatalogPage","commitId":"97fc925b-9bdf-4be1-82a6-8166fe111e52","commitTimeStamp":"2016-02-12T15:20:08.3108985Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1372.json","@type":"CatalogPage","commitId":"2d3dafef-de6a-4410-9e7e-cde3fee00d9f","commitTimeStamp":"2016-02-12T21:15:18.168463Z","count":551},{"@id":"https://api.nuget.org/v3/catalog0/page1373.json","@type":"CatalogPage","commitId":"9e8d7fee-c322-44e3-9311-297bb2f87c6e","commitTimeStamp":"2016-02-13T09:22:22.1803152Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1374.json","@type":"CatalogPage","commitId":"82ce2178-60b6-43ba-ad9c-ada099d53a81","commitTimeStamp":"2016-02-13T19:23:28.2725497Z","count":551},{"@id":"https://api.nuget.org/v3/catalog0/page1375.json","@type":"CatalogPage","commitId":"63bfca67-25a5-4783-93e0-e9719d74e680","commitTimeStamp":"2016-02-14T16:00:36.8262208Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1376.json","@type":"CatalogPage","commitId":"27bfd703-0a7c-4be8-8068-0d622f4183b6","commitTimeStamp":"2016-02-15T08:46:45.0985488Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1377.json","@type":"CatalogPage","commitId":"3bfc8679-418d-42c5-a139-a4f7870b875e","commitTimeStamp":"2016-02-15T18:14:54.4525776Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1378.json","@type":"CatalogPage","commitId":"dc9b9ada-af3f-42e3-8cb1-fda99cae3a74","commitTimeStamp":"2016-02-16T01:33:18.0983359Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1379.json","@type":"CatalogPage","commitId":"2a742de1-f36c-4e54-b84c-01b915238d13","commitTimeStamp":"2016-02-16T04:46:43.112008Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1380.json","@type":"CatalogPage","commitId":"b5f722a9-75cf-4dc5-964f-0be6942ae213","commitTimeStamp":"2016-02-16T08:24:43.0452105Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1381.json","@type":"CatalogPage","commitId":"4b27d9b2-5cd4-44f0-b86c-fc99895785ca","commitTimeStamp":"2016-02-16T12:06:05.1335906Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1382.json","@type":"CatalogPage","commitId":"dd42c4c2-1b5e-4c5a-9618-4c9582428fb8","commitTimeStamp":"2016-02-16T14:34:51.2440288Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1383.json","@type":"CatalogPage","commitId":"c076ec59-b52a-4868-922b-2326d3302334","commitTimeStamp":"2016-02-16T18:18:39.7429849Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1384.json","@type":"CatalogPage","commitId":"92f8abe2-f86b-4590-a549-75f70811b19c","commitTimeStamp":"2016-02-16T22:08:15.0862655Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1385.json","@type":"CatalogPage","commitId":"d38a61ae-3033-40ac-acc4-a3eb9a22af53","commitTimeStamp":"2016-02-17T01:59:36.50162Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1386.json","@type":"CatalogPage","commitId":"58014dd5-75d6-4a94-837a-10fd1c23a132","commitTimeStamp":"2016-02-17T14:51:33.1591534Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1387.json","@type":"CatalogPage","commitId":"e94cea9b-4a9c-4ebe-8e7c-c6898981feef","commitTimeStamp":"2016-02-18T04:38:07.908071Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1388.json","@type":"CatalogPage","commitId":"bebabe45-722d-4e6c-ab03-70813c59e028","commitTimeStamp":"2016-02-18T16:46:34.3643182Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1389.json","@type":"CatalogPage","commitId":"e144559e-c220-4846-8ea4-9fe9f1fec11c","commitTimeStamp":"2016-02-19T05:13:52.1167422Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1390.json","@type":"CatalogPage","commitId":"de50b8af-d8e9-4303-a999-5ad616d12dda","commitTimeStamp":"2016-02-19T14:25:37.7120568Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1391.json","@type":"CatalogPage","commitId":"4bf613aa-8b3d-475a-984b-c4f3b4df2c95","commitTimeStamp":"2016-02-19T19:20:42.5269399Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page1392.json","@type":"CatalogPage","commitId":"3f9e319c-cc38-4030-a8e0-7ccf041c8309","commitTimeStamp":"2016-02-19T19:46:28.6211936Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1393.json","@type":"CatalogPage","commitId":"689535f0-a8f0-4103-b9ca-47727dd3f9d4","commitTimeStamp":"2016-02-20T14:04:27.0211067Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1394.json","@type":"CatalogPage","commitId":"40d575c4-814e-420a-a8d0-35aa61be4dce","commitTimeStamp":"2016-02-21T11:15:06.5003771Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page1395.json","@type":"CatalogPage","commitId":"6db2ee26-951f-4de3-a068-ea51b5319359","commitTimeStamp":"2016-02-22T10:06:47.3370524Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1396.json","@type":"CatalogPage","commitId":"f93c04ef-1acb-4cb0-b7a8-82f0e603032a","commitTimeStamp":"2016-02-22T17:17:15.2447378Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1397.json","@type":"CatalogPage","commitId":"de521600-9ca2-445d-98e5-5aef355d9afd","commitTimeStamp":"2016-02-23T00:09:14.4875439Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1398.json","@type":"CatalogPage","commitId":"4c06ec46-4284-4218-ae19-6045bf549894","commitTimeStamp":"2016-02-23T09:31:20.8655229Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page1399.json","@type":"CatalogPage","commitId":"53dfbd6f-ea3a-4778-88eb-e96544729e6a","commitTimeStamp":"2016-02-23T11:17:38.2798217Z","count":532},{"@id":"https://api.nuget.org/v3/catalog0/page1400.json","@type":"CatalogPage","commitId":"fb58d9a3-eb92-4242-8fba-700972693ce9","commitTimeStamp":"2016-02-23T14:18:35.3914606Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page1401.json","@type":"CatalogPage","commitId":"02c471e6-6db8-430d-af32-5e15ebacf7a6","commitTimeStamp":"2016-02-23T21:37:36.6551601Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1402.json","@type":"CatalogPage","commitId":"60f34bbe-b21d-4285-aec1-546d619a03aa","commitTimeStamp":"2016-02-24T10:38:23.5558946Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page1403.json","@type":"CatalogPage","commitId":"93e2a853-1275-4597-8e10-af5734906d21","commitTimeStamp":"2016-02-24T13:11:09.1462568Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1404.json","@type":"CatalogPage","commitId":"66b39952-e29e-4e3b-b81f-5bdc800bb7ed","commitTimeStamp":"2016-02-24T21:15:07.0726738Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1405.json","@type":"CatalogPage","commitId":"8339559f-fe16-4359-8aea-5dd918587351","commitTimeStamp":"2016-02-25T13:39:32.6241744Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1406.json","@type":"CatalogPage","commitId":"2fc696c7-5bab-4e3e-baf1-f31e3f64eef5","commitTimeStamp":"2016-02-25T22:44:36.748727Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1407.json","@type":"CatalogPage","commitId":"72331833-c498-4b59-b341-f708b68e526b","commitTimeStamp":"2016-02-26T12:06:27.8421238Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1408.json","@type":"CatalogPage","commitId":"53da939e-b3a6-434a-8af7-b22eea6dadbb","commitTimeStamp":"2016-02-26T20:35:26.4286597Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1409.json","@type":"CatalogPage","commitId":"d327ea3e-2b43-4c1d-bb3f-539c89a8c6cf","commitTimeStamp":"2016-02-27T15:00:24.2495234Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1410.json","@type":"CatalogPage","commitId":"dea68f23-bb85-4a90-929c-d64c237ed106","commitTimeStamp":"2016-02-28T15:12:50.9492391Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1411.json","@type":"CatalogPage","commitId":"5aa59fcc-da46-43d4-8137-f46a379238d1","commitTimeStamp":"2016-02-29T06:56:41.4661087Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1412.json","@type":"CatalogPage","commitId":"9430fdec-72f1-4892-a629-d291be0efeee","commitTimeStamp":"2016-02-29T14:46:37.1884272Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1413.json","@type":"CatalogPage","commitId":"92c5c418-eccc-4c77-ac47-63170abc5f10","commitTimeStamp":"2016-03-01T00:45:19.0590133Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1414.json","@type":"CatalogPage","commitId":"06300425-1e3b-44c0-b445-9f21fbe0c12d","commitTimeStamp":"2016-03-01T12:59:00.2272856Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1415.json","@type":"CatalogPage","commitId":"890c0a10-8234-4d44-8068-6538186a57d5","commitTimeStamp":"2016-03-02T00:02:46.1647747Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1416.json","@type":"CatalogPage","commitId":"1fbf035f-c88e-42c3-8dfe-657c53889803","commitTimeStamp":"2016-03-02T13:41:24.9395451Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1417.json","@type":"CatalogPage","commitId":"87444baf-0314-4a62-8309-4f754b617587","commitTimeStamp":"2016-03-03T03:41:35.63136Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1418.json","@type":"CatalogPage","commitId":"cc4575f8-17b5-4097-ab39-4bf53ea1c0fc","commitTimeStamp":"2016-03-03T16:31:20.6060866Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1419.json","@type":"CatalogPage","commitId":"16a6753d-0ded-41ac-b42b-551d59f872f4","commitTimeStamp":"2016-03-04T02:56:34.4484593Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1420.json","@type":"CatalogPage","commitId":"70498be2-fb6a-4126-859d-1dd920200f13","commitTimeStamp":"2016-03-04T14:40:47.0437114Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1421.json","@type":"CatalogPage","commitId":"1f508d0c-3b20-4b5d-897f-bfa462abc630","commitTimeStamp":"2016-03-05T08:43:32.4100258Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1422.json","@type":"CatalogPage","commitId":"44d06689-944d-4b07-96c3-3181f87272de","commitTimeStamp":"2016-03-06T08:43:25.6256398Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1423.json","@type":"CatalogPage","commitId":"137e00fa-502e-493a-b9d3-5e49a5bca4d6","commitTimeStamp":"2016-03-07T04:02:26.5421856Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1424.json","@type":"CatalogPage","commitId":"ba066d48-8b83-40a9-befe-1a6d14c9677f","commitTimeStamp":"2016-03-07T13:05:11.4603955Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1425.json","@type":"CatalogPage","commitId":"a89c946f-3e51-41fd-8cc0-c2226033971f","commitTimeStamp":"2016-03-08T01:05:13.5433694Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1426.json","@type":"CatalogPage","commitId":"b5e2820c-318f-4cb6-ac65-1a8868d906c7","commitTimeStamp":"2016-03-08T16:06:28.0239259Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1427.json","@type":"CatalogPage","commitId":"eb6a6f0c-94e6-4f4e-bd7d-2b7c7d0cb7d4","commitTimeStamp":"2016-03-09T04:31:54.9932574Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1428.json","@type":"CatalogPage","commitId":"11761eb7-c907-48c0-98b3-c79c305a61a3","commitTimeStamp":"2016-03-09T15:42:49.3052024Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1429.json","@type":"CatalogPage","commitId":"d48eeaca-939e-4a57-9a3c-d97742b67bcc","commitTimeStamp":"2016-03-10T05:23:21.3522424Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1430.json","@type":"CatalogPage","commitId":"04f159d8-072e-4a96-911a-431784226c29","commitTimeStamp":"2016-03-10T14:27:34.3396011Z","count":551},{"@id":"https://api.nuget.org/v3/catalog0/page1431.json","@type":"CatalogPage","commitId":"93be802e-cecd-433d-b965-14822a18e557","commitTimeStamp":"2016-03-10T18:58:43.5502984Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1432.json","@type":"CatalogPage","commitId":"7266516a-ae3e-44a2-b9f6-95feafde0526","commitTimeStamp":"2016-03-11T03:06:17.3431199Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1433.json","@type":"CatalogPage","commitId":"664ed863-3b21-44e8-99d9-2248d19f6acf","commitTimeStamp":"2016-03-11T11:16:03.5141239Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1434.json","@type":"CatalogPage","commitId":"49d3b311-ebab-4291-b40b-17568cf04a60","commitTimeStamp":"2016-03-11T14:34:54.201487Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1435.json","@type":"CatalogPage","commitId":"4c7311df-9dcb-463c-a591-13b6bb6121b9","commitTimeStamp":"2016-03-11T20:11:29.7797882Z","count":551},{"@id":"https://api.nuget.org/v3/catalog0/page1436.json","@type":"CatalogPage","commitId":"bb0c5083-a8cd-4bba-b49e-d877b58bf853","commitTimeStamp":"2016-03-12T07:06:56.3828123Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1437.json","@type":"CatalogPage","commitId":"eda08ced-fc06-48a8-95d5-f03dd926ba3b","commitTimeStamp":"2016-03-12T21:43:27.7181834Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1438.json","@type":"CatalogPage","commitId":"f44a24ed-aa33-463c-913a-e3461f4535e1","commitTimeStamp":"2016-03-13T13:59:41.6972768Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1439.json","@type":"CatalogPage","commitId":"56d8e536-084c-4cbf-842d-3f0bdcf02d6e","commitTimeStamp":"2016-03-14T07:48:08.5576675Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1440.json","@type":"CatalogPage","commitId":"e0488fc4-1a32-4364-b644-d4e1e7b613fb","commitTimeStamp":"2016-03-14T15:57:49.7123039Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1441.json","@type":"CatalogPage","commitId":"aabbb258-6746-4980-8a96-27cd21fcd976","commitTimeStamp":"2016-03-14T23:14:40.562313Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1442.json","@type":"CatalogPage","commitId":"7f4600e6-7d8c-4a2f-bd08-46e9e6b6904e","commitTimeStamp":"2016-03-15T11:03:32.5052728Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1443.json","@type":"CatalogPage","commitId":"11a742a5-1d72-4fff-9bd2-880980d3f2fa","commitTimeStamp":"2016-03-15T17:45:27.4427774Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1444.json","@type":"CatalogPage","commitId":"7aa84b52-3f7f-42f3-af93-899ff52d883a","commitTimeStamp":"2016-03-16T09:01:09.5760281Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page1445.json","@type":"CatalogPage","commitId":"de584214-45e9-4ef2-ac32-ec0ff1dbb26f","commitTimeStamp":"2016-03-16T18:12:01.6349464Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page1446.json","@type":"CatalogPage","commitId":"e5c78f9f-34ed-46d7-869b-784d159dbe3f","commitTimeStamp":"2016-03-17T05:31:12.7510662Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page1447.json","@type":"CatalogPage","commitId":"5cf2042c-510d-4833-b33d-36e3373f9cd0","commitTimeStamp":"2016-03-17T12:23:44.5287465Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1448.json","@type":"CatalogPage","commitId":"aa22b8e4-211a-438d-aaf9-fc1b2a20b5df","commitTimeStamp":"2016-03-17T14:15:26.771889Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1449.json","@type":"CatalogPage","commitId":"25d1e27a-0a47-4842-bfbd-a92813e56ba8","commitTimeStamp":"2016-03-17T16:14:17.3100559Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1450.json","@type":"CatalogPage","commitId":"b2158236-9e53-4bc7-aa74-3511b34cb78c","commitTimeStamp":"2016-03-17T18:09:28.0464878Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1451.json","@type":"CatalogPage","commitId":"e9260dbf-2656-423c-9cac-2da682635854","commitTimeStamp":"2016-03-17T20:07:46.5099026Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1452.json","@type":"CatalogPage","commitId":"80b47892-78a5-4efa-b481-a8e6acc5d7ac","commitTimeStamp":"2016-03-17T22:04:22.4330178Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1453.json","@type":"CatalogPage","commitId":"c8879eef-e12e-40c7-8a90-02d38465482b","commitTimeStamp":"2016-03-17T22:58:15.1975522Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1454.json","@type":"CatalogPage","commitId":"7092b25d-36b6-4111-9f21-b2206415c1ab","commitTimeStamp":"2016-03-18T01:39:03.0682349Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1455.json","@type":"CatalogPage","commitId":"3137957c-f6fb-4f9b-8dd4-ec2494ab4948","commitTimeStamp":"2016-03-18T04:06:02.9556258Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1456.json","@type":"CatalogPage","commitId":"5ba82b56-1abc-4016-a702-5f3bb264530b","commitTimeStamp":"2016-03-18T06:16:36.4504348Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1457.json","@type":"CatalogPage","commitId":"1bc72939-c8da-4689-8231-0bab856f689a","commitTimeStamp":"2016-03-18T08:20:42.8284943Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1458.json","@type":"CatalogPage","commitId":"40602af3-1b1d-4c59-a500-6474a05c7954","commitTimeStamp":"2016-03-18T10:21:26.9198183Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1459.json","@type":"CatalogPage","commitId":"966c9662-a4ff-4c53-8119-b554f11cd803","commitTimeStamp":"2016-03-18T12:18:06.0702198Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1460.json","@type":"CatalogPage","commitId":"c93fffe0-a53f-4297-bc20-fc15536d3d2f","commitTimeStamp":"2016-03-18T14:19:56.6838428Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1461.json","@type":"CatalogPage","commitId":"4cf0d192-d721-4ace-b2f3-b114ab10d7a1","commitTimeStamp":"2016-03-18T16:17:38.7991174Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1462.json","@type":"CatalogPage","commitId":"033cb340-4d33-49df-9f95-38bc589230c1","commitTimeStamp":"2016-03-18T18:21:20.2185116Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1463.json","@type":"CatalogPage","commitId":"b8135c41-b9e3-4447-a98e-9d675f535bf0","commitTimeStamp":"2016-03-18T20:24:33.9326399Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1464.json","@type":"CatalogPage","commitId":"51290751-4790-40a6-9275-fc909e89ca6e","commitTimeStamp":"2016-03-18T22:27:54.2814458Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1465.json","@type":"CatalogPage","commitId":"f3bdc671-66ad-490c-911b-92b6df60e172","commitTimeStamp":"2016-03-19T00:34:43.4614413Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1466.json","@type":"CatalogPage","commitId":"5b4dbb97-1f02-46fd-b812-ebd456305770","commitTimeStamp":"2016-03-19T02:45:33.8841262Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1467.json","@type":"CatalogPage","commitId":"fdf32583-bd36-45de-ba87-6b39e62e8448","commitTimeStamp":"2016-03-19T04:59:30.1403454Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1468.json","@type":"CatalogPage","commitId":"51717fbc-4836-46c8-be50-47e9dc551de6","commitTimeStamp":"2016-03-19T07:49:14.8549487Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1469.json","@type":"CatalogPage","commitId":"518732fe-9ee9-4dfc-bdc6-ed29d202d99a","commitTimeStamp":"2016-03-19T09:01:01.1781953Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1470.json","@type":"CatalogPage","commitId":"1243f062-89cd-450d-9754-33e6f6969052","commitTimeStamp":"2016-03-19T10:49:35.9050671Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1471.json","@type":"CatalogPage","commitId":"bd0e5965-943f-4372-a472-1d5671e798c3","commitTimeStamp":"2016-03-19T12:49:43.8773315Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1472.json","@type":"CatalogPage","commitId":"3e5bcf62-22b9-46b7-b256-20f754676c59","commitTimeStamp":"2016-03-19T14:58:14.5617517Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1473.json","@type":"CatalogPage","commitId":"4d30571b-7449-4a3f-9ae5-882d152804e4","commitTimeStamp":"2016-03-19T16:52:36.9071786Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1474.json","@type":"CatalogPage","commitId":"c9cda541-2a56-4ae0-828d-d33a3f8e1664","commitTimeStamp":"2016-03-19T18:46:40.8294973Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1475.json","@type":"CatalogPage","commitId":"94747338-b91e-411f-b3a2-191d19fa1e7f","commitTimeStamp":"2016-03-19T20:41:45.7467532Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1476.json","@type":"CatalogPage","commitId":"343cc976-81b6-44f9-82e7-87164249d470","commitTimeStamp":"2016-03-19T22:35:17.0019975Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1477.json","@type":"CatalogPage","commitId":"62427547-e41b-41e9-83b1-d26b21f99171","commitTimeStamp":"2016-03-20T00:42:18.4495836Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1478.json","@type":"CatalogPage","commitId":"c6d32d90-6f71-4fcf-80f7-c85faa2262ff","commitTimeStamp":"2016-03-20T02:53:55.8794081Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1479.json","@type":"CatalogPage","commitId":"f5d0d85b-e0a0-4005-b2f8-9c8b73f46b57","commitTimeStamp":"2016-03-20T05:53:02.4154575Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1480.json","@type":"CatalogPage","commitId":"08f4a874-bc75-43c3-b6d5-13fa21ad94ea","commitTimeStamp":"2016-03-20T08:13:09.396444Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1481.json","@type":"CatalogPage","commitId":"cc6e4102-f64d-4a28-bea7-0914a1a92756","commitTimeStamp":"2016-03-20T10:11:19.1246531Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1482.json","@type":"CatalogPage","commitId":"d4ab785a-143b-4e78-a7e1-5b62da498e11","commitTimeStamp":"2016-03-20T12:21:47.6283442Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1483.json","@type":"CatalogPage","commitId":"ffc79c5c-d56e-46cb-86fc-a05380c648ef","commitTimeStamp":"2016-03-20T14:25:06.0362487Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1484.json","@type":"CatalogPage","commitId":"b143724e-e0e5-47f6-8b72-97df1a7e66ce","commitTimeStamp":"2016-03-20T16:21:50.5037528Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1485.json","@type":"CatalogPage","commitId":"c0f9eb91-56dc-4db7-9c5b-3c854c04eda5","commitTimeStamp":"2016-03-20T18:28:08.6605886Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1486.json","@type":"CatalogPage","commitId":"7d859188-126d-47ff-ab0a-2c5dee42dfb4","commitTimeStamp":"2016-03-20T20:31:27.7604871Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1487.json","@type":"CatalogPage","commitId":"51a8b518-b509-4b85-8f04-6e9c7927eb67","commitTimeStamp":"2016-03-21T06:43:23.7653498Z","count":534},{"@id":"https://api.nuget.org/v3/catalog0/page1488.json","@type":"CatalogPage","commitId":"2f578597-51ba-4d63-af69-37bef352457b","commitTimeStamp":"2016-03-21T06:50:24.5466377Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page1489.json","@type":"CatalogPage","commitId":"56f7d458-6cb3-4a71-a756-bd176f7b5db9","commitTimeStamp":"2016-03-21T06:55:23.1472341Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page1490.json","@type":"CatalogPage","commitId":"0832a80b-07eb-42f1-9c27-0be0fc873295","commitTimeStamp":"2016-03-21T07:00:51.3563675Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page1491.json","@type":"CatalogPage","commitId":"3cf24ebd-3276-446a-9e7a-6c4b4244e760","commitTimeStamp":"2016-03-21T07:05:22.2541114Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page1492.json","@type":"CatalogPage","commitId":"684cc388-4838-46a5-a147-b58bca1d6fd0","commitTimeStamp":"2016-03-21T08:04:54.2638069Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1493.json","@type":"CatalogPage","commitId":"d62781db-4485-434a-8c95-2529ff87ab77","commitTimeStamp":"2016-03-21T10:03:57.7001179Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1494.json","@type":"CatalogPage","commitId":"9502880c-e2ff-4634-80aa-60ecc881a56f","commitTimeStamp":"2016-03-21T11:01:22.3301342Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1495.json","@type":"CatalogPage","commitId":"6cfed8fe-9207-467a-8072-a0de1df6419f","commitTimeStamp":"2016-03-21T14:33:08.8996725Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1496.json","@type":"CatalogPage","commitId":"b9d355d7-3c9f-4d79-9ae5-72b17586c814","commitTimeStamp":"2016-03-21T16:12:53.6565529Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1497.json","@type":"CatalogPage","commitId":"0e01914e-edbd-4a02-a6cb-9678f340639d","commitTimeStamp":"2016-03-21T17:45:14.2160669Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1498.json","@type":"CatalogPage","commitId":"240ff55a-d526-4217-8cc4-88d96a9ba2c8","commitTimeStamp":"2016-03-21T19:16:08.866267Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1499.json","@type":"CatalogPage","commitId":"fb3d4c05-eae4-405b-9321-be45f2006c53","commitTimeStamp":"2016-03-21T20:53:30.0441742Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1500.json","@type":"CatalogPage","commitId":"2a106b69-51aa-400e-87e4-1a6eda654434","commitTimeStamp":"2016-03-21T22:41:38.0326995Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1501.json","@type":"CatalogPage","commitId":"b6b39564-1044-4de3-8c8d-daaae2398927","commitTimeStamp":"2016-03-22T00:33:41.7471631Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1502.json","@type":"CatalogPage","commitId":"a4dd3926-4a9e-4c5b-8680-4fde7ecda68b","commitTimeStamp":"2016-03-22T02:33:08.7868907Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1503.json","@type":"CatalogPage","commitId":"e64ee14b-6f41-4ecf-8623-f5b3fc7dfc9b","commitTimeStamp":"2016-03-22T04:27:27.0314495Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1504.json","@type":"CatalogPage","commitId":"7ef069e8-bf18-4749-92f6-f504239ffc1d","commitTimeStamp":"2016-03-22T06:44:05.1931284Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1505.json","@type":"CatalogPage","commitId":"874a1dc6-1fe6-4d90-b124-ec66fdc9bf3d","commitTimeStamp":"2016-03-22T08:33:08.8894279Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1506.json","@type":"CatalogPage","commitId":"007ed6d9-bc73-4487-bd97-9865c393745d","commitTimeStamp":"2016-03-22T10:22:45.8049697Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1507.json","@type":"CatalogPage","commitId":"a7be57c1-959f-43c1-84d8-51441dfd45fa","commitTimeStamp":"2016-03-22T12:21:03.2655196Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1508.json","@type":"CatalogPage","commitId":"7d9f6fb9-2d19-4ebd-a83d-26ad3f48b554","commitTimeStamp":"2016-03-22T14:24:12.2187893Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1509.json","@type":"CatalogPage","commitId":"cf9029fa-700d-48c8-9d8a-6b8b7de45aec","commitTimeStamp":"2016-03-22T16:08:09.0649913Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1510.json","@type":"CatalogPage","commitId":"c0afeb75-9f3b-4bb3-b99f-29bf1c4c4bc8","commitTimeStamp":"2016-03-22T16:58:33.5323588Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1511.json","@type":"CatalogPage","commitId":"87a18e07-d356-4b6c-ab3f-2d42eba119c7","commitTimeStamp":"2016-03-22T18:10:32.1522305Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1512.json","@type":"CatalogPage","commitId":"af5a3a51-677a-4d4d-8551-a684e947adc2","commitTimeStamp":"2016-03-22T19:09:04.3029532Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1513.json","@type":"CatalogPage","commitId":"08327828-8aea-4298-884f-46e5dd63ffaa","commitTimeStamp":"2016-03-22T20:00:31.4779363Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1514.json","@type":"CatalogPage","commitId":"43e4bd9d-b324-4ac9-9d3a-14515dc90faa","commitTimeStamp":"2016-03-22T22:50:26.4735134Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1515.json","@type":"CatalogPage","commitId":"74007d51-7eda-4620-93c5-f2e676c697d0","commitTimeStamp":"2016-03-23T14:05:27.2310864Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1516.json","@type":"CatalogPage","commitId":"af407287-5e37-40d5-84cf-bb0f95f9dc5b","commitTimeStamp":"2016-03-24T00:13:43.0609827Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1517.json","@type":"CatalogPage","commitId":"74f89e04-e9c8-4c78-a0b8-199f4f46d51b","commitTimeStamp":"2016-03-24T15:19:36.7813104Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1518.json","@type":"CatalogPage","commitId":"9b648f9b-0922-4864-8614-8e5328c17a87","commitTimeStamp":"2016-03-25T02:14:18.176766Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1519.json","@type":"CatalogPage","commitId":"61ab64e8-0aa5-4cab-a93a-617345cfb5d8","commitTimeStamp":"2016-03-25T17:46:06.8833754Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1520.json","@type":"CatalogPage","commitId":"d77252ce-cd1e-418a-baca-993b230528d9","commitTimeStamp":"2016-03-26T15:15:03.6015729Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page1521.json","@type":"CatalogPage","commitId":"10c792d8-1ab9-42bd-9eeb-9d294a68ecf0","commitTimeStamp":"2016-03-27T12:42:15.2561141Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1522.json","@type":"CatalogPage","commitId":"63722049-d0c5-45ac-b014-1c4a36648520","commitTimeStamp":"2016-03-28T04:38:38.0259954Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page1523.json","@type":"CatalogPage","commitId":"94b966d5-0d24-43b2-b8c7-a39f70a1376c","commitTimeStamp":"2016-03-28T18:50:55.0657055Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1524.json","@type":"CatalogPage","commitId":"95258000-f861-48ef-a66c-b227dc5ae2cf","commitTimeStamp":"2016-03-29T08:59:14.5028272Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1525.json","@type":"CatalogPage","commitId":"588127c1-176e-425e-bbcb-35a44ad81176","commitTimeStamp":"2016-03-29T16:05:27.2706928Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1526.json","@type":"CatalogPage","commitId":"0019539d-c717-495e-b6f0-59da49228dd8","commitTimeStamp":"2016-03-30T02:47:54.8015383Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1527.json","@type":"CatalogPage","commitId":"414b90fd-a638-4863-9770-dc6334d1f491","commitTimeStamp":"2016-03-30T12:00:22.484389Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page1528.json","@type":"CatalogPage","commitId":"509dd4a8-a1bb-4de4-acd0-c36ae05a41da","commitTimeStamp":"2016-03-30T19:42:57.4144034Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1529.json","@type":"CatalogPage","commitId":"ca673a0c-2aca-470a-afe6-716967433430","commitTimeStamp":"2016-03-31T06:07:42.7233607Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1530.json","@type":"CatalogPage","commitId":"0c1d0c78-ac52-4ef7-8610-491ec6b7dfc6","commitTimeStamp":"2016-03-31T12:15:53.8211449Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1531.json","@type":"CatalogPage","commitId":"9b30defa-4be5-4e8a-a971-1844c7cbfd08","commitTimeStamp":"2016-03-31T20:11:06.0791019Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1532.json","@type":"CatalogPage","commitId":"af6cbf9f-de7c-4182-a76e-1a14d44ff38d","commitTimeStamp":"2016-04-01T07:34:26.6450677Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1533.json","@type":"CatalogPage","commitId":"706da934-4cf7-4461-b541-81257421fb2f","commitTimeStamp":"2016-04-01T16:49:24.2247303Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1534.json","@type":"CatalogPage","commitId":"2ca93582-5787-409a-ac8a-9799dd38a89e","commitTimeStamp":"2016-04-02T06:08:52.7826058Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1535.json","@type":"CatalogPage","commitId":"d2ff87a2-649b-4437-a4b9-e34c4cdc1005","commitTimeStamp":"2016-04-03T06:50:03.6922002Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1536.json","@type":"CatalogPage","commitId":"d3806563-8f3d-4a1c-8804-5c03f54b1e48","commitTimeStamp":"2016-04-04T02:52:05.8269897Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1537.json","@type":"CatalogPage","commitId":"6bd3e571-69fc-4dad-b315-960b6930b872","commitTimeStamp":"2016-04-04T17:14:41.5851499Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1538.json","@type":"CatalogPage","commitId":"4d2c5d31-b0ae-496c-a86d-9e6f9478a2e9","commitTimeStamp":"2016-04-05T07:42:49.8089356Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1539.json","@type":"CatalogPage","commitId":"19e1b735-32a3-4954-9bd7-a1c10aead037","commitTimeStamp":"2016-04-05T10:08:19.1265401Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page1540.json","@type":"CatalogPage","commitId":"3e2e1fda-1b99-4df2-90a2-f29fbbde73a6","commitTimeStamp":"2016-04-05T10:20:50.9383382Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page1541.json","@type":"CatalogPage","commitId":"384709ad-017a-46f5-a7f0-8a7e560273ee","commitTimeStamp":"2016-04-05T10:33:42.1686514Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1542.json","@type":"CatalogPage","commitId":"29c5dc1e-2366-44ea-b478-7b00c8d78c35","commitTimeStamp":"2016-04-05T10:59:50.9559175Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1543.json","@type":"CatalogPage","commitId":"a1c74bf1-b4a0-4355-a4a8-b0f54a046cc7","commitTimeStamp":"2016-04-05T18:38:34.2200261Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1544.json","@type":"CatalogPage","commitId":"52e6c531-0d9f-4b62-a3ae-946a9b934233","commitTimeStamp":"2016-04-06T07:43:54.5289217Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1545.json","@type":"CatalogPage","commitId":"6d1baf1c-0958-4a30-9a6d-ad9bcae5f12b","commitTimeStamp":"2016-04-06T13:27:14.1310913Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1546.json","@type":"CatalogPage","commitId":"b8675e2d-9183-42f2-8c15-2d029be00791","commitTimeStamp":"2016-04-06T20:26:13.9849982Z","count":542},{"@id":"https://api.nuget.org/v3/catalog0/page1547.json","@type":"CatalogPage","commitId":"99204183-05ef-4cf9-9ea8-1ff7ecc0d76e","commitTimeStamp":"2016-04-07T06:42:54.1466684Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1548.json","@type":"CatalogPage","commitId":"8c99fddc-57b3-4f73-a569-f858f182889c","commitTimeStamp":"2016-04-07T15:36:17.8004513Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1549.json","@type":"CatalogPage","commitId":"d911ad28-5e1a-4630-b015-7d9c7de8b575","commitTimeStamp":"2016-04-08T02:10:09.2861209Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1550.json","@type":"CatalogPage","commitId":"364a58b0-dd93-4d22-b4cc-079bae356c76","commitTimeStamp":"2016-04-08T09:03:21.5562134Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1551.json","@type":"CatalogPage","commitId":"7037c10f-adbd-4977-96c7-374ec5c83ad5","commitTimeStamp":"2016-04-08T13:33:48.0947422Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1552.json","@type":"CatalogPage","commitId":"88421f03-d040-457e-b2be-b167f15e7ef5","commitTimeStamp":"2016-04-09T05:13:49.0988079Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1553.json","@type":"CatalogPage","commitId":"a1fbe279-b970-4c4f-9c15-db9158f14ef2","commitTimeStamp":"2016-04-10T01:58:25.5159213Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1554.json","@type":"CatalogPage","commitId":"bb98fe43-ff50-4188-95d3-218f8a762981","commitTimeStamp":"2016-04-10T17:58:25.028462Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1555.json","@type":"CatalogPage","commitId":"da7af02d-a162-45d8-a270-4ef71bc5761b","commitTimeStamp":"2016-04-11T11:16:40.4678277Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1556.json","@type":"CatalogPage","commitId":"53b17508-2c98-4245-96f8-e4ac7235a570","commitTimeStamp":"2016-04-11T19:40:08.7622656Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1557.json","@type":"CatalogPage","commitId":"0772ecc8-40f4-4aaf-ab44-64c09f616120","commitTimeStamp":"2016-04-12T09:29:21.5982737Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1558.json","@type":"CatalogPage","commitId":"ed3fe593-5e64-4dfd-a759-2d2db6ab8642","commitTimeStamp":"2016-04-12T15:10:56.947293Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1559.json","@type":"CatalogPage","commitId":"7ccbf9f1-bdac-4853-b46c-d557bc78ff1a","commitTimeStamp":"2016-04-13T04:51:33.9487128Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1560.json","@type":"CatalogPage","commitId":"a8d4e25b-93b5-4645-9874-62de43159d6a","commitTimeStamp":"2016-04-13T17:36:44.4462448Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1561.json","@type":"CatalogPage","commitId":"f3ee9a19-2803-435a-8851-53d7555adc44","commitTimeStamp":"2016-04-14T02:51:53.7299641Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page1562.json","@type":"CatalogPage","commitId":"67e165d8-b628-4b0b-902f-d619b17aebce","commitTimeStamp":"2016-04-14T03:04:18.4800499Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page1563.json","@type":"CatalogPage","commitId":"9cd6697c-34dd-4b3c-a39f-d0f0963cce9e","commitTimeStamp":"2016-04-14T10:34:18.7866594Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1564.json","@type":"CatalogPage","commitId":"4d81a9aa-50e3-4f03-9411-dfa6559894d3","commitTimeStamp":"2016-04-14T13:39:02.4035603Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1565.json","@type":"CatalogPage","commitId":"7080d65f-c905-45df-8bd9-28c729091600","commitTimeStamp":"2016-04-14T19:51:22.7431231Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1566.json","@type":"CatalogPage","commitId":"508ff259-3b8b-42ba-ab9d-9b7c7535ea07","commitTimeStamp":"2016-04-15T05:24:00.3795809Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1567.json","@type":"CatalogPage","commitId":"3560e158-25aa-4ec3-93ab-846621e594a0","commitTimeStamp":"2016-04-15T14:55:40.1150931Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1568.json","@type":"CatalogPage","commitId":"07e669de-15d9-4ff9-a34a-8b7c8aa4668d","commitTimeStamp":"2016-04-16T05:50:32.9719769Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1569.json","@type":"CatalogPage","commitId":"0debfa9a-59e7-4114-9f93-c0c319e474fb","commitTimeStamp":"2016-04-17T13:40:53.7612251Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page1570.json","@type":"CatalogPage","commitId":"dc0c53f8-ea53-413f-838c-3dadec373f7c","commitTimeStamp":"2016-04-18T06:39:52.3056278Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1571.json","@type":"CatalogPage","commitId":"72317aae-fbc1-40d2-b41e-739865c09824","commitTimeStamp":"2016-04-18T15:44:16.3739789Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1572.json","@type":"CatalogPage","commitId":"1b239b54-6604-4a9e-a7f5-bd59972635bf","commitTimeStamp":"2016-04-19T01:56:12.3153333Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1573.json","@type":"CatalogPage","commitId":"084a75ec-1807-4b4f-bea1-7269a7a98afd","commitTimeStamp":"2016-04-19T12:01:51.3557012Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1574.json","@type":"CatalogPage","commitId":"0cc926a8-67d8-4c00-b25e-902ad9f6225d","commitTimeStamp":"2016-04-19T20:30:56.3182658Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1575.json","@type":"CatalogPage","commitId":"f9ea92c2-18a5-4092-b0f0-3394e41ec484","commitTimeStamp":"2016-04-20T08:51:42.1659476Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1576.json","@type":"CatalogPage","commitId":"90b3d687-3b04-4246-a9aa-0a240ebf8186","commitTimeStamp":"2016-04-20T15:43:43.1096458Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1577.json","@type":"CatalogPage","commitId":"1ddf2f47-7aca-487d-ac33-016023e8da30","commitTimeStamp":"2016-04-21T03:39:53.1939303Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1578.json","@type":"CatalogPage","commitId":"e36f1a7e-a124-479f-898e-65d9cf4d8f05","commitTimeStamp":"2016-04-21T14:53:59.9696078Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1579.json","@type":"CatalogPage","commitId":"f2436ef2-c4b7-4f2a-96b3-50aaac114966","commitTimeStamp":"2016-04-22T05:45:52.1502308Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1580.json","@type":"CatalogPage","commitId":"687b7111-9c15-4232-93c0-1d53bcfe3426","commitTimeStamp":"2016-04-22T15:19:29.6923282Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1581.json","@type":"CatalogPage","commitId":"c8ba2359-bbc4-402e-9a29-fefba18464d4","commitTimeStamp":"2016-04-23T05:31:08.4768546Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1582.json","@type":"CatalogPage","commitId":"d070ca25-cae9-46eb-9e02-a69eab257979","commitTimeStamp":"2016-04-24T05:04:01.2044257Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1583.json","@type":"CatalogPage","commitId":"9382c4b4-b888-42b9-96c2-743723bc550f","commitTimeStamp":"2016-04-25T02:42:18.4971399Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1584.json","@type":"CatalogPage","commitId":"1b4cd465-ed05-442b-aed1-8039524dc724","commitTimeStamp":"2016-04-25T14:45:38.7166379Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1585.json","@type":"CatalogPage","commitId":"bb4a38b5-348a-4cd3-b13a-addc4b73c830","commitTimeStamp":"2016-04-26T06:13:17.2237359Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1586.json","@type":"CatalogPage","commitId":"dbb65239-0b86-4d38-88a2-f09fa0137f98","commitTimeStamp":"2016-04-26T18:29:57.9381745Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1587.json","@type":"CatalogPage","commitId":"571e3ca9-db97-4765-9d06-e1c490846dcf","commitTimeStamp":"2016-04-27T07:07:37.3510033Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page1588.json","@type":"CatalogPage","commitId":"803fbbc3-5ba5-43d5-9978-40da20171566","commitTimeStamp":"2016-04-27T17:48:03.6209729Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1589.json","@type":"CatalogPage","commitId":"ee3b3f95-8fb2-4b21-a773-7dce32f5fc2c","commitTimeStamp":"2016-04-28T05:34:39.8796636Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1590.json","@type":"CatalogPage","commitId":"08c86459-d7f3-46c3-9c4b-f22a1d584f36","commitTimeStamp":"2016-04-28T14:30:20.2244679Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page1591.json","@type":"CatalogPage","commitId":"b3ca2dab-d304-465b-9690-af0d60c174f2","commitTimeStamp":"2016-04-29T06:55:24.028766Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1592.json","@type":"CatalogPage","commitId":"4464f64e-2688-443a-8039-507b27cc2916","commitTimeStamp":"2016-04-29T18:42:20.7527012Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1593.json","@type":"CatalogPage","commitId":"ff1c1909-5946-4924-ae3a-af91a008c7d0","commitTimeStamp":"2016-04-30T15:32:50.2148678Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1594.json","@type":"CatalogPage","commitId":"37305c46-028a-4ae3-8ae7-6b93d2b4c664","commitTimeStamp":"2016-05-01T13:29:13.5403603Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1595.json","@type":"CatalogPage","commitId":"36d8b543-8fd8-465e-a6b7-c283b25e6f5a","commitTimeStamp":"2016-05-02T03:41:31.0944294Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1596.json","@type":"CatalogPage","commitId":"4b47e728-b6c6-4d8b-ad18-f6044a8c7bf5","commitTimeStamp":"2016-05-02T18:37:55.0846353Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1597.json","@type":"CatalogPage","commitId":"cd058719-6995-4437-8261-b7104ec6b1ca","commitTimeStamp":"2016-05-03T10:28:32.6496829Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1598.json","@type":"CatalogPage","commitId":"92a248f7-67aa-4c1d-8c3c-338b3741fc0a","commitTimeStamp":"2016-05-03T21:30:44.0560785Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1599.json","@type":"CatalogPage","commitId":"ca5e3836-ad3b-4a40-818d-72666cebc8b3","commitTimeStamp":"2016-05-04T11:04:34.7615534Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1600.json","@type":"CatalogPage","commitId":"c9faaf1a-caed-4912-a66e-795ffa9da641","commitTimeStamp":"2016-05-04T20:22:37.4133995Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1601.json","@type":"CatalogPage","commitId":"ebbb1e4f-82f7-4549-bb0b-55fcfbfaeed2","commitTimeStamp":"2016-05-05T13:55:46.7226301Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1602.json","@type":"CatalogPage","commitId":"373da887-f79f-4acd-9bd0-434fcf532d5e","commitTimeStamp":"2016-05-06T00:51:42.9548112Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page1603.json","@type":"CatalogPage","commitId":"4a1e1774-ab44-4bb8-aeaa-96af9a4b6b7c","commitTimeStamp":"2016-05-06T12:50:56.0705506Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1604.json","@type":"CatalogPage","commitId":"1af72ead-dc0c-4fef-8b55-c5e09f263bc1","commitTimeStamp":"2016-05-07T02:37:05.2198629Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1605.json","@type":"CatalogPage","commitId":"2c5fe4e0-0e10-491f-9ac7-a792d1ad159f","commitTimeStamp":"2016-05-08T08:01:47.3129173Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1606.json","@type":"CatalogPage","commitId":"25bad4f3-04d2-4a4e-89e7-452eca02c380","commitTimeStamp":"2016-05-09T08:52:18.9522998Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1607.json","@type":"CatalogPage","commitId":"bfdbd882-c5c2-45a7-860a-d5ab20942f58","commitTimeStamp":"2016-05-09T18:39:20.1071662Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1608.json","@type":"CatalogPage","commitId":"0b44c45c-0166-4929-8d2c-a1a889191558","commitTimeStamp":"2016-05-10T06:45:20.449251Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1609.json","@type":"CatalogPage","commitId":"422471e3-7424-42a8-8c84-a0f9f99e66db","commitTimeStamp":"2016-05-10T17:11:50.1945288Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page1610.json","@type":"CatalogPage","commitId":"cee05d83-5df0-4f66-80f3-9746a20f69d6","commitTimeStamp":"2016-05-11T06:31:28.9550764Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1611.json","@type":"CatalogPage","commitId":"71a7a89b-cebc-420b-bf8f-f12671b57771","commitTimeStamp":"2016-05-11T19:53:41.1405607Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1612.json","@type":"CatalogPage","commitId":"bb2d08f3-3b0a-4c38-9ab4-30bfda7d180b","commitTimeStamp":"2016-05-12T11:58:08.1851804Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1613.json","@type":"CatalogPage","commitId":"e11aaba0-e97e-418b-bf36-6efd1743bfd1","commitTimeStamp":"2016-05-12T21:09:01.5325022Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page1614.json","@type":"CatalogPage","commitId":"f7690839-d23c-4db9-9943-be882e2c46fa","commitTimeStamp":"2016-05-13T10:28:32.2521267Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1615.json","@type":"CatalogPage","commitId":"17ed14ba-92a4-4573-94e7-e380c2456771","commitTimeStamp":"2016-05-13T21:04:13.6173458Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1616.json","@type":"CatalogPage","commitId":"8e015b39-59bd-4331-9f1e-e5e36832c024","commitTimeStamp":"2016-05-14T19:43:43.5746868Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1617.json","@type":"CatalogPage","commitId":"437345fd-38f1-405f-a08f-5db43f92e1c6","commitTimeStamp":"2016-05-16T01:52:23.4080034Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1618.json","@type":"CatalogPage","commitId":"2601d9c2-d4a5-4e8e-9d56-af8286f592c6","commitTimeStamp":"2016-05-16T13:55:10.2020083Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1619.json","@type":"CatalogPage","commitId":"7646493c-5e98-4d40-89cb-bd8cbe917d21","commitTimeStamp":"2016-05-16T17:00:01.062252Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1620.json","@type":"CatalogPage","commitId":"50bda762-ff62-46d2-8eac-9e991fc5d5d1","commitTimeStamp":"2016-05-17T06:44:26.1771671Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1621.json","@type":"CatalogPage","commitId":"8208b313-4687-4527-aa85-78ec41fcbcda","commitTimeStamp":"2016-05-17T16:47:08.1496985Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1622.json","@type":"CatalogPage","commitId":"0bc21ad8-1572-47f4-8b34-dedd33dc25c8","commitTimeStamp":"2016-05-18T04:46:38.9729469Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1623.json","@type":"CatalogPage","commitId":"7515b725-00f4-41a4-9e8c-cfc50372e18a","commitTimeStamp":"2016-05-18T13:29:42.0704299Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1624.json","@type":"CatalogPage","commitId":"5eb2b885-133c-4ee4-bd7e-3051172acfc1","commitTimeStamp":"2016-05-18T23:00:00.5099276Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1625.json","@type":"CatalogPage","commitId":"ddcc43d9-25a2-4da5-a35f-49e719d8c578","commitTimeStamp":"2016-05-19T10:31:30.5070926Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1626.json","@type":"CatalogPage","commitId":"1383890f-ec02-4e85-ad0f-a0a78a979e46","commitTimeStamp":"2016-05-19T18:07:24.1520791Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1627.json","@type":"CatalogPage","commitId":"8a37b3dd-dc12-4d81-a8e0-dd1edadac490","commitTimeStamp":"2016-05-20T07:13:33.8874836Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1628.json","@type":"CatalogPage","commitId":"fe6efc3b-456f-4907-bb55-8fe8ef775f20","commitTimeStamp":"2016-05-20T17:30:26.5961233Z","count":544},{"@id":"https://api.nuget.org/v3/catalog0/page1629.json","@type":"CatalogPage","commitId":"8fd8afe8-0f7e-4f0e-91a7-ec6e88d6e7ea","commitTimeStamp":"2016-05-21T10:13:13.2826736Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1630.json","@type":"CatalogPage","commitId":"451d8b0d-bfa3-4467-8bdb-3d6b64b0cca5","commitTimeStamp":"2016-05-22T08:42:59.8745618Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1631.json","@type":"CatalogPage","commitId":"b568d90d-2b38-4d0f-bf51-2d8208e3451f","commitTimeStamp":"2016-05-23T05:24:43.7663015Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1632.json","@type":"CatalogPage","commitId":"d031deb2-9470-4b75-93fa-f1b66256d00e","commitTimeStamp":"2016-05-23T15:42:15.2811541Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1633.json","@type":"CatalogPage","commitId":"6cb09171-a659-4675-9732-5693f28629f9","commitTimeStamp":"2016-05-24T01:38:36.3997089Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1634.json","@type":"CatalogPage","commitId":"2ac22f8d-34cf-4a24-86f1-802219a12fe2","commitTimeStamp":"2016-05-24T12:35:30.9861715Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1635.json","@type":"CatalogPage","commitId":"36f4f026-da96-4025-86d8-3958e78091ef","commitTimeStamp":"2016-05-24T20:21:18.903459Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1636.json","@type":"CatalogPage","commitId":"197dd853-3369-4bcf-bc10-74b87cb1e721","commitTimeStamp":"2016-05-25T10:26:12.5882365Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1637.json","@type":"CatalogPage","commitId":"b6d0fff7-5f8c-42ad-98d6-c0bc9ea860a5","commitTimeStamp":"2016-05-25T16:52:35.4624625Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1638.json","@type":"CatalogPage","commitId":"efa7d116-0c7a-4647-939b-e0cff6b4d519","commitTimeStamp":"2016-05-26T02:39:03.3780589Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1639.json","@type":"CatalogPage","commitId":"91938996-f527-4e80-bca4-1aa177aa3672","commitTimeStamp":"2016-05-26T14:31:19.5538762Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1640.json","@type":"CatalogPage","commitId":"5be4e698-a380-45d3-a172-e81bd8956ef0","commitTimeStamp":"2016-05-26T21:32:52.1560898Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1641.json","@type":"CatalogPage","commitId":"3b3b549a-ef84-4435-be24-5da3801f4942","commitTimeStamp":"2016-05-27T02:08:21.9120997Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1642.json","@type":"CatalogPage","commitId":"7a50e260-90b5-4b5f-9802-dd1f2baaccad","commitTimeStamp":"2016-05-27T09:07:35.4973845Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1643.json","@type":"CatalogPage","commitId":"c57bacfa-d9e7-4725-9fff-cab97b821485","commitTimeStamp":"2016-05-27T11:56:23.5850167Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1644.json","@type":"CatalogPage","commitId":"9460b3b8-e021-4cee-ba69-4f393e38d430","commitTimeStamp":"2016-05-27T13:15:35.3776471Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page1645.json","@type":"CatalogPage","commitId":"79d70eb4-72d9-44df-8b2a-51c53b487864","commitTimeStamp":"2016-05-27T17:03:51.2449939Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1646.json","@type":"CatalogPage","commitId":"731d1773-671c-40d0-86d8-87854bfbdc2e","commitTimeStamp":"2016-05-28T15:36:14.9626913Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1647.json","@type":"CatalogPage","commitId":"7db179fc-7f8c-4126-8cb8-163b7838d7c9","commitTimeStamp":"2016-05-29T17:19:16.4358806Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1648.json","@type":"CatalogPage","commitId":"3f370cb3-73f8-4999-923f-4398a1971a91","commitTimeStamp":"2016-05-30T12:52:17.5600527Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1649.json","@type":"CatalogPage","commitId":"05c8fe61-b1c1-4fc5-af72-b922fb8b62db","commitTimeStamp":"2016-05-30T21:14:13.2088123Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1650.json","@type":"CatalogPage","commitId":"ac3b14df-74bc-40c3-922b-a199cfcb16af","commitTimeStamp":"2016-05-31T10:49:08.330607Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1651.json","@type":"CatalogPage","commitId":"1da6c4c1-3a5c-4dee-8c48-2fe0171f77b5","commitTimeStamp":"2016-05-31T18:05:36.0363896Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1652.json","@type":"CatalogPage","commitId":"76dd62a3-88a5-4dea-ad4f-61f9b7fb646a","commitTimeStamp":"2016-06-01T05:01:35.11999Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1653.json","@type":"CatalogPage","commitId":"3e704a99-b05f-44ff-8382-a5443c6a418e","commitTimeStamp":"2016-06-01T14:47:27.8178751Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1654.json","@type":"CatalogPage","commitId":"81f03397-a72b-44f7-9067-18cf0259cc59","commitTimeStamp":"2016-06-01T23:17:04.4833303Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1655.json","@type":"CatalogPage","commitId":"bbd5be0b-2373-440d-a1de-932cc706b08f","commitTimeStamp":"2016-06-02T10:03:22.1218366Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1656.json","@type":"CatalogPage","commitId":"237a5d78-816f-4f6b-a0f1-67e5affbfd39","commitTimeStamp":"2016-06-02T16:21:23.0578173Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1657.json","@type":"CatalogPage","commitId":"c767b34b-35a8-4ed0-a274-25f0e784db85","commitTimeStamp":"2016-06-02T23:59:04.832769Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1658.json","@type":"CatalogPage","commitId":"77fdff6b-78e8-4641-97e4-d1be5794da32","commitTimeStamp":"2016-06-03T14:29:20.2219993Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1659.json","@type":"CatalogPage","commitId":"4cb7f2a4-02ac-46d4-99a3-6370ba0e6bf5","commitTimeStamp":"2016-06-03T22:59:07.0500279Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1660.json","@type":"CatalogPage","commitId":"757854d0-b1bd-4778-9066-7e109ee96204","commitTimeStamp":"2016-06-04T20:39:42.3372059Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1661.json","@type":"CatalogPage","commitId":"d4ae88ab-5d95-422a-ace0-04293911fd85","commitTimeStamp":"2016-06-05T19:15:29.5951226Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1662.json","@type":"CatalogPage","commitId":"762ae9c6-0ce7-4e69-a368-5e91e275f2ae","commitTimeStamp":"2016-06-06T11:53:43.5304726Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1663.json","@type":"CatalogPage","commitId":"e294df2f-bc5e-4b74-8a34-97f60d1fd424","commitTimeStamp":"2016-06-06T19:57:36.4928518Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1664.json","@type":"CatalogPage","commitId":"97517e7d-96f4-450f-b154-4c18b746e6a9","commitTimeStamp":"2016-06-07T07:13:12.2759287Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1665.json","@type":"CatalogPage","commitId":"0f59022f-4fff-41b1-ac2e-da141e6553ff","commitTimeStamp":"2016-06-07T10:19:11.5998992Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1666.json","@type":"CatalogPage","commitId":"603f6911-2194-4020-a80e-e8ef2b748565","commitTimeStamp":"2016-06-07T18:09:20.6102619Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page1667.json","@type":"CatalogPage","commitId":"e5c4aeb9-d724-4421-8817-143ceb002d6d","commitTimeStamp":"2016-06-08T08:43:48.9181295Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1668.json","@type":"CatalogPage","commitId":"c2e57b1b-25eb-4604-84d8-7e9f52d80689","commitTimeStamp":"2016-06-08T16:13:32.945719Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1669.json","@type":"CatalogPage","commitId":"ad70904f-31c7-49a9-8c7f-9bb843d6dbf2","commitTimeStamp":"2016-06-09T03:56:34.8503984Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1670.json","@type":"CatalogPage","commitId":"6624e541-ccd3-4a9c-bf79-5f7dc2898bbe","commitTimeStamp":"2016-06-09T14:14:36.5777674Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1671.json","@type":"CatalogPage","commitId":"412cbd0d-0f00-4890-a39a-f1cd924cef64","commitTimeStamp":"2016-06-09T23:31:31.4695657Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1672.json","@type":"CatalogPage","commitId":"f74f84d8-eb68-4d96-b9ef-aa9a35889758","commitTimeStamp":"2016-06-10T14:10:15.4649144Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1673.json","@type":"CatalogPage","commitId":"3f1800db-0320-4f06-80b6-3e067dde3e73","commitTimeStamp":"2016-06-11T03:03:04.5752717Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1674.json","@type":"CatalogPage","commitId":"9b66a583-5483-452f-a9f3-442b68180936","commitTimeStamp":"2016-06-11T19:38:51.1124053Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1675.json","@type":"CatalogPage","commitId":"f1d872ee-c21b-4fb1-8cec-665d31ed2ec8","commitTimeStamp":"2016-06-13T01:13:45.757257Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1676.json","@type":"CatalogPage","commitId":"47c36aaf-2629-49d9-8e76-19e6f245ddec","commitTimeStamp":"2016-06-13T13:06:29.8344151Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1677.json","@type":"CatalogPage","commitId":"ffae06c4-e4cc-4874-ac27-9d94f484e3b7","commitTimeStamp":"2016-06-14T00:17:15.4604851Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1678.json","@type":"CatalogPage","commitId":"0d5be0c1-679a-45e6-92cc-b5ad93945a04","commitTimeStamp":"2016-06-14T07:44:23.7057667Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1679.json","@type":"CatalogPage","commitId":"37d6b6fa-9d7a-4fa1-927a-b0832bf0d914","commitTimeStamp":"2016-06-14T14:13:16.2033765Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1680.json","@type":"CatalogPage","commitId":"1f6ac2b8-d517-4b50-82b6-f9d06e9f932c","commitTimeStamp":"2016-06-15T02:32:47.9987213Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1681.json","@type":"CatalogPage","commitId":"2ee16324-dc9e-4ff0-a906-44908200e42a","commitTimeStamp":"2016-06-15T11:35:39.8713347Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1682.json","@type":"CatalogPage","commitId":"bb510450-39fc-45d2-b39a-a9da5469cff9","commitTimeStamp":"2016-06-15T17:42:36.9018887Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page1683.json","@type":"CatalogPage","commitId":"0e19fa37-7940-4ec5-9697-0ad696415a7b","commitTimeStamp":"2016-06-16T08:13:24.3459409Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1684.json","@type":"CatalogPage","commitId":"0d3954fb-3494-47b2-b0b4-514bdd9f8f34","commitTimeStamp":"2016-06-16T15:22:24.8988531Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1685.json","@type":"CatalogPage","commitId":"604f0799-60c5-4f1a-816f-ad69d4803c98","commitTimeStamp":"2016-06-17T02:23:53.3136582Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1686.json","@type":"CatalogPage","commitId":"4810339e-0a63-4616-8273-97141341af7e","commitTimeStamp":"2016-06-17T13:02:02.9566948Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1687.json","@type":"CatalogPage","commitId":"2efa98b1-0378-4444-95a0-237ad47d2daf","commitTimeStamp":"2016-06-17T19:41:11.0031628Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1688.json","@type":"CatalogPage","commitId":"06cb873c-2651-4d9d-af2c-cf3475c4b1ec","commitTimeStamp":"2016-06-18T12:12:38.6451219Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1689.json","@type":"CatalogPage","commitId":"310fa210-755a-433a-9fde-4f2528851600","commitTimeStamp":"2016-06-19T04:05:46.631373Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1690.json","@type":"CatalogPage","commitId":"8b5146af-61d9-40d1-ac9f-ab06f79d8ad2","commitTimeStamp":"2016-06-19T17:54:42.0733638Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1691.json","@type":"CatalogPage","commitId":"d539ea5c-7e68-4b05-bba0-dc3fc728bbef","commitTimeStamp":"2016-06-20T10:10:30.7124845Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1692.json","@type":"CatalogPage","commitId":"c26e922b-7a4f-483d-bca5-831d532ef8e2","commitTimeStamp":"2016-06-20T17:24:41.6415323Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1693.json","@type":"CatalogPage","commitId":"671cbcaa-9085-4954-a2be-54d827d52683","commitTimeStamp":"2016-06-21T04:17:35.9190526Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1694.json","@type":"CatalogPage","commitId":"4422dedd-7232-4328-8685-53eed12a0987","commitTimeStamp":"2016-06-21T15:28:12.0067645Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1695.json","@type":"CatalogPage","commitId":"2c4da3ed-7dc9-40a5-90a9-49c3fd316484","commitTimeStamp":"2016-06-21T20:09:27.8751487Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1696.json","@type":"CatalogPage","commitId":"dc7f6082-5e36-430a-b6a4-847a61abc3f5","commitTimeStamp":"2016-06-22T09:58:53.1935698Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1697.json","@type":"CatalogPage","commitId":"1d969e42-868c-4bfe-93d3-9ac8ce037ba7","commitTimeStamp":"2016-06-22T19:12:46.9072246Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1698.json","@type":"CatalogPage","commitId":"3c25d9a8-7999-4139-a475-9ae6d39ca922","commitTimeStamp":"2016-06-23T05:19:15.0786014Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1699.json","@type":"CatalogPage","commitId":"f2e35c37-13eb-491d-a972-8f6b246e2d66","commitTimeStamp":"2016-06-23T16:06:19.6504656Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1700.json","@type":"CatalogPage","commitId":"67d4f71a-9247-4ff4-9682-7aa133d25333","commitTimeStamp":"2016-06-24T02:19:19.307689Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1701.json","@type":"CatalogPage","commitId":"0f2fa6d6-4eb4-425b-acf4-16f70e7ab9f2","commitTimeStamp":"2016-06-24T12:18:20.9042798Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1702.json","@type":"CatalogPage","commitId":"119e1d11-bfb7-4569-8134-ae9b99695082","commitTimeStamp":"2016-06-25T04:02:15.7759584Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1703.json","@type":"CatalogPage","commitId":"df69305d-e26c-4563-b14c-914a82b27a2f","commitTimeStamp":"2016-06-26T02:37:13.2711785Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1704.json","@type":"CatalogPage","commitId":"fc9c3995-0358-4126-822b-73f7d2a25fe5","commitTimeStamp":"2016-06-27T02:42:32.4065737Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1705.json","@type":"CatalogPage","commitId":"589fa558-616b-4ed7-94e5-6d0f09e73a21","commitTimeStamp":"2016-06-27T12:10:34.8031834Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1706.json","@type":"CatalogPage","commitId":"09bc40e6-bb2a-4631-89c3-df7e2d3a6b56","commitTimeStamp":"2016-06-27T14:29:41.618862Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1707.json","@type":"CatalogPage","commitId":"b10ff992-8727-4f87-8b70-6263f56fa937","commitTimeStamp":"2016-06-27T23:10:48.3907299Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1708.json","@type":"CatalogPage","commitId":"dc1e524b-8bdf-4f6f-a735-d19a1b7d057c","commitTimeStamp":"2016-06-28T08:02:40.495752Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1709.json","@type":"CatalogPage","commitId":"c6d68697-4d20-4ce0-bfb0-9c32e3dc3b74","commitTimeStamp":"2016-06-28T12:49:29.4239216Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1710.json","@type":"CatalogPage","commitId":"82d3a97c-9475-46aa-8d4e-12cc6d144c44","commitTimeStamp":"2016-06-28T18:47:27.9502628Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1711.json","@type":"CatalogPage","commitId":"2a7dbbf9-2049-4466-aac9-22b933a38a10","commitTimeStamp":"2016-06-29T00:29:10.6895024Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1712.json","@type":"CatalogPage","commitId":"87028d22-2d9f-4844-9f4f-dc881a07f556","commitTimeStamp":"2016-06-29T11:43:02.5635124Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1713.json","@type":"CatalogPage","commitId":"c67aa1c5-2230-4269-b329-9094ecfbdd15","commitTimeStamp":"2016-06-29T19:00:39.5912338Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1714.json","@type":"CatalogPage","commitId":"804b8ad0-f8cf-48db-a4a2-753b280c21a5","commitTimeStamp":"2016-06-30T06:07:02.944923Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1715.json","@type":"CatalogPage","commitId":"120afbea-be92-49a3-96c6-e83f27d75f89","commitTimeStamp":"2016-06-30T13:28:38.7583143Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1716.json","@type":"CatalogPage","commitId":"3a1b61c9-cd3a-4037-9e4b-f9812a6714f6","commitTimeStamp":"2016-06-30T22:28:03.0843567Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1717.json","@type":"CatalogPage","commitId":"19698e06-8e10-4f6c-bcc7-11289eb3ca36","commitTimeStamp":"2016-07-01T10:03:04.1767609Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1718.json","@type":"CatalogPage","commitId":"39a2778a-ff52-48c7-be93-18e50d890ad0","commitTimeStamp":"2016-07-01T14:39:17.3092665Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1719.json","@type":"CatalogPage","commitId":"b167cf7b-45fb-461a-8c15-4e9a82229b19","commitTimeStamp":"2016-07-01T23:41:18.8342608Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1720.json","@type":"CatalogPage","commitId":"d0b3d836-113e-4fa5-a5ca-5ad9fb28b9ee","commitTimeStamp":"2016-07-02T22:02:58.6449561Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1721.json","@type":"CatalogPage","commitId":"8f3a746e-629c-4fd9-8bfb-856098364d7e","commitTimeStamp":"2016-07-04T01:41:09.9836562Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1722.json","@type":"CatalogPage","commitId":"df77c6dd-f235-4477-814e-c28a8627dc51","commitTimeStamp":"2016-07-04T11:41:52.4794306Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1723.json","@type":"CatalogPage","commitId":"6fb58b6c-6986-4ddb-b8e5-bbec6395dc80","commitTimeStamp":"2016-07-04T22:38:06.923776Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1724.json","@type":"CatalogPage","commitId":"1a35caf7-3717-4808-a90c-92d46d194dea","commitTimeStamp":"2016-07-05T12:24:35.2587477Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1725.json","@type":"CatalogPage","commitId":"c64983a4-915f-4751-abf9-0961b9995b79","commitTimeStamp":"2016-07-05T17:07:14.4059421Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1726.json","@type":"CatalogPage","commitId":"8065c963-ede5-45ca-8274-1872f8d4d409","commitTimeStamp":"2016-07-06T04:18:13.3051533Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1727.json","@type":"CatalogPage","commitId":"5ca32592-bee2-4892-be5d-79f8a1444c86","commitTimeStamp":"2016-07-06T16:53:49.1692174Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1728.json","@type":"CatalogPage","commitId":"6a54da09-4a83-40fe-90da-75e655f29215","commitTimeStamp":"2016-07-07T07:09:06.698976Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1729.json","@type":"CatalogPage","commitId":"b6622710-5f8d-47b2-9c76-7689e02340e7","commitTimeStamp":"2016-07-07T14:17:27.8132595Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1730.json","@type":"CatalogPage","commitId":"d496e9bc-a1c0-424f-970d-bbbaa8153fd7","commitTimeStamp":"2016-07-07T22:18:16.124361Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1731.json","@type":"CatalogPage","commitId":"cd106858-7e9b-427d-bbf0-499bcf0be3fb","commitTimeStamp":"2016-07-08T11:36:45.1826221Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1732.json","@type":"CatalogPage","commitId":"f68a8bb0-7c7b-44d8-96bf-948135c29b04","commitTimeStamp":"2016-07-08T22:45:11.5323939Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1733.json","@type":"CatalogPage","commitId":"64e22f8c-452e-4760-aa74-8af39a87bc1c","commitTimeStamp":"2016-07-09T15:43:12.9733002Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1734.json","@type":"CatalogPage","commitId":"6c13d43d-e1d9-4544-8e7c-1600cd50ca81","commitTimeStamp":"2016-07-10T17:34:59.888075Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1735.json","@type":"CatalogPage","commitId":"b9bd942f-e798-4218-9078-61b236cc4265","commitTimeStamp":"2016-07-11T12:27:08.4165064Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1736.json","@type":"CatalogPage","commitId":"024a3281-3304-431f-8b75-22b87de68a30","commitTimeStamp":"2016-07-11T20:24:47.6853792Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1737.json","@type":"CatalogPage","commitId":"13154238-2c40-48d2-b6d2-9eb5e8beabd8","commitTimeStamp":"2016-07-12T10:02:44.2609887Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1738.json","@type":"CatalogPage","commitId":"c8a35fd0-9e39-4e27-9251-6f4143dbb4d4","commitTimeStamp":"2016-07-12T17:17:19.9061698Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1739.json","@type":"CatalogPage","commitId":"8557f9cc-86c1-410e-b0ab-ca5b50db6d62","commitTimeStamp":"2016-07-13T00:58:50.330643Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1740.json","@type":"CatalogPage","commitId":"18422798-1bda-44d4-af4f-2f91654fbcc6","commitTimeStamp":"2016-07-13T11:53:42.3665854Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1741.json","@type":"CatalogPage","commitId":"594e682e-1db6-42b6-8091-c77e689855c6","commitTimeStamp":"2016-07-13T23:10:27.8229444Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1742.json","@type":"CatalogPage","commitId":"da27f870-28e8-488c-b3d0-2f7a7264606d","commitTimeStamp":"2016-07-14T10:42:51.1083312Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1743.json","@type":"CatalogPage","commitId":"7fb94421-d4dd-4337-b305-4bfce557be2d","commitTimeStamp":"2016-07-14T16:29:47.2718964Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1744.json","@type":"CatalogPage","commitId":"8fb1a048-5aa1-400a-baa6-136d4221cfc1","commitTimeStamp":"2016-07-15T05:37:47.6295227Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1745.json","@type":"CatalogPage","commitId":"e3e20065-be12-47c0-89f7-7b3426ec6b1a","commitTimeStamp":"2016-07-15T08:36:38.97377Z","count":542},{"@id":"https://api.nuget.org/v3/catalog0/page1746.json","@type":"CatalogPage","commitId":"6beb11c7-587a-4528-9211-de01e2c7877a","commitTimeStamp":"2016-07-15T08:52:12.1239891Z","count":544},{"@id":"https://api.nuget.org/v3/catalog0/page1747.json","@type":"CatalogPage","commitId":"95dfa78f-5f85-4800-9a9c-d5e71627ec7a","commitTimeStamp":"2016-07-15T14:25:42.9406589Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1748.json","@type":"CatalogPage","commitId":"141efa59-c9bf-4df6-a5f2-89d192a22415","commitTimeStamp":"2016-07-16T01:14:49.6577789Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1749.json","@type":"CatalogPage","commitId":"2c7efd91-ddac-4e0b-9778-58414cc721d8","commitTimeStamp":"2016-07-16T15:26:04.0839423Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1750.json","@type":"CatalogPage","commitId":"09d8b12c-bcec-46ba-bdaf-046a1513e9e9","commitTimeStamp":"2016-07-17T07:20:13.7123308Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1751.json","@type":"CatalogPage","commitId":"2905d02e-c1b3-4e1a-99c9-c6a5a00c5edb","commitTimeStamp":"2016-07-17T18:32:51.8851378Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1752.json","@type":"CatalogPage","commitId":"f9f2f6c7-7e3d-4719-8ace-e1058bfcd434","commitTimeStamp":"2016-07-18T08:04:29.1198554Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1753.json","@type":"CatalogPage","commitId":"2ac7ba39-0caa-4244-a5a3-8386a1a6fcd3","commitTimeStamp":"2016-07-18T17:28:47.3568918Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1754.json","@type":"CatalogPage","commitId":"ae86e45d-d796-43d6-b2da-d4e324ef07fa","commitTimeStamp":"2016-07-18T23:54:55.7635844Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page1755.json","@type":"CatalogPage","commitId":"3cd0b91c-7437-4558-a88a-0f025c4022e1","commitTimeStamp":"2016-07-19T10:26:45.3969585Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1756.json","@type":"CatalogPage","commitId":"818c88ce-9021-420a-a7ed-49629f7f2b93","commitTimeStamp":"2016-07-19T16:58:30.728871Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1757.json","@type":"CatalogPage","commitId":"41107feb-f350-47ac-810e-4f624d80c0b7","commitTimeStamp":"2016-07-20T03:25:09.4561105Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1758.json","@type":"CatalogPage","commitId":"76381921-9b91-4135-a52c-888eebaa745b","commitTimeStamp":"2016-07-20T12:57:42.8818527Z","count":542},{"@id":"https://api.nuget.org/v3/catalog0/page1759.json","@type":"CatalogPage","commitId":"a78e311b-6d13-4692-8aa4-eb78e47ea0dd","commitTimeStamp":"2016-07-20T19:32:42.8575732Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1760.json","@type":"CatalogPage","commitId":"5c8cdec1-6306-4c9e-93dc-66f55620820c","commitTimeStamp":"2016-07-21T08:01:57.2762024Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1761.json","@type":"CatalogPage","commitId":"50e6376e-74de-469a-b8e6-b86d5e40f717","commitTimeStamp":"2016-07-21T14:04:08.9685609Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1762.json","@type":"CatalogPage","commitId":"22c04a5f-cf95-4453-8755-653d6ca0d0de","commitTimeStamp":"2016-07-21T18:16:19.1916024Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1763.json","@type":"CatalogPage","commitId":"43d50ae1-26ad-4298-a236-0100d77380a6","commitTimeStamp":"2016-07-22T01:05:32.7063086Z","count":544},{"@id":"https://api.nuget.org/v3/catalog0/page1764.json","@type":"CatalogPage","commitId":"bb4d8d45-ea98-4828-b286-eedf89113722","commitTimeStamp":"2016-07-22T10:23:11.7501921Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1765.json","@type":"CatalogPage","commitId":"58b8bcb5-776e-4f46-915d-1760422e13e9","commitTimeStamp":"2016-07-22T19:13:31.6435498Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page1766.json","@type":"CatalogPage","commitId":"8be06b9b-d685-4eab-b9dc-59aae51c4c88","commitTimeStamp":"2016-07-23T11:18:02.2078331Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1767.json","@type":"CatalogPage","commitId":"892273eb-dd02-4ca0-a4d1-8aa1d93af362","commitTimeStamp":"2016-07-24T11:16:26.3254083Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1768.json","@type":"CatalogPage","commitId":"3ec215ae-699f-4f93-b1cf-352ec18ba376","commitTimeStamp":"2016-07-25T07:48:37.025044Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1769.json","@type":"CatalogPage","commitId":"2000b7ea-a36f-46fd-941a-6d7c23941429","commitTimeStamp":"2016-07-25T18:22:09.2415573Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1770.json","@type":"CatalogPage","commitId":"e4b02c39-57dd-4571-8c4d-e9b193f44998","commitTimeStamp":"2016-07-26T09:13:02.8245256Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1771.json","@type":"CatalogPage","commitId":"5b9647d3-2b82-4f14-b1fe-d8d6f0370433","commitTimeStamp":"2016-07-26T17:44:43.9469583Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1772.json","@type":"CatalogPage","commitId":"e64fc4e0-be5e-4286-831b-7c3d537b5a3b","commitTimeStamp":"2016-07-27T08:17:52.1964633Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1773.json","@type":"CatalogPage","commitId":"0794aebf-50fb-4158-8551-da3222a82f26","commitTimeStamp":"2016-07-27T18:25:19.7267169Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1774.json","@type":"CatalogPage","commitId":"8fc38055-c2e5-4e20-be28-3a87ac7afeef","commitTimeStamp":"2016-07-28T09:53:19.9217191Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1775.json","@type":"CatalogPage","commitId":"255eab5c-5fb0-4999-8ad7-b249b6aeb7f2","commitTimeStamp":"2016-07-28T16:01:55.5730703Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1776.json","@type":"CatalogPage","commitId":"c889bf19-2284-416c-a169-63b868d49f5e","commitTimeStamp":"2016-07-29T06:08:47.0992763Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1777.json","@type":"CatalogPage","commitId":"7399aab3-4c44-429f-affb-3d70c20f2796","commitTimeStamp":"2016-07-29T13:31:11.5146341Z","count":542},{"@id":"https://api.nuget.org/v3/catalog0/page1778.json","@type":"CatalogPage","commitId":"589c87a3-64b8-450d-82ea-cae2ded2f5f3","commitTimeStamp":"2016-07-29T23:39:55.2559989Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1779.json","@type":"CatalogPage","commitId":"c45d8578-4068-44c4-9566-d0f30e22b72d","commitTimeStamp":"2016-07-30T17:58:53.7731995Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1780.json","@type":"CatalogPage","commitId":"9a85ba63-94d7-469e-aa27-7548bf2ec5d5","commitTimeStamp":"2016-07-31T21:13:31.2199278Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1781.json","@type":"CatalogPage","commitId":"1eb0d856-aae6-4a94-ae75-8bf5770f08fd","commitTimeStamp":"2016-08-01T12:17:37.8296177Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1782.json","@type":"CatalogPage","commitId":"89220fab-8fed-42b1-a92c-c477466d86c2","commitTimeStamp":"2016-08-01T21:39:20.5637236Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1783.json","@type":"CatalogPage","commitId":"103b979f-8132-406b-9f37-e20bd1348e65","commitTimeStamp":"2016-08-02T10:26:31.8108976Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1784.json","@type":"CatalogPage","commitId":"3d39ae1b-e629-48f0-88a5-704b76f929aa","commitTimeStamp":"2016-08-02T21:10:35.7534862Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1785.json","@type":"CatalogPage","commitId":"4a15bd7f-96a2-4e57-acd3-898e7b792aa3","commitTimeStamp":"2016-08-03T09:21:24.8178581Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1786.json","@type":"CatalogPage","commitId":"a6cd5cd9-c56c-4b36-89e1-4c9d9a5b6ade","commitTimeStamp":"2016-08-03T18:01:48.4234469Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1787.json","@type":"CatalogPage","commitId":"1909a2da-fb16-4404-b367-bdeef0355d8b","commitTimeStamp":"2016-08-04T06:36:49.9444849Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1788.json","@type":"CatalogPage","commitId":"3e42aab1-8ac0-4c9d-9ce0-ec4da5e6ffb4","commitTimeStamp":"2016-08-04T16:30:11.6838739Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1789.json","@type":"CatalogPage","commitId":"15ebb7bd-28e3-4c18-b691-8a6d9dd6915b","commitTimeStamp":"2016-08-04T23:45:30.3686081Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1790.json","@type":"CatalogPage","commitId":"14e5fb54-febf-4580-9fc1-986b00ed8b94","commitTimeStamp":"2016-08-05T09:32:29.9999799Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1791.json","@type":"CatalogPage","commitId":"b9bf81f5-577c-4b5f-b01d-585ef1815291","commitTimeStamp":"2016-08-05T20:38:15.6792001Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1792.json","@type":"CatalogPage","commitId":"8a0c296b-69b2-4a6e-9a19-1e37ad1f788b","commitTimeStamp":"2016-08-07T02:42:32.9798619Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1793.json","@type":"CatalogPage","commitId":"623d2336-fa9f-42f0-a3e0-c498283de2c6","commitTimeStamp":"2016-08-08T03:51:10.0756687Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1794.json","@type":"CatalogPage","commitId":"a8d77a1a-3780-4040-b2ff-b908d1870d74","commitTimeStamp":"2016-08-08T14:12:57.7600912Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1795.json","@type":"CatalogPage","commitId":"24dd392c-30e9-445b-8934-7c8956620b6d","commitTimeStamp":"2016-08-08T23:03:12.5089488Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1796.json","@type":"CatalogPage","commitId":"18c93ff0-a1a2-4708-a0af-44a5aa3651cf","commitTimeStamp":"2016-08-09T06:14:44.1465332Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1797.json","@type":"CatalogPage","commitId":"f2a37110-282b-4f81-baca-86adf17044c9","commitTimeStamp":"2016-08-09T16:10:10.9021667Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1798.json","@type":"CatalogPage","commitId":"a376ba6c-4912-479a-b8d6-d28a9dd2bb51","commitTimeStamp":"2016-08-09T23:15:26.2382459Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1799.json","@type":"CatalogPage","commitId":"c4107582-e11c-4df2-8f6a-e98671083751","commitTimeStamp":"2016-08-10T10:55:33.5877262Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1800.json","@type":"CatalogPage","commitId":"a02f6a63-2b45-44cf-b104-705dbe7b0e75","commitTimeStamp":"2016-08-10T20:20:07.7121597Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1801.json","@type":"CatalogPage","commitId":"34400ee7-20e6-483c-8632-f094e05e55ba","commitTimeStamp":"2016-08-11T07:15:15.8289476Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1802.json","@type":"CatalogPage","commitId":"a7f3f40e-f031-4245-89b3-189da2c145bb","commitTimeStamp":"2016-08-11T14:02:27.7620521Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1803.json","@type":"CatalogPage","commitId":"264b0a62-4cc3-45f4-acc3-7803c6c69041","commitTimeStamp":"2016-08-11T21:57:26.2814129Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1804.json","@type":"CatalogPage","commitId":"0bdb3783-44ee-4f68-a30f-3192d8d10d4d","commitTimeStamp":"2016-08-12T05:15:48.9540098Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1805.json","@type":"CatalogPage","commitId":"ff5dc45e-3cd2-4385-b3b6-55636ccdf89c","commitTimeStamp":"2016-08-12T15:36:25.7002962Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1806.json","@type":"CatalogPage","commitId":"42c3da50-82c8-4086-9713-9d0eb76542ba","commitTimeStamp":"2016-08-13T07:52:25.5101129Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1807.json","@type":"CatalogPage","commitId":"03c789a4-dc67-47c0-9fe9-674db69f18aa","commitTimeStamp":"2016-08-14T12:23:06.8841966Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1808.json","@type":"CatalogPage","commitId":"9f8f3dbd-c543-4333-b384-e5181c30fcaa","commitTimeStamp":"2016-08-15T10:09:55.793114Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1809.json","@type":"CatalogPage","commitId":"624c8a3c-ec11-449a-8869-928ffc1bc394","commitTimeStamp":"2016-08-15T20:09:58.9307319Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1810.json","@type":"CatalogPage","commitId":"dcf9ec3e-1e83-40bd-b014-0f5ca82b0eb9","commitTimeStamp":"2016-08-16T07:43:14.4914204Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1811.json","@type":"CatalogPage","commitId":"94ec963e-d949-4c5f-aded-0eeba8d4de9d","commitTimeStamp":"2016-08-16T17:33:34.3548606Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1812.json","@type":"CatalogPage","commitId":"bbda8f7e-53a2-4074-b617-106692cf06de","commitTimeStamp":"2016-08-17T09:17:28.3457976Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1813.json","@type":"CatalogPage","commitId":"e6b6e0cb-c0a9-4cb3-bbbc-aec2b64eba4c","commitTimeStamp":"2016-08-17T18:52:46.8982204Z","count":531},{"@id":"https://api.nuget.org/v3/catalog0/page1814.json","@type":"CatalogPage","commitId":"4d783a78-c947-42ff-907a-32b8265b0eb7","commitTimeStamp":"2016-08-18T08:17:32.914784Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1815.json","@type":"CatalogPage","commitId":"84e9a7b0-5a52-4123-8f7f-dcb933801ee2","commitTimeStamp":"2016-08-18T17:50:00.5706066Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1816.json","@type":"CatalogPage","commitId":"322ea699-8bf3-4f9b-949c-febcce8f6aa3","commitTimeStamp":"2016-08-19T05:56:37.934312Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1817.json","@type":"CatalogPage","commitId":"00a71401-4900-4b9c-8368-af89099387d3","commitTimeStamp":"2016-08-19T17:32:20.7072307Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1818.json","@type":"CatalogPage","commitId":"2243c7d6-e40d-4cf6-ac09-b8fc890907a9","commitTimeStamp":"2016-08-20T07:45:14.617952Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1819.json","@type":"CatalogPage","commitId":"36710251-d0dd-4a74-94e9-0cfbf80f870b","commitTimeStamp":"2016-08-21T09:38:20.1659042Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1820.json","@type":"CatalogPage","commitId":"86d42438-05db-4710-9182-5741f6d68a09","commitTimeStamp":"2016-08-22T05:55:52.5496303Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1821.json","@type":"CatalogPage","commitId":"69f85e3d-867a-4f10-99ac-d438ea608262","commitTimeStamp":"2016-08-22T14:05:51.5062219Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1822.json","@type":"CatalogPage","commitId":"cf3bba9d-abfe-4883-8b9f-985de314163e","commitTimeStamp":"2016-08-22T23:25:12.6158356Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1823.json","@type":"CatalogPage","commitId":"162d558d-95df-4f2c-8ed3-a49fcf729a47","commitTimeStamp":"2016-08-23T11:32:52.1001531Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1824.json","@type":"CatalogPage","commitId":"b753e390-204f-4e59-99da-9dd3e4b3127c","commitTimeStamp":"2016-08-23T19:27:36.3955533Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page1825.json","@type":"CatalogPage","commitId":"8405bdd8-87d6-4f03-9bc4-82ca817ec211","commitTimeStamp":"2016-08-24T03:50:59.1253405Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1826.json","@type":"CatalogPage","commitId":"2f0c86bf-0c76-4f21-8ac7-e0309851c79e","commitTimeStamp":"2016-08-24T12:07:05.9431052Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1827.json","@type":"CatalogPage","commitId":"2c4cd519-bc27-49d0-b97d-dc2a84016820","commitTimeStamp":"2016-08-24T21:32:12.5883683Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1828.json","@type":"CatalogPage","commitId":"983eb3c0-fe9d-49aa-bb0d-371ce8e8db73","commitTimeStamp":"2016-08-25T13:10:38.6252074Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1829.json","@type":"CatalogPage","commitId":"ef1b06f4-c703-45ee-b5a0-d2c5947d5606","commitTimeStamp":"2016-08-25T21:02:37.3768006Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1830.json","@type":"CatalogPage","commitId":"bb04d84c-229f-47ea-b02c-78521ef719f1","commitTimeStamp":"2016-08-26T12:04:16.7225472Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1831.json","@type":"CatalogPage","commitId":"7c490ab4-4603-4d0a-84d9-7f93ed652164","commitTimeStamp":"2016-08-27T01:01:18.8763722Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1832.json","@type":"CatalogPage","commitId":"202f8aa1-2bcf-4ae9-bdd6-d48acad79806","commitTimeStamp":"2016-08-28T05:42:41.0672786Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1833.json","@type":"CatalogPage","commitId":"980c0654-26db-47c9-9f7c-35fb5f4b29d9","commitTimeStamp":"2016-08-29T01:18:15.7172776Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1834.json","@type":"CatalogPage","commitId":"8a294540-96a8-44a8-be82-625762abdca9","commitTimeStamp":"2016-08-29T13:08:50.7135569Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1835.json","@type":"CatalogPage","commitId":"836016be-4343-478b-bee4-948d88124df9","commitTimeStamp":"2016-08-29T21:29:57.3267144Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1836.json","@type":"CatalogPage","commitId":"fe673f1b-7b42-4d75-bf8a-a91a4ca2c8cb","commitTimeStamp":"2016-08-30T13:46:58.4935517Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1837.json","@type":"CatalogPage","commitId":"9e877519-b854-486c-a561-1433c9bfb553","commitTimeStamp":"2016-08-31T03:42:38.4886456Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1838.json","@type":"CatalogPage","commitId":"5da525d1-1466-49ce-b79e-f94b9533613c","commitTimeStamp":"2016-08-31T15:05:34.226642Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1839.json","@type":"CatalogPage","commitId":"c6cefed4-ea81-4ef9-8908-f945847b1a33","commitTimeStamp":"2016-09-01T00:39:10.4178926Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1840.json","@type":"CatalogPage","commitId":"cd8f8dd5-7409-478c-b442-9698f53b6ea6","commitTimeStamp":"2016-09-01T14:01:33.2725832Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1841.json","@type":"CatalogPage","commitId":"c1dc18e0-d48d-4fd0-b787-2914c51ea2f1","commitTimeStamp":"2016-09-01T21:53:45.2948304Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1842.json","@type":"CatalogPage","commitId":"c8e4da9b-3cab-4262-b763-abe044a7677d","commitTimeStamp":"2016-09-02T09:34:30.4316766Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1843.json","@type":"CatalogPage","commitId":"c65b5e62-2429-42eb-8a01-77e51033c3b1","commitTimeStamp":"2016-09-02T16:00:17.6014451Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1844.json","@type":"CatalogPage","commitId":"64001c7a-f9fa-4460-8bcc-bdcf7cbd1bf8","commitTimeStamp":"2016-09-03T12:36:07.9662686Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1845.json","@type":"CatalogPage","commitId":"79a18e1f-67f0-43c8-9a6f-504082d112ee","commitTimeStamp":"2016-09-04T09:39:32.2558583Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1846.json","@type":"CatalogPage","commitId":"85fa00db-39a0-43c9-bc4a-c06c18292795","commitTimeStamp":"2016-09-05T04:50:55.6276597Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1847.json","@type":"CatalogPage","commitId":"1a6ab1ed-abff-4828-b653-1385bcb81af2","commitTimeStamp":"2016-09-05T14:16:23.9510327Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page1848.json","@type":"CatalogPage","commitId":"44777791-e990-4983-b548-bb41559cacc8","commitTimeStamp":"2016-09-06T08:14:16.2885642Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1849.json","@type":"CatalogPage","commitId":"6f7be2ba-b9ab-42a3-8ff4-9547a3ad508e","commitTimeStamp":"2016-09-06T16:03:00.0443883Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1850.json","@type":"CatalogPage","commitId":"8c0e5e6d-984e-46ed-bcd8-68e067fa57e4","commitTimeStamp":"2016-09-07T03:21:18.2343711Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1851.json","@type":"CatalogPage","commitId":"ce4a6071-3a31-4258-91f5-0b869b57251b","commitTimeStamp":"2016-09-07T11:53:00.2779647Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1852.json","@type":"CatalogPage","commitId":"0b2f4640-eee9-4212-bc16-e555fbb944eb","commitTimeStamp":"2016-09-07T20:42:18.1662823Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1853.json","@type":"CatalogPage","commitId":"211c6b7f-5169-4787-a9e4-53cbab3fb066","commitTimeStamp":"2016-09-08T09:21:06.3864017Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1854.json","@type":"CatalogPage","commitId":"f160443d-2fed-4b22-a875-e80f91be006f","commitTimeStamp":"2016-09-08T14:18:47.8513311Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1855.json","@type":"CatalogPage","commitId":"2aac359f-ca73-4169-9327-917403a248ae","commitTimeStamp":"2016-09-09T00:32:31.3002268Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1856.json","@type":"CatalogPage","commitId":"c25c69f1-18b8-4439-96df-b8f93f45202e","commitTimeStamp":"2016-09-09T12:13:14.0182822Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1857.json","@type":"CatalogPage","commitId":"8b919a6c-123c-451d-b59d-1baf1ce13723","commitTimeStamp":"2016-09-09T21:24:49.1869994Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page1858.json","@type":"CatalogPage","commitId":"eabac624-d6b0-454f-8b1a-769805dae12c","commitTimeStamp":"2016-09-10T14:53:31.613225Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1859.json","@type":"CatalogPage","commitId":"228dd752-c0fa-4fe0-9d85-1e946d6180d1","commitTimeStamp":"2016-09-11T16:26:07.6408215Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1860.json","@type":"CatalogPage","commitId":"0ba184a9-c191-45db-aa1c-108eb989a5c8","commitTimeStamp":"2016-09-12T06:34:35.7666298Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1861.json","@type":"CatalogPage","commitId":"eff22441-62d4-4c49-9350-08d66c83e8b2","commitTimeStamp":"2016-09-12T11:32:44.0569107Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1862.json","@type":"CatalogPage","commitId":"7c2b7f15-4284-4da2-a7bc-268f175347f1","commitTimeStamp":"2016-09-12T17:17:44.9523964Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1863.json","@type":"CatalogPage","commitId":"f37cc05a-30cf-4a26-b400-dab005b12fed","commitTimeStamp":"2016-09-13T09:48:23.4977461Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1864.json","@type":"CatalogPage","commitId":"aeeb098e-a869-480b-be91-79870b2df043","commitTimeStamp":"2016-09-13T18:51:05.8408126Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1865.json","@type":"CatalogPage","commitId":"dda6eb65-1af6-45a3-92c9-2bf076829351","commitTimeStamp":"2016-09-14T08:11:51.759113Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1866.json","@type":"CatalogPage","commitId":"7ab3fbc8-eee4-4fdf-979a-fc95fbff6abc","commitTimeStamp":"2016-09-14T15:50:14.7866253Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1867.json","@type":"CatalogPage","commitId":"9e1d1dce-be6f-4f7d-9a70-66bfe9d7c8c5","commitTimeStamp":"2016-09-15T08:14:44.5603852Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1868.json","@type":"CatalogPage","commitId":"60c6fef6-2c80-44e9-91d2-323ee071c761","commitTimeStamp":"2016-09-15T16:35:27.1266557Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1869.json","@type":"CatalogPage","commitId":"06ea7112-e2aa-4a56-8952-6f2b8f6c44fe","commitTimeStamp":"2016-09-16T04:14:59.9404569Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1870.json","@type":"CatalogPage","commitId":"edfeb9c0-161b-49ec-b39f-b295d14d4053","commitTimeStamp":"2016-09-16T15:38:26.3034519Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1871.json","@type":"CatalogPage","commitId":"4095bdb4-996f-47cc-8f1d-39b7c9d26c65","commitTimeStamp":"2016-09-17T08:46:45.5122926Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1872.json","@type":"CatalogPage","commitId":"ac18574a-1794-40e5-849b-8b4805c9a9b6","commitTimeStamp":"2016-09-18T10:58:15.116096Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1873.json","@type":"CatalogPage","commitId":"dd806565-f373-45e2-ad0f-21810e0e7124","commitTimeStamp":"2016-09-19T08:12:40.5157532Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1874.json","@type":"CatalogPage","commitId":"f784482c-d0bb-4f87-8854-85e48ae5a6a2","commitTimeStamp":"2016-09-19T16:18:28.9371105Z","count":542},{"@id":"https://api.nuget.org/v3/catalog0/page1875.json","@type":"CatalogPage","commitId":"d4d19151-35c9-48c0-bf37-7454fa860b63","commitTimeStamp":"2016-09-20T04:41:06.2627161Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1876.json","@type":"CatalogPage","commitId":"19792637-4325-4ba5-85a5-3eb135fb2607","commitTimeStamp":"2016-09-20T15:41:24.8207281Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1877.json","@type":"CatalogPage","commitId":"3a8ca0fc-70db-4a60-8bbd-65e79947ea71","commitTimeStamp":"2016-09-21T02:39:23.1443329Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1878.json","@type":"CatalogPage","commitId":"a1c7dce3-57fa-45de-bdb5-8a18ad40314f","commitTimeStamp":"2016-09-21T14:42:52.036902Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1879.json","@type":"CatalogPage","commitId":"eb6b00dd-68cc-4539-8c66-feec1aae537a","commitTimeStamp":"2016-09-22T02:37:01.0126116Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1880.json","@type":"CatalogPage","commitId":"ae162836-c38d-44e8-8992-20cb5efe7135","commitTimeStamp":"2016-09-22T15:50:01.4817788Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1881.json","@type":"CatalogPage","commitId":"4a69c46f-5447-4bac-a2c0-8f9d47ef9915","commitTimeStamp":"2016-09-23T02:27:50.9081441Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1882.json","@type":"CatalogPage","commitId":"4568ee08-ae8a-4e22-b783-54156cc5f302","commitTimeStamp":"2016-09-23T13:58:01.196172Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1883.json","@type":"CatalogPage","commitId":"b5a0e755-c2e8-43da-831a-69a7de2d6316","commitTimeStamp":"2016-09-24T07:29:28.963043Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1884.json","@type":"CatalogPage","commitId":"5eae059c-6a86-476e-914d-795e8202c11b","commitTimeStamp":"2016-09-25T10:06:18.7779008Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1885.json","@type":"CatalogPage","commitId":"4ff66548-4b5d-45f4-ae8f-e426f29d8f09","commitTimeStamp":"2016-09-26T04:19:22.9743953Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1886.json","@type":"CatalogPage","commitId":"94e26d42-ea31-492b-8232-ef4a424287db","commitTimeStamp":"2016-09-26T14:33:46.0457709Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1887.json","@type":"CatalogPage","commitId":"4a00db8a-d125-4e29-b80f-0dfdad9300a8","commitTimeStamp":"2016-09-27T02:48:03.782371Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1888.json","@type":"CatalogPage","commitId":"6a2633ca-76b6-4a9c-b0d7-6cf733732ddc","commitTimeStamp":"2016-09-27T12:51:50.4752378Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1889.json","@type":"CatalogPage","commitId":"edab1e55-e060-4431-8cc0-9159058c9512","commitTimeStamp":"2016-09-27T20:30:17.4841074Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1890.json","@type":"CatalogPage","commitId":"a00e51a0-516c-4365-99b3-d50bc5ec2fdd","commitTimeStamp":"2016-09-28T08:09:53.7814111Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1891.json","@type":"CatalogPage","commitId":"99552a2f-19b3-4d7d-8d0d-cbfeb72ea379","commitTimeStamp":"2016-09-28T16:50:22.9911976Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1892.json","@type":"CatalogPage","commitId":"7283b21c-84f8-48cc-bd1e-4eacab1949fe","commitTimeStamp":"2016-09-28T23:53:53.7102915Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1893.json","@type":"CatalogPage","commitId":"b5ab6c30-03e1-474f-8ed2-70b92ce58fb7","commitTimeStamp":"2016-09-29T09:39:56.3069594Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1894.json","@type":"CatalogPage","commitId":"435d6b24-9cbc-437a-8e83-9fff4810ab96","commitTimeStamp":"2016-09-29T16:05:47.3304017Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1895.json","@type":"CatalogPage","commitId":"09ab3527-d1d6-42f2-bf93-7d58508e1243","commitTimeStamp":"2016-09-30T07:21:45.755795Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1896.json","@type":"CatalogPage","commitId":"31c81ffc-ac21-45c4-83c9-6f8298239c38","commitTimeStamp":"2016-09-30T15:54:01.3443168Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1897.json","@type":"CatalogPage","commitId":"6a0b6f63-f602-4176-9a07-eef66f14deb7","commitTimeStamp":"2016-10-01T02:03:23.0259315Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1898.json","@type":"CatalogPage","commitId":"6caecf5b-b502-456d-93bd-0b258675f6b9","commitTimeStamp":"2016-10-02T11:43:57.0784488Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1899.json","@type":"CatalogPage","commitId":"7aa3f5b0-a24a-4a50-9d32-8cd4a2f16cb9","commitTimeStamp":"2016-10-03T08:06:10.7908586Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1900.json","@type":"CatalogPage","commitId":"3e3224e0-5c3e-44ae-955e-9605d6e46481","commitTimeStamp":"2016-10-03T16:00:36.4101923Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1901.json","@type":"CatalogPage","commitId":"79fcde65-1a6a-48b2-a7ed-8e7c613d76c2","commitTimeStamp":"2016-10-03T21:10:14.9340189Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page1902.json","@type":"CatalogPage","commitId":"b64e5ac2-0371-4ac4-9678-c45c76d62ec8","commitTimeStamp":"2016-10-04T09:30:30.1865303Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1903.json","@type":"CatalogPage","commitId":"abf1c950-3377-4c7e-b353-5f0bf6d96082","commitTimeStamp":"2016-10-04T19:17:48.2814248Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1904.json","@type":"CatalogPage","commitId":"a5a71622-c55e-47ba-aa3f-14ac2f254189","commitTimeStamp":"2016-10-05T13:25:45.6444531Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1905.json","@type":"CatalogPage","commitId":"d9f32afa-8707-4c9b-a7bd-745131c2c38a","commitTimeStamp":"2016-10-05T21:31:56.7392617Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1906.json","@type":"CatalogPage","commitId":"de42e899-2e33-4fe5-b5db-ea6f5afeb0fe","commitTimeStamp":"2016-10-06T09:52:45.2409383Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1907.json","@type":"CatalogPage","commitId":"4ee8c6ca-0c7c-4179-85c1-027fb4ec0fb0","commitTimeStamp":"2016-10-06T16:35:48.9660025Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1908.json","@type":"CatalogPage","commitId":"5480a9dc-b21f-40ae-8156-4e5751eda374","commitTimeStamp":"2016-10-06T21:58:52.391887Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1909.json","@type":"CatalogPage","commitId":"61b0ac82-5475-48c1-bd1d-69a35d2254fd","commitTimeStamp":"2016-10-07T09:41:46.7398379Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1910.json","@type":"CatalogPage","commitId":"8431314b-e3ef-4848-be86-579ac266e001","commitTimeStamp":"2016-10-07T19:23:59.3619408Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1911.json","@type":"CatalogPage","commitId":"1d598008-23d6-4003-973b-182b35c5b7ed","commitTimeStamp":"2016-10-08T15:15:39.0713005Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1912.json","@type":"CatalogPage","commitId":"fe9fe94d-f408-4f35-bf8f-5476ef4b7254","commitTimeStamp":"2016-10-09T16:57:08.1043599Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1913.json","@type":"CatalogPage","commitId":"a0f5a580-35e8-40ed-9bc1-6bfc939fc0d2","commitTimeStamp":"2016-10-10T08:16:51.2257602Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1914.json","@type":"CatalogPage","commitId":"7682320f-c238-420b-bede-80222074d7b0","commitTimeStamp":"2016-10-10T16:06:18.4911469Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1915.json","@type":"CatalogPage","commitId":"1615248c-250c-4510-9517-87544b7c12bf","commitTimeStamp":"2016-10-11T06:46:45.1573847Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1916.json","@type":"CatalogPage","commitId":"61367763-5f4d-4105-b941-d3e32aac6af6","commitTimeStamp":"2016-10-11T14:52:21.9114905Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1917.json","@type":"CatalogPage","commitId":"b4a09844-cad6-466a-a6ed-14c57e362d35","commitTimeStamp":"2016-10-12T01:34:12.4824143Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1918.json","@type":"CatalogPage","commitId":"95377ca0-c373-4ecf-b2b7-3a55c0f64e2f","commitTimeStamp":"2016-10-12T13:30:57.9601348Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1919.json","@type":"CatalogPage","commitId":"ba6d4e51-e51f-471a-8ec6-41a0242681ca","commitTimeStamp":"2016-10-12T22:13:13.1143665Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1920.json","@type":"CatalogPage","commitId":"2ba15871-89dd-4380-9ffb-c16fcf474765","commitTimeStamp":"2016-10-13T06:46:08.6421335Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1921.json","@type":"CatalogPage","commitId":"11a82196-3981-4989-9d8b-26c587bc27cc","commitTimeStamp":"2016-10-13T13:37:55.6770333Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1922.json","@type":"CatalogPage","commitId":"8ad6e3e9-7ec8-4cdc-af2c-27e24b080daa","commitTimeStamp":"2016-10-13T21:25:25.5035315Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1923.json","@type":"CatalogPage","commitId":"fee09fba-4c1e-4f71-86e5-ff71380eb469","commitTimeStamp":"2016-10-14T09:33:29.656747Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1924.json","@type":"CatalogPage","commitId":"d7a053ba-20ab-4964-ba6e-9b08f4ec37fe","commitTimeStamp":"2016-10-14T20:54:56.2056384Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1925.json","@type":"CatalogPage","commitId":"5a0ce8ce-0275-4c9d-9521-b8be99384d46","commitTimeStamp":"2016-10-15T16:19:47.352807Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1926.json","@type":"CatalogPage","commitId":"341f097b-c60d-4f0e-a65e-0b8cbe18509d","commitTimeStamp":"2016-10-16T12:52:03.196116Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1927.json","@type":"CatalogPage","commitId":"083bbca3-803e-4937-808c-8185b48efc21","commitTimeStamp":"2016-10-17T03:38:34.3093716Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1928.json","@type":"CatalogPage","commitId":"8d5160ab-9986-4f23-9f77-1256b108ef65","commitTimeStamp":"2016-10-17T12:39:20.1542642Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1929.json","@type":"CatalogPage","commitId":"f85f5bb0-5b03-4515-be69-4743f737226d","commitTimeStamp":"2016-10-17T22:40:00.9324523Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1930.json","@type":"CatalogPage","commitId":"a811d1e9-5d37-494d-a412-fed2971ce226","commitTimeStamp":"2016-10-18T09:01:43.0404462Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1931.json","@type":"CatalogPage","commitId":"30427605-1082-4413-adbf-4fc39bf7d63e","commitTimeStamp":"2016-10-18T18:40:38.1919417Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1932.json","@type":"CatalogPage","commitId":"6eb78617-96cd-490b-9461-d2c9ccfe4b1d","commitTimeStamp":"2016-10-19T08:21:17.6468615Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1933.json","@type":"CatalogPage","commitId":"a8146e22-6a9e-4717-808a-d80933e956bb","commitTimeStamp":"2016-10-19T15:59:55.0859137Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page1934.json","@type":"CatalogPage","commitId":"6e760176-b268-4a64-837e-0a26fd2e7398","commitTimeStamp":"2016-10-19T23:15:05.9666421Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1935.json","@type":"CatalogPage","commitId":"75d8b86c-10cf-4985-9735-b1d57294ea25","commitTimeStamp":"2016-10-20T09:39:52.4930736Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1936.json","@type":"CatalogPage","commitId":"bea68b12-021e-41e6-a767-e9926abb29c2","commitTimeStamp":"2016-10-20T15:37:19.6144935Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1937.json","@type":"CatalogPage","commitId":"fd782d98-096a-48a4-8ae1-074c51fb2a6b","commitTimeStamp":"2016-10-20T21:58:35.1847325Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1938.json","@type":"CatalogPage","commitId":"53a9246d-b0bd-4d23-bfa8-1e277e0e4769","commitTimeStamp":"2016-10-21T11:31:22.8927907Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page1939.json","@type":"CatalogPage","commitId":"e98a4bcb-1c53-46d5-b347-788084262421","commitTimeStamp":"2016-10-21T20:28:42.7024538Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1940.json","@type":"CatalogPage","commitId":"14783c3f-64c3-4b38-a6c7-27b43e50d467","commitTimeStamp":"2016-10-22T17:59:57.4975679Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1941.json","@type":"CatalogPage","commitId":"07869d9c-c031-4399-be90-7ad000130461","commitTimeStamp":"2016-10-23T14:50:23.2852496Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1942.json","@type":"CatalogPage","commitId":"90597ce8-ab5e-4603-8035-1f53081cdee4","commitTimeStamp":"2016-10-24T09:50:34.6924784Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1943.json","@type":"CatalogPage","commitId":"5206e3ac-c30d-4fe7-8b31-ac1a5efad7a0","commitTimeStamp":"2016-10-24T16:12:28.2381162Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1944.json","@type":"CatalogPage","commitId":"a163f3f8-7335-4588-bd61-cd07bb99b4b3","commitTimeStamp":"2016-10-24T17:40:39.3219838Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1945.json","@type":"CatalogPage","commitId":"dcce0c0a-dc48-4508-8848-c5189cfee19d","commitTimeStamp":"2016-10-25T01:44:43.2244753Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1946.json","@type":"CatalogPage","commitId":"a320ebd1-4bef-432c-8a8a-5a672064b497","commitTimeStamp":"2016-10-25T09:47:04.3793176Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1947.json","@type":"CatalogPage","commitId":"bebfafe2-ddd1-4602-83c6-ffc4efb333df","commitTimeStamp":"2016-10-25T17:09:12.6407067Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1948.json","@type":"CatalogPage","commitId":"62285fbc-fdb4-41eb-865e-a6b0c76b6d09","commitTimeStamp":"2016-10-25T23:49:43.8409195Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1949.json","@type":"CatalogPage","commitId":"70af40db-69f4-42f0-91ac-e43cc88945cc","commitTimeStamp":"2016-10-26T10:03:36.2029226Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1950.json","@type":"CatalogPage","commitId":"f544c5f2-bfba-436b-a6ed-b2877d74db85","commitTimeStamp":"2016-10-26T16:29:26.4819328Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1951.json","@type":"CatalogPage","commitId":"430acaae-8e4a-4976-ab0f-8ae290692d36","commitTimeStamp":"2016-10-27T02:40:52.2376228Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1952.json","@type":"CatalogPage","commitId":"177ff4f0-9661-46d2-8c67-6af14477ca8a","commitTimeStamp":"2016-10-27T13:37:30.8641475Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1953.json","@type":"CatalogPage","commitId":"86d9bfbf-26cf-476f-88e5-f4597660f0fc","commitTimeStamp":"2016-10-27T20:01:55.824019Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1954.json","@type":"CatalogPage","commitId":"959df6d3-a6be-4780-9565-482ed546073a","commitTimeStamp":"2016-10-28T06:14:39.3850818Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1955.json","@type":"CatalogPage","commitId":"dc397de8-508a-4b7f-a7eb-e434d9dbb028","commitTimeStamp":"2016-10-28T15:33:33.6723406Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1956.json","@type":"CatalogPage","commitId":"01f256f7-7a34-49ef-bca1-d59cecbbac1f","commitTimeStamp":"2016-10-29T06:01:48.6411878Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1957.json","@type":"CatalogPage","commitId":"139196e9-7ac6-4b08-85b3-330ecf864ebc","commitTimeStamp":"2016-10-30T07:01:25.4390725Z","count":537},{"@id":"https://api.nuget.org/v3/catalog0/page1958.json","@type":"CatalogPage","commitId":"8b346d4c-84b3-4d86-b53e-edd99d32baa5","commitTimeStamp":"2016-10-30T18:11:40.1236863Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1959.json","@type":"CatalogPage","commitId":"a94ba521-7163-4bda-b2bd-692577c527ec","commitTimeStamp":"2016-10-31T08:32:09.3594476Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1960.json","@type":"CatalogPage","commitId":"227e1c80-d090-44ac-afca-b98cb53aa648","commitTimeStamp":"2016-10-31T16:45:43.7945537Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1961.json","@type":"CatalogPage","commitId":"c5a3b7be-66f5-4470-b2b7-a099f1c60f78","commitTimeStamp":"2016-11-01T05:33:57.3578841Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1962.json","@type":"CatalogPage","commitId":"04296478-3e06-478b-b691-29adfe8bfc1c","commitTimeStamp":"2016-11-01T11:05:39.8540235Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1963.json","@type":"CatalogPage","commitId":"f83e08cb-c497-4611-87e1-c104b38ee7fb","commitTimeStamp":"2016-11-01T17:35:58.3921919Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1964.json","@type":"CatalogPage","commitId":"5507fe70-a231-4cfe-b48b-2bb57ac4194e","commitTimeStamp":"2016-11-02T02:18:04.8560993Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1965.json","@type":"CatalogPage","commitId":"049a1582-7818-49ac-bc8a-8bc109dff45b","commitTimeStamp":"2016-11-02T13:46:19.175897Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1966.json","@type":"CatalogPage","commitId":"687d25eb-24ea-4cb4-9857-d269cb31280d","commitTimeStamp":"2016-11-02T21:20:11.9566991Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1967.json","@type":"CatalogPage","commitId":"3638da71-af4e-443d-8bab-04c41af457f9","commitTimeStamp":"2016-11-03T11:17:19.788194Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1968.json","@type":"CatalogPage","commitId":"770a9eec-156e-4ac6-bd57-7b0463acd5d9","commitTimeStamp":"2016-11-03T18:50:01.5586634Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1969.json","@type":"CatalogPage","commitId":"1949b75f-36fa-4a04-bebe-a9bfc590feac","commitTimeStamp":"2016-11-04T08:34:26.4986043Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1970.json","@type":"CatalogPage","commitId":"931a9e57-217c-41bd-9a55-026a6799b2db","commitTimeStamp":"2016-11-04T16:03:27.3913804Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1971.json","@type":"CatalogPage","commitId":"22890c24-0a81-4a95-9593-a337509602fd","commitTimeStamp":"2016-11-05T04:42:52.3694437Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1972.json","@type":"CatalogPage","commitId":"c269e022-57c1-4e7b-97c5-26e02d6055da","commitTimeStamp":"2016-11-05T22:38:32.3947059Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1973.json","@type":"CatalogPage","commitId":"a8877821-eba1-4d28-95f9-8111c8d8a202","commitTimeStamp":"2016-11-07T02:22:09.2825509Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1974.json","@type":"CatalogPage","commitId":"f9d4718a-1a53-4bbe-9ddb-f3142f7d33bd","commitTimeStamp":"2016-11-07T12:41:16.3981256Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1975.json","@type":"CatalogPage","commitId":"3a088cab-9c8b-4672-9b7f-a2f2e54a18d3","commitTimeStamp":"2016-11-07T21:35:22.488288Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1976.json","@type":"CatalogPage","commitId":"a74a4e31-8a86-4e28-b41d-14167d7db5da","commitTimeStamp":"2016-11-08T08:25:52.4572979Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1977.json","@type":"CatalogPage","commitId":"6cdab327-a0ba-4e0d-aaa8-79cb3ae72eb8","commitTimeStamp":"2016-11-08T13:24:02.6783584Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1978.json","@type":"CatalogPage","commitId":"9d02e08d-6def-4f28-9bd3-27dcb4ee55ee","commitTimeStamp":"2016-11-09T02:26:29.026772Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1979.json","@type":"CatalogPage","commitId":"99673553-5d7f-4931-9752-2341bb3b7fcd","commitTimeStamp":"2016-11-09T13:44:54.9505872Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page1980.json","@type":"CatalogPage","commitId":"b36a80e1-995e-40f1-917d-60457e0a0b0e","commitTimeStamp":"2016-11-09T22:25:54.4939615Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1981.json","@type":"CatalogPage","commitId":"68b7dd43-6e57-42b4-a8b7-4f0d0ff86043","commitTimeStamp":"2016-11-10T12:08:07.3365122Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page1982.json","@type":"CatalogPage","commitId":"ec92034b-ea19-4c30-86fc-3b3cb3687b09","commitTimeStamp":"2016-11-10T18:56:30.7374922Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1983.json","@type":"CatalogPage","commitId":"dc0aeac6-4d7c-4480-bb68-f329ca023e7b","commitTimeStamp":"2016-11-10T22:01:17.9517274Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page1984.json","@type":"CatalogPage","commitId":"fd27333e-95aa-4dd7-b999-bbbe1f625507","commitTimeStamp":"2016-11-11T09:42:03.1437369Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1985.json","@type":"CatalogPage","commitId":"90d18a78-ba74-4988-b276-98e4af6df91e","commitTimeStamp":"2016-11-11T18:11:57.8031879Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1986.json","@type":"CatalogPage","commitId":"babce24d-535b-4289-9db2-e014e5706f5f","commitTimeStamp":"2016-11-12T05:23:24.9812042Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1987.json","@type":"CatalogPage","commitId":"77fd4a50-177d-4857-a089-1d93148d3f2e","commitTimeStamp":"2016-11-12T23:40:37.670238Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1988.json","@type":"CatalogPage","commitId":"71f9d6ed-3399-4cd3-8e73-da0f24f65701","commitTimeStamp":"2016-11-13T21:09:32.9805705Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1989.json","@type":"CatalogPage","commitId":"a2f6f007-9c92-48c1-a82f-8e4fc811941a","commitTimeStamp":"2016-11-14T11:26:08.4908195Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1990.json","@type":"CatalogPage","commitId":"f4ec6dc1-ef54-4e90-bc77-b83bcd496ae3","commitTimeStamp":"2016-11-14T21:56:20.5932048Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1991.json","@type":"CatalogPage","commitId":"014de31c-fc7c-4359-b81a-5fe8daade19c","commitTimeStamp":"2016-11-15T10:10:57.1979489Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1992.json","@type":"CatalogPage","commitId":"d71f69da-ba80-4b3a-9e43-c03ee33d93f0","commitTimeStamp":"2016-11-15T18:21:17.3018488Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page1993.json","@type":"CatalogPage","commitId":"3088ba5c-d43a-4c4d-9e70-68a4aa46c8b6","commitTimeStamp":"2016-11-15T23:35:35.2988913Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1994.json","@type":"CatalogPage","commitId":"d757f295-abe3-4ef0-9e69-56254f907dab","commitTimeStamp":"2016-11-16T03:50:07.4505881Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page1995.json","@type":"CatalogPage","commitId":"6090a2d9-99e6-49bc-8aad-343de591d5ab","commitTimeStamp":"2016-11-16T11:32:38.3432421Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1996.json","@type":"CatalogPage","commitId":"a4e559d9-26d4-4f8e-9261-fd9a23e5de7b","commitTimeStamp":"2016-11-16T18:14:48.1862278Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1997.json","@type":"CatalogPage","commitId":"773a893d-2fdf-4080-b133-32b06ea9c81f","commitTimeStamp":"2016-11-16T22:48:38.4620748Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1998.json","@type":"CatalogPage","commitId":"916a3dcb-5014-4564-bd2f-2d0a28b02c15","commitTimeStamp":"2016-11-17T06:53:07.7877697Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page1999.json","@type":"CatalogPage","commitId":"83aa09f4-9ca3-42db-9326-7da120f0b7ca","commitTimeStamp":"2016-11-17T14:27:12.4050545Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2000.json","@type":"CatalogPage","commitId":"07a6d672-aeb8-43a8-a554-f8d330fa3f44","commitTimeStamp":"2016-11-17T19:21:18.4623941Z","count":536},{"@id":"https://api.nuget.org/v3/catalog0/page2001.json","@type":"CatalogPage","commitId":"4ef04d0a-e9ef-4af7-9021-d305134fe4ea","commitTimeStamp":"2016-11-18T03:19:18.4385884Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2002.json","@type":"CatalogPage","commitId":"b7922980-f400-47d9-b3e8-43a362b4e11c","commitTimeStamp":"2016-11-18T13:10:12.4968949Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2003.json","@type":"CatalogPage","commitId":"56270959-7d47-4e3a-b203-35cb0c67c028","commitTimeStamp":"2016-11-18T19:46:18.8847925Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2004.json","@type":"CatalogPage","commitId":"9e918e74-563c-4183-8705-5f2372a4d1b1","commitTimeStamp":"2016-11-18T21:09:14.7142855Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2005.json","@type":"CatalogPage","commitId":"a925bc4e-5622-4c16-ad2a-6acae60af9e3","commitTimeStamp":"2016-11-19T13:22:28.0833891Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2006.json","@type":"CatalogPage","commitId":"930294d3-a992-49e8-b51a-c8f6c2e29425","commitTimeStamp":"2016-11-20T09:14:22.6644997Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2007.json","@type":"CatalogPage","commitId":"c2e37fd7-8636-462e-80e5-2bc38b7f05c0","commitTimeStamp":"2016-11-21T05:17:56.5115088Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2008.json","@type":"CatalogPage","commitId":"a372e8e5-4128-4460-8a30-96fb1a9d2be7","commitTimeStamp":"2016-11-21T09:58:06.7218924Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2009.json","@type":"CatalogPage","commitId":"f647e6e4-9b61-462a-ac8a-40dbee8e5fea","commitTimeStamp":"2016-11-21T15:21:28.0343053Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2010.json","@type":"CatalogPage","commitId":"4b97dde4-fc23-4477-a346-8b5cff14ca15","commitTimeStamp":"2016-11-21T21:28:27.0720383Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2011.json","@type":"CatalogPage","commitId":"558c27f0-24c2-4ffe-8cac-c2ac80d5c2c9","commitTimeStamp":"2016-11-22T01:16:17.9025289Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2012.json","@type":"CatalogPage","commitId":"12b52697-9ce6-4a88-bb44-85fb82800b3e","commitTimeStamp":"2016-11-22T11:40:19.4200436Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2013.json","@type":"CatalogPage","commitId":"e74755c9-ba34-484f-9d1b-c9224e461346","commitTimeStamp":"2016-11-22T18:36:13.9705018Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2014.json","@type":"CatalogPage","commitId":"f8cfd8b1-ae32-48d4-82aa-82a38fdba672","commitTimeStamp":"2016-11-23T05:08:35.6850346Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2015.json","@type":"CatalogPage","commitId":"6a8ed392-28cb-44b4-80eb-6c2378ebdef2","commitTimeStamp":"2016-11-23T13:28:03.6665459Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2016.json","@type":"CatalogPage","commitId":"5a4f64c3-ed20-4f35-b184-79d42a861512","commitTimeStamp":"2016-11-23T22:14:51.8236276Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2017.json","@type":"CatalogPage","commitId":"b12d3caa-4fa8-46a7-82ee-4359553aea02","commitTimeStamp":"2016-11-24T10:12:25.9393916Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2018.json","@type":"CatalogPage","commitId":"ecd8229e-621a-4e0a-b4e4-087d0b345a66","commitTimeStamp":"2016-11-24T17:33:43.7508662Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2019.json","@type":"CatalogPage","commitId":"5c3392fa-52d8-4504-a0b2-73040d7eb1ab","commitTimeStamp":"2016-11-25T09:04:32.0461901Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2020.json","@type":"CatalogPage","commitId":"e5ba96b8-e363-48fb-9805-feaeffd06f90","commitTimeStamp":"2016-11-25T15:05:38.0600803Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2021.json","@type":"CatalogPage","commitId":"473d8bb1-224c-44da-89e3-7c619d2f1554","commitTimeStamp":"2016-11-26T16:36:15.3250759Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2022.json","@type":"CatalogPage","commitId":"d21d8ef8-b685-4450-aa22-b440238e0e0e","commitTimeStamp":"2016-11-27T17:26:59.2526048Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2023.json","@type":"CatalogPage","commitId":"c422152d-ab93-447c-bd9e-55163370ea47","commitTimeStamp":"2016-11-28T09:43:17.677544Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2024.json","@type":"CatalogPage","commitId":"8519a291-666e-4cdf-87bb-5cfde72afe66","commitTimeStamp":"2016-11-28T20:13:26.2102115Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2025.json","@type":"CatalogPage","commitId":"45f7c7be-c84e-4373-91df-35058482b125","commitTimeStamp":"2016-11-29T09:41:20.2166023Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2026.json","@type":"CatalogPage","commitId":"f058bb98-ff37-4d80-89ba-984649cb76f4","commitTimeStamp":"2016-11-29T17:39:27.1428373Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2027.json","@type":"CatalogPage","commitId":"33ea7743-efc9-4595-90a4-bd4ae3ff7973","commitTimeStamp":"2016-11-30T01:51:16.4248937Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2028.json","@type":"CatalogPage","commitId":"bf41bd8a-7296-4767-afe1-c6e01d560689","commitTimeStamp":"2016-11-30T09:39:50.6390912Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2029.json","@type":"CatalogPage","commitId":"49b3040d-14f9-4775-af2f-4c259c004cc0","commitTimeStamp":"2016-11-30T18:10:24.0780735Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2030.json","@type":"CatalogPage","commitId":"97365930-8d64-417c-a528-d8046e3f3a78","commitTimeStamp":"2016-12-01T05:54:40.7568164Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2031.json","@type":"CatalogPage","commitId":"510f4f35-f7b0-4232-8774-00f190651fad","commitTimeStamp":"2016-12-01T17:21:33.3629633Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2032.json","@type":"CatalogPage","commitId":"ca98f799-ecc6-4d60-b116-00fb12455a70","commitTimeStamp":"2016-12-02T01:44:38.7278365Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2033.json","@type":"CatalogPage","commitId":"247badb2-f6bd-44f8-bb46-1595b933a838","commitTimeStamp":"2016-12-02T15:35:22.5584731Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2034.json","@type":"CatalogPage","commitId":"92c755fc-2993-4491-a50c-fb99044dc8a1","commitTimeStamp":"2016-12-03T08:52:05.9964698Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2035.json","@type":"CatalogPage","commitId":"f1b28aac-d435-45b4-9857-cba78a170b46","commitTimeStamp":"2016-12-03T18:14:05.9900222Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page2036.json","@type":"CatalogPage","commitId":"ec266521-c461-418d-84a0-b5aa520f48b0","commitTimeStamp":"2016-12-04T12:27:47.1969237Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2037.json","@type":"CatalogPage","commitId":"9aea334d-d78a-4066-b6c2-519782f6aa05","commitTimeStamp":"2016-12-05T05:01:35.1300141Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2038.json","@type":"CatalogPage","commitId":"e24729d5-5263-483e-97be-52d542416ae7","commitTimeStamp":"2016-12-05T13:58:57.5767415Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2039.json","@type":"CatalogPage","commitId":"7ec040c5-a3a9-4463-a548-48202c06db03","commitTimeStamp":"2016-12-05T19:42:29.1108607Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2040.json","@type":"CatalogPage","commitId":"0f2477ca-f6d7-468b-a4b3-7a49c21ffbe6","commitTimeStamp":"2016-12-06T08:15:46.5902668Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2041.json","@type":"CatalogPage","commitId":"cdd714b6-40a0-4d47-8e8c-702c264388c2","commitTimeStamp":"2016-12-06T15:21:14.0655859Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2042.json","@type":"CatalogPage","commitId":"49ed7bdd-5898-4255-a43f-cf91f0087f25","commitTimeStamp":"2016-12-06T22:20:25.2882598Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2043.json","@type":"CatalogPage","commitId":"c0829d94-e4c0-4984-a704-424780cef39d","commitTimeStamp":"2016-12-07T10:11:39.3520579Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2044.json","@type":"CatalogPage","commitId":"57d883cf-ec7d-4b5b-aa08-34672629b4db","commitTimeStamp":"2016-12-07T16:25:53.5007375Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2045.json","@type":"CatalogPage","commitId":"07879985-ff39-47bf-9b53-c624edd3b1c9","commitTimeStamp":"2016-12-08T01:14:52.6198985Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2046.json","@type":"CatalogPage","commitId":"3f15e902-1559-499a-b1c7-f004a2d6d552","commitTimeStamp":"2016-12-08T12:08:35.7744758Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2047.json","@type":"CatalogPage","commitId":"97f935b2-6bf9-4666-b6ed-474012843440","commitTimeStamp":"2016-12-08T18:12:53.7456284Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2048.json","@type":"CatalogPage","commitId":"f6c2b8d7-d74e-424d-b79c-dde54a404d79","commitTimeStamp":"2016-12-09T03:04:01.7276674Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2049.json","@type":"CatalogPage","commitId":"734cb76d-687b-40cd-bf54-7e3733f22c08","commitTimeStamp":"2016-12-09T09:54:41.1721434Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2050.json","@type":"CatalogPage","commitId":"a2cf40d4-75b9-48d7-82fe-7abd7b203b04","commitTimeStamp":"2016-12-09T18:30:52.3783627Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2051.json","@type":"CatalogPage","commitId":"906db260-0d3d-4bef-8768-8cf65f1004c0","commitTimeStamp":"2016-12-10T12:51:57.5656591Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2052.json","@type":"CatalogPage","commitId":"c015e2b4-5d13-460c-b603-a4e0650d3a55","commitTimeStamp":"2016-12-11T15:08:46.6715477Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2053.json","@type":"CatalogPage","commitId":"188073d5-5c7e-4a23-af53-36350f7aa65c","commitTimeStamp":"2016-12-12T09:04:35.9759946Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2054.json","@type":"CatalogPage","commitId":"e37ef699-ef0c-4646-b6cc-1e5cd0dcadf9","commitTimeStamp":"2016-12-12T17:24:22.0372864Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2055.json","@type":"CatalogPage","commitId":"c1305344-e3d3-47b7-8de5-88f9b42c5137","commitTimeStamp":"2016-12-13T00:30:17.6143552Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2056.json","@type":"CatalogPage","commitId":"a4cdfaf9-acf4-417f-adf9-79e64fcb0107","commitTimeStamp":"2016-12-13T11:11:21.7126577Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2057.json","@type":"CatalogPage","commitId":"c90dca89-8d00-45c8-ae0f-4e118f6efd9c","commitTimeStamp":"2016-12-13T18:58:25.1488288Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2058.json","@type":"CatalogPage","commitId":"2731a137-4a25-477e-9d0e-eee63feff28e","commitTimeStamp":"2016-12-13T22:12:08.8185793Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2059.json","@type":"CatalogPage","commitId":"c185f313-1f54-4743-9d81-b68fca3b59ca","commitTimeStamp":"2016-12-13T22:57:59.9338414Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2060.json","@type":"CatalogPage","commitId":"1ff83a30-2e17-44c3-a63a-00f6de247ca0","commitTimeStamp":"2016-12-14T02:14:36.6016561Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2061.json","@type":"CatalogPage","commitId":"9e38a93f-d76a-47aa-a829-27aaed5f54ac","commitTimeStamp":"2016-12-14T04:21:11.0184698Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2062.json","@type":"CatalogPage","commitId":"968c6077-ea7c-4157-a1ea-c70e966599be","commitTimeStamp":"2016-12-14T06:27:46.5680539Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2063.json","@type":"CatalogPage","commitId":"11dbad48-458f-4ec6-9500-2622a0655cbd","commitTimeStamp":"2016-12-14T09:00:00.3332266Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2064.json","@type":"CatalogPage","commitId":"878ef43e-3821-4ff6-81f1-05fe237543ee","commitTimeStamp":"2016-12-14T17:01:59.2027153Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2065.json","@type":"CatalogPage","commitId":"d8fb6c85-d4af-41a0-9be7-1f5e201f25b1","commitTimeStamp":"2016-12-15T05:51:58.7964795Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2066.json","@type":"CatalogPage","commitId":"ebf4cbf7-92c4-492b-8a31-d034e87f62b2","commitTimeStamp":"2016-12-15T13:00:38.3609178Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2067.json","@type":"CatalogPage","commitId":"fc1fab96-d723-4053-96b5-88074a84f8e6","commitTimeStamp":"2016-12-15T18:42:10.8160975Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2068.json","@type":"CatalogPage","commitId":"e40eb11e-494b-49bf-9fc3-ca27625018b0","commitTimeStamp":"2016-12-16T06:31:51.0922651Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2069.json","@type":"CatalogPage","commitId":"9df73a7c-2f0c-4c42-a388-f62871aaf400","commitTimeStamp":"2016-12-16T15:22:09.7477871Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2070.json","@type":"CatalogPage","commitId":"5baa0676-f312-451a-a390-2756698567ee","commitTimeStamp":"2016-12-17T05:18:17.8432788Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2071.json","@type":"CatalogPage","commitId":"5323baee-17fb-46c3-b80a-ee4a318290ce","commitTimeStamp":"2016-12-18T03:42:49.6147618Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2072.json","@type":"CatalogPage","commitId":"8031186a-f0a7-47c6-b31c-8c062bc506c8","commitTimeStamp":"2016-12-19T02:06:10.5165166Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2073.json","@type":"CatalogPage","commitId":"02fb597d-e714-4c46-a71b-03138690eaa3","commitTimeStamp":"2016-12-19T14:24:14.815214Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2074.json","@type":"CatalogPage","commitId":"c775bed0-ebb4-49bd-a335-a06c5aedffff","commitTimeStamp":"2016-12-19T23:31:03.7769718Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2075.json","@type":"CatalogPage","commitId":"24785cc0-fcd5-4515-9bb2-5fab3421c909","commitTimeStamp":"2016-12-20T09:33:57.0982441Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2076.json","@type":"CatalogPage","commitId":"a842d451-a2ff-494b-a602-71b102e5538e","commitTimeStamp":"2016-12-20T17:21:57.9256922Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2077.json","@type":"CatalogPage","commitId":"c44061a0-33fd-47f8-98c8-1cbc332a4d5d","commitTimeStamp":"2016-12-21T07:39:56.8941033Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2078.json","@type":"CatalogPage","commitId":"cd64254e-bf8e-48a5-9b9a-c864e2b2b68b","commitTimeStamp":"2016-12-21T15:08:13.9903404Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2079.json","@type":"CatalogPage","commitId":"60444739-9c8d-4d5d-9581-f0623fb7d0e7","commitTimeStamp":"2016-12-21T22:50:12.2917588Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2080.json","@type":"CatalogPage","commitId":"643a3bf0-e4c2-4b89-84f0-908d5e807337","commitTimeStamp":"2016-12-22T08:50:44.4535827Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2081.json","@type":"CatalogPage","commitId":"faa337c2-5725-4c59-bca0-23870470abcf","commitTimeStamp":"2016-12-22T17:18:28.9057358Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2082.json","@type":"CatalogPage","commitId":"5b98dffb-6fd9-419d-9c73-d0fdd28697cb","commitTimeStamp":"2016-12-23T07:36:22.685103Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2083.json","@type":"CatalogPage","commitId":"de811c1b-f507-4bb9-b967-e92e50abf92f","commitTimeStamp":"2016-12-23T16:50:46.337037Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2084.json","@type":"CatalogPage","commitId":"b91998e8-145a-43cd-a313-be0e13aef8e4","commitTimeStamp":"2016-12-24T09:10:28.2223026Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2085.json","@type":"CatalogPage","commitId":"b0228a53-a63a-422e-aeed-b7397ec9e7b9","commitTimeStamp":"2016-12-25T15:54:13.2902695Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2086.json","@type":"CatalogPage","commitId":"abfe77f6-51a1-4699-a4e5-3942290c7e16","commitTimeStamp":"2016-12-26T17:57:49.4234659Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2087.json","@type":"CatalogPage","commitId":"1ee17716-c3ab-4ce8-8a3a-b1ded1a5bf81","commitTimeStamp":"2016-12-27T02:55:33.2628686Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2088.json","@type":"CatalogPage","commitId":"bd52c803-94af-41a9-b527-49f81404c331","commitTimeStamp":"2016-12-27T19:02:14.7414467Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2089.json","@type":"CatalogPage","commitId":"f1b0488e-e936-4b3b-8a34-3d59fd29d2f9","commitTimeStamp":"2016-12-28T10:41:11.0441123Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2090.json","@type":"CatalogPage","commitId":"95c0d2ea-45d9-48ae-b3ce-3d90a2c05925","commitTimeStamp":"2016-12-29T00:57:14.9739546Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2091.json","@type":"CatalogPage","commitId":"87e42ea3-1e04-4a47-bc18-7628bd89670d","commitTimeStamp":"2016-12-29T14:01:02.7959761Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2092.json","@type":"CatalogPage","commitId":"548ea363-8f86-4441-ad94-d5f0ee9a08a4","commitTimeStamp":"2016-12-30T04:28:09.7688529Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2093.json","@type":"CatalogPage","commitId":"e01cb0f3-91eb-461d-8bfe-5324a8453381","commitTimeStamp":"2016-12-30T17:16:29.2002956Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2094.json","@type":"CatalogPage","commitId":"2c549ec7-e750-400f-8d05-2ca73c70326b","commitTimeStamp":"2016-12-31T15:14:43.9491923Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2095.json","@type":"CatalogPage","commitId":"108a4e93-6bad-4c22-8849-62cd5826df8f","commitTimeStamp":"2017-01-02T08:14:25.2211131Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2096.json","@type":"CatalogPage","commitId":"156e4734-ca6f-42f7-bc5f-974e759f4242","commitTimeStamp":"2017-01-02T21:09:42.4368899Z","count":541},{"@id":"https://api.nuget.org/v3/catalog0/page2097.json","@type":"CatalogPage","commitId":"7369947d-dade-491e-8ea1-7f03e3b6f9c1","commitTimeStamp":"2017-01-03T10:40:47.6947081Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2098.json","@type":"CatalogPage","commitId":"390854d7-adad-40ba-b93e-5a6d2a29d83e","commitTimeStamp":"2017-01-03T19:41:00.0698634Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2099.json","@type":"CatalogPage","commitId":"aa35bc22-008e-41a3-b3e6-48ec30753cf8","commitTimeStamp":"2017-01-04T08:22:13.2520243Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2100.json","@type":"CatalogPage","commitId":"7b27c86f-0852-4d90-a25c-5360bd048777","commitTimeStamp":"2017-01-04T16:03:45.2300649Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2101.json","@type":"CatalogPage","commitId":"d43d0302-7436-4c58-8ab8-ba0f6cbec214","commitTimeStamp":"2017-01-05T01:55:49.194109Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2102.json","@type":"CatalogPage","commitId":"85a25311-830c-4ceb-8671-ca5bc31bfc2e","commitTimeStamp":"2017-01-05T13:46:18.2123548Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2103.json","@type":"CatalogPage","commitId":"bf958940-04c3-4f50-8971-288ad873c281","commitTimeStamp":"2017-01-05T20:52:19.4650453Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2104.json","@type":"CatalogPage","commitId":"2ef48518-1ade-4d81-a8af-e07609eff48f","commitTimeStamp":"2017-01-06T00:28:46.4294642Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2105.json","@type":"CatalogPage","commitId":"3042d206-c091-4bff-8088-33184f5f4eac","commitTimeStamp":"2017-01-06T08:48:21.3539932Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2106.json","@type":"CatalogPage","commitId":"9fcd35b3-7f3d-4706-af4e-3e952eb13bfe","commitTimeStamp":"2017-01-06T20:12:08.2940435Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2107.json","@type":"CatalogPage","commitId":"ab955f79-f29c-4e5d-96f5-2bc18d960ea7","commitTimeStamp":"2017-01-07T14:41:06.2829481Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2108.json","@type":"CatalogPage","commitId":"39e79b2f-ea65-441d-9954-5599b7cad23b","commitTimeStamp":"2017-01-08T12:34:04.2593058Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2109.json","@type":"CatalogPage","commitId":"96b4bca7-bdda-4a23-84ef-f178ffaca6b0","commitTimeStamp":"2017-01-08T23:34:27.7402575Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2110.json","@type":"CatalogPage","commitId":"1ef4cda2-ca63-4ee2-be10-70b2667f3750","commitTimeStamp":"2017-01-09T12:31:53.3300243Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2111.json","@type":"CatalogPage","commitId":"9e9da444-5667-46ef-b09f-2924e8b41e19","commitTimeStamp":"2017-01-09T21:00:12.290369Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2112.json","@type":"CatalogPage","commitId":"937136b1-ff9c-4cde-a439-58c0f7d5708f","commitTimeStamp":"2017-01-10T08:55:33.3218951Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2113.json","@type":"CatalogPage","commitId":"bbc88259-d6ae-496a-a022-e58eff29e631","commitTimeStamp":"2017-01-10T13:23:32.8904557Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2114.json","@type":"CatalogPage","commitId":"0d85cc06-a2a1-4fcb-9503-2b8eda3acc49","commitTimeStamp":"2017-01-10T22:30:10.0164216Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2115.json","@type":"CatalogPage","commitId":"374a4b80-7eca-4d58-961b-be76af7ff337","commitTimeStamp":"2017-01-11T09:59:12.5335039Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2116.json","@type":"CatalogPage","commitId":"1eaad6f0-e07b-41f8-9e75-801be151cdb0","commitTimeStamp":"2017-01-11T20:00:36.7028043Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2117.json","@type":"CatalogPage","commitId":"9f2ea6f6-5ca3-48c5-bf0e-68e461a7b8a7","commitTimeStamp":"2017-01-12T09:07:13.8096653Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2118.json","@type":"CatalogPage","commitId":"2372ae3f-bcf6-415f-a045-5a99a8ffe78f","commitTimeStamp":"2017-01-12T18:16:18.3284303Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2119.json","@type":"CatalogPage","commitId":"967ed0df-6450-4e48-a80a-e43f9f469b59","commitTimeStamp":"2017-01-13T10:00:18.0430217Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2120.json","@type":"CatalogPage","commitId":"9d49339f-c64c-40f7-aa10-fc37ec1080ce","commitTimeStamp":"2017-01-13T18:21:39.0755015Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2121.json","@type":"CatalogPage","commitId":"7373ff70-520d-452f-8785-ae630bbbe4b0","commitTimeStamp":"2017-01-14T12:51:49.7867115Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2122.json","@type":"CatalogPage","commitId":"eafcf474-b384-4917-8607-4640fb348ffd","commitTimeStamp":"2017-01-15T03:45:34.468375Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2123.json","@type":"CatalogPage","commitId":"d2e88d4f-1bf6-4f81-b1fb-be434bbb2290","commitTimeStamp":"2017-01-16T04:09:50.1034837Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2124.json","@type":"CatalogPage","commitId":"f701e626-5092-4688-a0e6-b4fafa64f358","commitTimeStamp":"2017-01-16T12:53:54.5867326Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2125.json","@type":"CatalogPage","commitId":"04ff96f6-97f1-4f8e-9b1e-78523259ee2a","commitTimeStamp":"2017-01-16T23:49:13.4098141Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2126.json","@type":"CatalogPage","commitId":"c23c7574-ec95-4f76-ab5b-c2e508995f03","commitTimeStamp":"2017-01-17T09:39:36.3151785Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2127.json","@type":"CatalogPage","commitId":"3bcbec17-cf0a-465b-806e-83be1510b6d1","commitTimeStamp":"2017-01-17T17:05:49.546719Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2128.json","@type":"CatalogPage","commitId":"a9001972-648b-4da0-8af0-a21a2ff14ed7","commitTimeStamp":"2017-01-18T07:06:57.2353509Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2129.json","@type":"CatalogPage","commitId":"5fdacd59-c7db-49d8-b004-3143f87b22e0","commitTimeStamp":"2017-01-18T14:26:07.6555894Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2130.json","@type":"CatalogPage","commitId":"d07fcd69-fd39-40c2-b21c-98c855922e7f","commitTimeStamp":"2017-01-19T00:20:09.4548049Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2131.json","@type":"CatalogPage","commitId":"f48cc6cf-c7f4-41da-96d0-13be692577cb","commitTimeStamp":"2017-01-19T09:53:30.7151052Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2132.json","@type":"CatalogPage","commitId":"cfdfabd5-58a5-447b-86ba-c875ed514f5b","commitTimeStamp":"2017-01-19T15:57:25.6651391Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2133.json","@type":"CatalogPage","commitId":"7e197386-6415-44ed-880e-dcb6ff7e2376","commitTimeStamp":"2017-01-20T06:24:21.9428786Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2134.json","@type":"CatalogPage","commitId":"f521ad1d-80f0-4141-a1b0-dd69cc0d4367","commitTimeStamp":"2017-01-20T13:08:37.9887427Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2135.json","@type":"CatalogPage","commitId":"9425ebb7-9314-48a2-989f-923f42384e30","commitTimeStamp":"2017-01-20T21:12:58.8727763Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2136.json","@type":"CatalogPage","commitId":"518eeca6-2a57-4d50-ae22-c52ec7189072","commitTimeStamp":"2017-01-21T06:45:02.6981408Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2137.json","@type":"CatalogPage","commitId":"eeb200b9-8554-4cdb-930b-2a7a5988b2b1","commitTimeStamp":"2017-01-22T01:17:34.6288037Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2138.json","@type":"CatalogPage","commitId":"a9f369d9-1e3e-4db0-815c-d12c308d9863","commitTimeStamp":"2017-01-22T21:17:59.2924504Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2139.json","@type":"CatalogPage","commitId":"fd070719-1702-4127-9392-bf0689bc8523","commitTimeStamp":"2017-01-23T11:37:53.3148278Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2140.json","@type":"CatalogPage","commitId":"b9ee6c57-781e-4763-9b7e-71a0d62612cd","commitTimeStamp":"2017-01-23T20:17:00.4977116Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2141.json","@type":"CatalogPage","commitId":"d61a66d6-5cd3-453d-bb81-11ea17d0cc2e","commitTimeStamp":"2017-01-24T09:10:36.4785324Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2142.json","@type":"CatalogPage","commitId":"73dd6af5-8d1e-480a-b117-a96db354fb70","commitTimeStamp":"2017-01-24T16:11:27.972989Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2143.json","@type":"CatalogPage","commitId":"fdd371ee-fcc4-431b-9219-cc69a1122077","commitTimeStamp":"2017-01-24T21:57:47.3399333Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2144.json","@type":"CatalogPage","commitId":"36c68f66-19a6-41c1-92ee-e644ae51e935","commitTimeStamp":"2017-01-25T09:11:26.3081412Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2145.json","@type":"CatalogPage","commitId":"e1ed4681-a63c-45d5-bf61-90f13905fa8d","commitTimeStamp":"2017-01-25T15:52:18.5377342Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2146.json","@type":"CatalogPage","commitId":"3c577e5c-a2ad-4e50-89ae-d280d5e0ef8c","commitTimeStamp":"2017-01-25T22:39:05.3179482Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page2147.json","@type":"CatalogPage","commitId":"4503e6c2-f4e6-40dc-8261-bb811471ef88","commitTimeStamp":"2017-01-26T08:13:44.5412768Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2148.json","@type":"CatalogPage","commitId":"6e0b3f94-e9d3-4303-9eae-d08730d9e4f7","commitTimeStamp":"2017-01-26T14:35:18.2211779Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2149.json","@type":"CatalogPage","commitId":"d74f229d-ec52-4416-9bc9-38ef1f8d1536","commitTimeStamp":"2017-01-26T21:12:17.0487805Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2150.json","@type":"CatalogPage","commitId":"39336b15-d4ef-4b43-9023-d84eb718a821","commitTimeStamp":"2017-01-27T06:59:25.8282718Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2151.json","@type":"CatalogPage","commitId":"1974a85d-d675-4441-baff-d69400242605","commitTimeStamp":"2017-01-27T16:15:37.5089256Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2152.json","@type":"CatalogPage","commitId":"cfdcff60-3b5a-474c-a66e-628ffc9fa285","commitTimeStamp":"2017-01-28T14:21:53.9582671Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2153.json","@type":"CatalogPage","commitId":"65465b55-ba15-4728-bb35-fc333250f944","commitTimeStamp":"2017-01-29T12:28:48.7000237Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2154.json","@type":"CatalogPage","commitId":"98d00b68-b20e-499c-a3af-742f8b1ebb59","commitTimeStamp":"2017-01-30T00:15:31.6087175Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2155.json","@type":"CatalogPage","commitId":"b9ad7f5c-6805-4cbc-9ef3-b9092bfed9b9","commitTimeStamp":"2017-01-30T11:22:24.6378082Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2156.json","@type":"CatalogPage","commitId":"63660eba-8a6d-4ffe-8eab-9d6cf4c7d3b2","commitTimeStamp":"2017-01-30T19:50:51.7459034Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2157.json","@type":"CatalogPage","commitId":"7798b466-24df-4461-927a-a75fb14547dc","commitTimeStamp":"2017-01-31T07:54:08.0252512Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2158.json","@type":"CatalogPage","commitId":"1f889991-1b10-4ce7-8a8e-53fbd24c52fb","commitTimeStamp":"2017-01-31T13:18:09.8219547Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2159.json","@type":"CatalogPage","commitId":"1871f092-8fe8-42b2-b5d0-d5ee49cc1aaf","commitTimeStamp":"2017-01-31T19:51:18.4451189Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2160.json","@type":"CatalogPage","commitId":"7d496c5b-66c7-4446-beab-a98f1856dec4","commitTimeStamp":"2017-02-01T05:04:32.7700789Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2161.json","@type":"CatalogPage","commitId":"c31ddcf2-fe19-4aa1-9d47-e8f33753f6f7","commitTimeStamp":"2017-02-01T12:24:14.2042622Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2162.json","@type":"CatalogPage","commitId":"a1909bf0-9e31-4a40-aa35-6afc2305620e","commitTimeStamp":"2017-02-01T19:32:30.3427705Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2163.json","@type":"CatalogPage","commitId":"d024543d-59a6-4802-ab1d-8f9a14be0a3d","commitTimeStamp":"2017-02-02T09:44:33.2617008Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2164.json","@type":"CatalogPage","commitId":"f2186232-1841-49dd-ad5b-f054ddfccdcc","commitTimeStamp":"2017-02-02T17:36:56.0553462Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2165.json","@type":"CatalogPage","commitId":"60ac4bd7-6bf0-452b-815a-5aa69161db1b","commitTimeStamp":"2017-02-03T03:51:13.3063732Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2166.json","@type":"CatalogPage","commitId":"1e1ca4fd-98be-4621-a6d2-0146f9ad7a03","commitTimeStamp":"2017-02-03T09:49:02.4795653Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2167.json","@type":"CatalogPage","commitId":"94f37e40-1c4a-4ca5-89d2-0f0e51931211","commitTimeStamp":"2017-02-03T16:14:56.5412853Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2168.json","@type":"CatalogPage","commitId":"f69693b9-8a26-49c1-9d8b-98e13088cfcd","commitTimeStamp":"2017-02-04T02:36:16.8850831Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2169.json","@type":"CatalogPage","commitId":"5e1e1518-3822-4084-b4aa-ff83c296fbce","commitTimeStamp":"2017-02-04T18:28:05.44389Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2170.json","@type":"CatalogPage","commitId":"16e29b89-f774-4c1f-9c81-45574af1ce69","commitTimeStamp":"2017-02-05T01:03:39.1510602Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page2171.json","@type":"CatalogPage","commitId":"d3639b47-160f-40ca-8c3b-9f9e80d4cbb4","commitTimeStamp":"2017-02-05T17:10:35.8880145Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2172.json","@type":"CatalogPage","commitId":"ab642d41-4073-4047-911e-22b063141fe0","commitTimeStamp":"2017-02-06T06:49:32.3565206Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2173.json","@type":"CatalogPage","commitId":"bb895116-3d74-43e7-b594-b90e517cedc1","commitTimeStamp":"2017-02-06T15:41:10.2661332Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2174.json","@type":"CatalogPage","commitId":"098e1815-6817-4ae0-abee-0db38228fe69","commitTimeStamp":"2017-02-07T02:45:18.8002824Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2175.json","@type":"CatalogPage","commitId":"f0e47958-b235-4abc-b198-2fc78e58418d","commitTimeStamp":"2017-02-07T15:07:58.7638851Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2176.json","@type":"CatalogPage","commitId":"e9726976-fb3f-4547-9191-68ff136a4ce0","commitTimeStamp":"2017-02-07T22:09:56.0534575Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2177.json","@type":"CatalogPage","commitId":"ee8e58dc-89f2-4404-8300-21c1435b32a4","commitTimeStamp":"2017-02-08T08:52:43.2858955Z","count":534},{"@id":"https://api.nuget.org/v3/catalog0/page2178.json","@type":"CatalogPage","commitId":"ce23d723-0b5b-4067-a1c0-ff6c4481f87d","commitTimeStamp":"2017-02-08T09:01:08.2471824Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page2179.json","@type":"CatalogPage","commitId":"8db31325-1a9a-4475-aebd-e9db9d941297","commitTimeStamp":"2017-02-08T09:07:42.744482Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page2180.json","@type":"CatalogPage","commitId":"a86b733a-49ac-49a2-9dea-89bb69d1bf05","commitTimeStamp":"2017-02-08T09:13:35.0788009Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page2181.json","@type":"CatalogPage","commitId":"e3793bde-5d50-4d1e-b2d9-a8419877f0a1","commitTimeStamp":"2017-02-08T09:19:36.5845692Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page2182.json","@type":"CatalogPage","commitId":"2639445a-bb3b-411c-806e-65bf224c22d1","commitTimeStamp":"2017-02-08T09:25:30.2445737Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page2183.json","@type":"CatalogPage","commitId":"0fbaf0c9-876f-4712-a788-2e1356f39836","commitTimeStamp":"2017-02-08T09:31:19.5124119Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page2184.json","@type":"CatalogPage","commitId":"3ac11a6f-6b60-4ff6-89e0-1412114032a6","commitTimeStamp":"2017-02-08T09:37:03.450381Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page2185.json","@type":"CatalogPage","commitId":"b85a1344-7585-4018-a228-4e45c0b64470","commitTimeStamp":"2017-02-08T09:42:43.4932559Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page2186.json","@type":"CatalogPage","commitId":"ef03bedc-29da-4487-a8d2-68c7203ee136","commitTimeStamp":"2017-02-08T09:48:26.5645034Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page2187.json","@type":"CatalogPage","commitId":"fa38143d-5708-4a52-ae0f-b0e256d47c7c","commitTimeStamp":"2017-02-08T09:54:06.906098Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page2188.json","@type":"CatalogPage","commitId":"440a630a-a2ce-467b-b16f-26fb6bf3f3cb","commitTimeStamp":"2017-02-08T09:59:58.7769026Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page2189.json","@type":"CatalogPage","commitId":"11c5677d-372b-458f-bc10-1b618b4e06e9","commitTimeStamp":"2017-02-08T10:05:52.7582151Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page2190.json","@type":"CatalogPage","commitId":"f7980e50-71b3-4416-9642-cfd4e180fde7","commitTimeStamp":"2017-02-08T10:11:32.7851576Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page2191.json","@type":"CatalogPage","commitId":"280de7a0-ac1f-4cad-b968-1ae0bcf3be03","commitTimeStamp":"2017-02-08T10:17:13.3461954Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page2192.json","@type":"CatalogPage","commitId":"026433d7-ad54-47b8-a156-9647e9c8eda9","commitTimeStamp":"2017-02-08T10:23:00.7709279Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page2193.json","@type":"CatalogPage","commitId":"90514bb8-0441-437e-a431-d91938d44417","commitTimeStamp":"2017-02-08T10:28:53.4425651Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page2194.json","@type":"CatalogPage","commitId":"9ecf4934-3403-4f67-8bf1-ac0caff8d3a3","commitTimeStamp":"2017-02-08T10:34:51.959105Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page2195.json","@type":"CatalogPage","commitId":"9cfd88e6-0312-48e1-a790-1b348c98421d","commitTimeStamp":"2017-02-08T10:40:43.1057197Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page2196.json","@type":"CatalogPage","commitId":"a6219783-58a0-44f7-85de-6c8e6a657319","commitTimeStamp":"2017-02-08T13:26:26.2121658Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2197.json","@type":"CatalogPage","commitId":"708f2aa5-052c-4144-9a38-11a821c4f02a","commitTimeStamp":"2017-02-08T20:28:20.4101601Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2198.json","@type":"CatalogPage","commitId":"22b9bf1a-9361-4c6a-bbac-9c80ccb944f9","commitTimeStamp":"2017-02-09T01:19:17.1167717Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2199.json","@type":"CatalogPage","commitId":"b2a528e7-f88a-42e4-8246-ef8308e99c51","commitTimeStamp":"2017-02-09T06:46:31.5430647Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2200.json","@type":"CatalogPage","commitId":"4e1e6849-35db-4a30-931f-5fe3413845f0","commitTimeStamp":"2017-02-09T10:32:26.0889433Z","count":533},{"@id":"https://api.nuget.org/v3/catalog0/page2201.json","@type":"CatalogPage","commitId":"63fa033c-4444-4018-a020-a7bf020fbf4f","commitTimeStamp":"2017-02-09T15:28:36.3728981Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2202.json","@type":"CatalogPage","commitId":"add1faae-b3b1-4db6-a6eb-c049cd70d707","commitTimeStamp":"2017-02-09T21:36:43.8491203Z","count":544},{"@id":"https://api.nuget.org/v3/catalog0/page2203.json","@type":"CatalogPage","commitId":"4fa020ad-552a-4eb5-adaa-7f7c4899b041","commitTimeStamp":"2017-02-10T09:06:47.7738365Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2204.json","@type":"CatalogPage","commitId":"42a90e5e-5f0e-4e1b-a5ca-c5c1a70fa3fc","commitTimeStamp":"2017-02-10T14:46:25.3077385Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2205.json","@type":"CatalogPage","commitId":"c48b2de8-7865-4cb0-8f8d-bcedb9f342ba","commitTimeStamp":"2017-02-10T21:03:29.0287026Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2206.json","@type":"CatalogPage","commitId":"64dd9e71-a70e-443d-9f1b-f5ea9b992e80","commitTimeStamp":"2017-02-11T15:04:50.5113045Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2207.json","@type":"CatalogPage","commitId":"fe6d8ab6-e0dc-44bc-907b-e22d48de1ed0","commitTimeStamp":"2017-02-12T08:19:01.4949908Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2208.json","@type":"CatalogPage","commitId":"c648ac52-ed67-4ace-97a3-02c27ccf1111","commitTimeStamp":"2017-02-13T02:52:52.4686936Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2209.json","@type":"CatalogPage","commitId":"5e5b3841-f2da-493e-af65-6ae7e72ba969","commitTimeStamp":"2017-02-13T11:24:38.157507Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2210.json","@type":"CatalogPage","commitId":"68caa5d4-ca50-49d4-88b1-ef7d14b6c2f6","commitTimeStamp":"2017-02-13T17:16:07.6933782Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2211.json","@type":"CatalogPage","commitId":"02d3f794-c3f1-4eab-81a0-6017cdfa4974","commitTimeStamp":"2017-02-14T05:06:46.7738846Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2212.json","@type":"CatalogPage","commitId":"32df8323-c572-4cdb-9ebf-7729083918f3","commitTimeStamp":"2017-02-14T14:04:17.5613997Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2213.json","@type":"CatalogPage","commitId":"1c148753-f906-430d-ba18-f85d3303f15d","commitTimeStamp":"2017-02-14T21:21:07.0505289Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2214.json","@type":"CatalogPage","commitId":"5f41e04d-8f5d-430e-962e-27e13df1e3f4","commitTimeStamp":"2017-02-15T05:08:33.4944037Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2215.json","@type":"CatalogPage","commitId":"e5d713a7-c9c3-4245-b754-7f6cf64f5abe","commitTimeStamp":"2017-02-15T14:47:09.8344026Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2216.json","@type":"CatalogPage","commitId":"d3443829-5abb-4b9d-bb70-f4dc1bbcfd77","commitTimeStamp":"2017-02-15T21:36:15.9015589Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2217.json","@type":"CatalogPage","commitId":"2c4f38a1-4d5b-4e16-a7d8-44fa16c939df","commitTimeStamp":"2017-02-16T12:20:43.8877991Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2218.json","@type":"CatalogPage","commitId":"ccf4bbb9-9c8c-4cd7-8557-46806204b21a","commitTimeStamp":"2017-02-16T20:19:19.8834276Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2219.json","@type":"CatalogPage","commitId":"b97b1c4c-f3a0-4ec8-b887-750ed8eaf1f7","commitTimeStamp":"2017-02-17T07:08:31.1704954Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2220.json","@type":"CatalogPage","commitId":"d53a0062-0cac-4744-bc16-ba45b264c94e","commitTimeStamp":"2017-02-17T12:56:44.454978Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2221.json","@type":"CatalogPage","commitId":"3580cecb-f27b-4abd-914a-d61c43e305e0","commitTimeStamp":"2017-02-17T21:02:31.2908854Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2222.json","@type":"CatalogPage","commitId":"31d265b1-5a3e-4001-9542-48e8a1359215","commitTimeStamp":"2017-02-18T09:23:04.8603042Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2223.json","@type":"CatalogPage","commitId":"f5bf942e-39c3-4701-9868-837f1ae891b1","commitTimeStamp":"2017-02-19T00:39:59.5381207Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2224.json","@type":"CatalogPage","commitId":"bbfd8c80-107e-42e8-9345-bf6bf5776496","commitTimeStamp":"2017-02-19T16:38:11.3427935Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2225.json","@type":"CatalogPage","commitId":"3e1001b6-fd80-4e4e-8001-8fa32c741812","commitTimeStamp":"2017-02-20T09:01:39.2058144Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2226.json","@type":"CatalogPage","commitId":"17065895-7a2c-4638-8417-47aa760e28b7","commitTimeStamp":"2017-02-20T14:47:55.0034111Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2227.json","@type":"CatalogPage","commitId":"f399cf08-f47e-4498-bc44-81a7a33c7a74","commitTimeStamp":"2017-02-20T20:56:59.5759906Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2228.json","@type":"CatalogPage","commitId":"3c894ca0-ac03-4592-b224-3e47af525291","commitTimeStamp":"2017-02-21T08:45:43.4614961Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2229.json","@type":"CatalogPage","commitId":"0800e5d1-22fc-4511-a0b4-7503d6e0d234","commitTimeStamp":"2017-02-21T18:23:05.2108537Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2230.json","@type":"CatalogPage","commitId":"203e9edb-eaad-4015-af3c-7f36918a62ae","commitTimeStamp":"2017-02-22T03:11:07.2832144Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2231.json","@type":"CatalogPage","commitId":"162cc900-7b4e-4dc4-85b6-f4bcbe1109a0","commitTimeStamp":"2017-02-22T10:58:30.0774917Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2232.json","@type":"CatalogPage","commitId":"ce7c7391-befd-4190-95fd-75a43a11afa9","commitTimeStamp":"2017-02-22T17:58:03.5608873Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2233.json","@type":"CatalogPage","commitId":"66792876-7508-4023-9418-a0705614524b","commitTimeStamp":"2017-02-23T10:29:47.2755766Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2234.json","@type":"CatalogPage","commitId":"a9951299-b4b1-441b-be88-011fd8f645e9","commitTimeStamp":"2017-02-23T18:45:22.0401615Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2235.json","@type":"CatalogPage","commitId":"a8ed0874-564e-4632-ba5d-ee5ce200ebc9","commitTimeStamp":"2017-02-24T05:17:43.9429528Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2236.json","@type":"CatalogPage","commitId":"43a6c9bc-7668-4a15-b291-8aaf2b0d4708","commitTimeStamp":"2017-02-24T14:24:20.9848315Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2237.json","@type":"CatalogPage","commitId":"7daed8de-c2b8-488b-ae49-ae6b947bacee","commitTimeStamp":"2017-02-24T23:16:36.8736541Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2238.json","@type":"CatalogPage","commitId":"ca6fe2d4-006e-48a3-a4a8-d26d384fbfb8","commitTimeStamp":"2017-02-25T11:34:09.6330278Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2239.json","@type":"CatalogPage","commitId":"50487e0b-7204-493e-b39e-8b28846e8689","commitTimeStamp":"2017-02-25T17:53:40.248531Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2240.json","@type":"CatalogPage","commitId":"82a9c581-8f9c-408d-a578-25b41f03c4e5","commitTimeStamp":"2017-02-26T08:00:24.3208611Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2241.json","@type":"CatalogPage","commitId":"638b5480-90b8-4a78-8093-224104e796ae","commitTimeStamp":"2017-02-26T21:28:18.4391328Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2242.json","@type":"CatalogPage","commitId":"38ba8177-b739-4c0b-81f0-e6efd9ba8adb","commitTimeStamp":"2017-02-27T09:24:03.3705648Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2243.json","@type":"CatalogPage","commitId":"a2546e02-758a-4fd3-b94d-e40f3cadddb3","commitTimeStamp":"2017-02-27T16:04:35.091998Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2244.json","@type":"CatalogPage","commitId":"2c71ed51-b7a8-40c0-a67e-51faebf194b3","commitTimeStamp":"2017-02-27T21:51:33.5626434Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2245.json","@type":"CatalogPage","commitId":"ad87e854-a3c7-496a-97a6-30e4a675c538","commitTimeStamp":"2017-02-28T05:56:27.2906859Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2246.json","@type":"CatalogPage","commitId":"29850d3d-76b7-4736-8807-23e9536dfe91","commitTimeStamp":"2017-02-28T11:20:43.4555509Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2247.json","@type":"CatalogPage","commitId":"4222a48f-e24d-487e-81bc-e9cd5f4e3d97","commitTimeStamp":"2017-02-28T16:10:32.9744894Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page2248.json","@type":"CatalogPage","commitId":"36a22550-4e06-4ad1-bd3a-13aefe7b30a2","commitTimeStamp":"2017-03-01T03:46:23.3640741Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2249.json","@type":"CatalogPage","commitId":"6dc42c55-21b9-4a1d-88c3-aebacb1ea01b","commitTimeStamp":"2017-03-01T13:38:17.2130488Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2250.json","@type":"CatalogPage","commitId":"27b3e604-05c5-4468-9319-782777504176","commitTimeStamp":"2017-03-01T22:47:47.4618639Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2251.json","@type":"CatalogPage","commitId":"0f5740d6-22df-4185-b096-0e22f391236b","commitTimeStamp":"2017-03-02T10:05:46.4219645Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2252.json","@type":"CatalogPage","commitId":"0a5d2aca-ce6d-442c-99b7-bc122d2e509c","commitTimeStamp":"2017-03-02T17:57:02.589806Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2253.json","@type":"CatalogPage","commitId":"def87b27-1f47-4ed1-b218-44667f3ce20a","commitTimeStamp":"2017-03-03T06:40:48.0039801Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2254.json","@type":"CatalogPage","commitId":"6cc40ae3-c96c-484b-ac40-46cb6564dc30","commitTimeStamp":"2017-03-03T15:28:54.086141Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2255.json","@type":"CatalogPage","commitId":"924a6857-3832-41db-84b4-bc85b7ebb989","commitTimeStamp":"2017-03-04T03:16:32.509248Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2256.json","@type":"CatalogPage","commitId":"6e7f969c-bf5b-4586-8193-b639f15b871f","commitTimeStamp":"2017-03-05T03:42:16.0118597Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2257.json","@type":"CatalogPage","commitId":"44361eb4-87c0-428f-b161-5cc51970e9f0","commitTimeStamp":"2017-03-06T02:50:41.7886671Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2258.json","@type":"CatalogPage","commitId":"6466f414-8910-4137-9b51-225079b33a69","commitTimeStamp":"2017-03-06T13:05:25.7258754Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2259.json","@type":"CatalogPage","commitId":"6f54fd49-0e08-487d-8c61-6bfeae3a2c8c","commitTimeStamp":"2017-03-06T18:37:42.7710106Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2260.json","@type":"CatalogPage","commitId":"a7a1c3a1-13f9-4adf-ab69-c41a6be54540","commitTimeStamp":"2017-03-07T00:54:34.2982562Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2261.json","@type":"CatalogPage","commitId":"e9f1ca6d-a0cf-4c65-9c46-f3f32419726c","commitTimeStamp":"2017-03-07T10:47:51.6067887Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2262.json","@type":"CatalogPage","commitId":"72001ee0-79ef-440f-b2be-9b335225329b","commitTimeStamp":"2017-03-07T21:05:03.1049833Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2263.json","@type":"CatalogPage","commitId":"9f20bbf5-e40f-45db-b3a2-6db7a9d8e040","commitTimeStamp":"2017-03-08T05:04:58.406806Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2264.json","@type":"CatalogPage","commitId":"f22908e8-380b-4256-a93e-0c7567f3dc96","commitTimeStamp":"2017-03-08T10:58:03.7355908Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2265.json","@type":"CatalogPage","commitId":"58e80a03-567d-47f8-97f3-60ce9b333ad3","commitTimeStamp":"2017-03-08T17:05:36.9776857Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2266.json","@type":"CatalogPage","commitId":"ef9ef97b-b45e-488c-92ec-d39d6ba4bf29","commitTimeStamp":"2017-03-09T03:48:21.8775916Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2267.json","@type":"CatalogPage","commitId":"47546770-6860-496d-8cfd-49d8f6d1b27b","commitTimeStamp":"2017-03-09T14:10:41.9774925Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2268.json","@type":"CatalogPage","commitId":"09e5cdb6-577b-4bea-a543-49fc02f80f92","commitTimeStamp":"2017-03-09T20:15:11.7943165Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2269.json","@type":"CatalogPage","commitId":"90f53253-2bc1-41d7-8510-d4493c7e67b4","commitTimeStamp":"2017-03-10T06:03:02.6867625Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2270.json","@type":"CatalogPage","commitId":"ef66f787-13f7-4b81-b7fe-ed0e33c913b2","commitTimeStamp":"2017-03-10T13:17:25.6937292Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2271.json","@type":"CatalogPage","commitId":"b5bbae09-152d-49ea-b565-10ed03366501","commitTimeStamp":"2017-03-10T23:27:49.8813943Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2272.json","@type":"CatalogPage","commitId":"04421686-1e94-495c-afca-11b84e54a1e2","commitTimeStamp":"2017-03-11T09:30:08.7836353Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2273.json","@type":"CatalogPage","commitId":"0605af88-b102-46ae-b34f-5b1093786006","commitTimeStamp":"2017-03-11T19:38:37.9667447Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2274.json","@type":"CatalogPage","commitId":"e3e9d1a2-3b98-487e-9857-49087d6685df","commitTimeStamp":"2017-03-12T14:23:16.1085697Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2275.json","@type":"CatalogPage","commitId":"c962e78c-34cf-4406-a54d-aecedf24a555","commitTimeStamp":"2017-03-13T03:27:22.1290864Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2276.json","@type":"CatalogPage","commitId":"862ee81f-d294-4d60-9eb8-5f112ba2e913","commitTimeStamp":"2017-03-13T12:36:42.6952955Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2277.json","@type":"CatalogPage","commitId":"a95ab90a-7bce-477d-b290-fa2c90e2b088","commitTimeStamp":"2017-03-13T18:20:18.8472842Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2278.json","@type":"CatalogPage","commitId":"4200baea-46af-4a8e-a3d9-df20f3a5b040","commitTimeStamp":"2017-03-14T06:57:30.7874434Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2279.json","@type":"CatalogPage","commitId":"6c08535b-bbdd-4b42-bc67-455fbef3ff10","commitTimeStamp":"2017-03-14T14:00:26.4105054Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2280.json","@type":"CatalogPage","commitId":"40ef4c8e-5067-4329-ab8e-ff537479cf59","commitTimeStamp":"2017-03-14T21:35:48.4324389Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2281.json","@type":"CatalogPage","commitId":"571c8a65-4895-4c4f-9bb9-2ff2f9b1018c","commitTimeStamp":"2017-03-15T07:23:36.3532472Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2282.json","@type":"CatalogPage","commitId":"ebb5d3e0-a951-42b4-81db-0cc8a36af35f","commitTimeStamp":"2017-03-15T13:48:47.0416959Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2283.json","@type":"CatalogPage","commitId":"dd3aa402-d764-484d-9c4f-1f1e1e20e229","commitTimeStamp":"2017-03-15T21:15:33.2322876Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2284.json","@type":"CatalogPage","commitId":"7d3f0798-8768-431a-90aa-3d8ec3855174","commitTimeStamp":"2017-03-16T08:47:51.0102259Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2285.json","@type":"CatalogPage","commitId":"5a7ce234-7a62-4ec2-80d8-be75dbeafa62","commitTimeStamp":"2017-03-16T17:11:20.0557742Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2286.json","@type":"CatalogPage","commitId":"c3d1b1ea-367b-486a-869d-4836c4c9cdb6","commitTimeStamp":"2017-03-17T01:17:15.9435625Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2287.json","@type":"CatalogPage","commitId":"39e57e02-a24a-4dff-a58e-5e1dcc97bc8e","commitTimeStamp":"2017-03-17T12:29:04.5948886Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2288.json","@type":"CatalogPage","commitId":"057236ec-103b-4e85-8240-11c9d34ac671","commitTimeStamp":"2017-03-17T22:05:13.8730182Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2289.json","@type":"CatalogPage","commitId":"fe719e51-8208-4d4d-b22f-e8d249cfc3ac","commitTimeStamp":"2017-03-18T16:28:15.9115988Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2290.json","@type":"CatalogPage","commitId":"6108cfda-655c-4d30-a413-1883a0699b8d","commitTimeStamp":"2017-03-19T10:32:58.2878206Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2291.json","@type":"CatalogPage","commitId":"bba5c485-bc40-449f-8578-25b66fef9b17","commitTimeStamp":"2017-03-19T20:43:03.3122351Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2292.json","@type":"CatalogPage","commitId":"5729070c-3dc6-4f94-ab96-457a74877c65","commitTimeStamp":"2017-03-20T08:32:12.2681815Z","count":543},{"@id":"https://api.nuget.org/v3/catalog0/page2293.json","@type":"CatalogPage","commitId":"f5e725ec-413a-4ec6-968c-213e6a7fa45b","commitTimeStamp":"2017-03-20T17:00:07.4043773Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page2294.json","@type":"CatalogPage","commitId":"2e55962f-e418-4e07-b6d7-87e04d540a7e","commitTimeStamp":"2017-03-20T22:55:37.9958072Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2295.json","@type":"CatalogPage","commitId":"a71feba0-0b8c-4780-98ef-b6e842dcd1da","commitTimeStamp":"2017-03-21T09:46:32.5693489Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2296.json","@type":"CatalogPage","commitId":"32f147c7-8950-4f98-811d-ef03d07af5fd","commitTimeStamp":"2017-03-21T17:10:07.2550987Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2297.json","@type":"CatalogPage","commitId":"4f574df4-a6c3-44d0-88a2-88544fd05c32","commitTimeStamp":"2017-03-22T00:01:30.9619056Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2298.json","@type":"CatalogPage","commitId":"222a53f8-0d9f-4722-8ee6-44cb15907e49","commitTimeStamp":"2017-03-22T11:49:24.4213264Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page2299.json","@type":"CatalogPage","commitId":"eba42908-1091-472c-8bcf-a6e7be6c2a96","commitTimeStamp":"2017-03-22T18:26:33.6039909Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2300.json","@type":"CatalogPage","commitId":"48e4c915-8dd4-4a36-880a-8b9250e9500e","commitTimeStamp":"2017-03-23T06:52:26.7234859Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2301.json","@type":"CatalogPage","commitId":"c0c5f92c-6ac4-4ced-a94f-d8789ac53e82","commitTimeStamp":"2017-03-23T14:53:30.2327961Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2302.json","@type":"CatalogPage","commitId":"404bd280-afa7-4039-a49f-19d03ba4d1c4","commitTimeStamp":"2017-03-23T21:19:59.0228989Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2303.json","@type":"CatalogPage","commitId":"44de76c0-06e6-4c02-bb5d-176b7cc89df3","commitTimeStamp":"2017-03-24T08:30:21.9605827Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2304.json","@type":"CatalogPage","commitId":"8e2a2ac7-2e0c-4d4f-8f94-f169c4c587de","commitTimeStamp":"2017-03-24T17:19:16.4162346Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2305.json","@type":"CatalogPage","commitId":"f8f73fa5-288d-49a7-a35f-41dd4c601747","commitTimeStamp":"2017-03-25T04:39:00.0034767Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2306.json","@type":"CatalogPage","commitId":"df6f045f-da7e-4426-95da-9f364090a457","commitTimeStamp":"2017-03-25T19:57:38.5130359Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2307.json","@type":"CatalogPage","commitId":"ab5b1490-6997-48a6-b7d1-4f541dcd79bd","commitTimeStamp":"2017-03-26T15:23:25.1742247Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2308.json","@type":"CatalogPage","commitId":"28853cc6-92de-4ca8-8e06-231f9acafa89","commitTimeStamp":"2017-03-27T05:22:51.0722686Z","count":542},{"@id":"https://api.nuget.org/v3/catalog0/page2309.json","@type":"CatalogPage","commitId":"d325bef0-bc20-421a-8e86-91e343494e95","commitTimeStamp":"2017-03-27T13:54:37.6708141Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2310.json","@type":"CatalogPage","commitId":"cd458508-095c-4dc4-84c3-b4a05b8b4661","commitTimeStamp":"2017-03-27T19:56:53.9762637Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2311.json","@type":"CatalogPage","commitId":"2b19076f-2bb3-4366-9c98-74ec0658c28e","commitTimeStamp":"2017-03-28T06:01:45.917868Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2312.json","@type":"CatalogPage","commitId":"204fc820-b27a-4b54-8732-6257b59d7d11","commitTimeStamp":"2017-03-28T09:32:17.6895626Z","count":543},{"@id":"https://api.nuget.org/v3/catalog0/page2313.json","@type":"CatalogPage","commitId":"9f2bb966-6ae0-420e-8f52-5d01e258e586","commitTimeStamp":"2017-03-28T15:03:28.6580003Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2314.json","@type":"CatalogPage","commitId":"4b3987ff-9834-4232-885b-a7c32d2f839e","commitTimeStamp":"2017-03-28T19:43:35.8264162Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2315.json","@type":"CatalogPage","commitId":"ef2852f5-7b1e-45eb-9194-fc87ca4952ec","commitTimeStamp":"2017-03-29T07:31:36.5432645Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2316.json","@type":"CatalogPage","commitId":"eec39434-5ad2-4866-b52c-69d97e9c271d","commitTimeStamp":"2017-03-29T14:16:58.9587318Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2317.json","@type":"CatalogPage","commitId":"ee46fc10-00fd-4875-a78c-5393b773294a","commitTimeStamp":"2017-03-29T20:04:59.5924638Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2318.json","@type":"CatalogPage","commitId":"41ab87ee-1770-44a7-8946-220e4a2f9e0f","commitTimeStamp":"2017-03-30T02:08:30.6215063Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2319.json","@type":"CatalogPage","commitId":"1615a5be-53e5-4fa9-99e0-63ba26a965fe","commitTimeStamp":"2017-03-30T10:39:04.1471794Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2320.json","@type":"CatalogPage","commitId":"9b53cb6f-fcaa-48e7-bff8-b27c9a23d55e","commitTimeStamp":"2017-03-30T15:27:00.4156494Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2321.json","@type":"CatalogPage","commitId":"29316247-7da6-4952-9a61-6266a68fe189","commitTimeStamp":"2017-03-30T17:47:27.5897707Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2322.json","@type":"CatalogPage","commitId":"cd297431-be77-44ec-b249-ae4402c1dd19","commitTimeStamp":"2017-03-31T01:39:16.1504778Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2323.json","@type":"CatalogPage","commitId":"2f2e0988-3748-4ec9-8ba6-a07748a5c752","commitTimeStamp":"2017-03-31T09:56:28.3182781Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2324.json","@type":"CatalogPage","commitId":"e06e3ac8-d92b-4ac9-938c-10af6b606e38","commitTimeStamp":"2017-03-31T15:07:04.4895448Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2325.json","@type":"CatalogPage","commitId":"b4066b89-0607-4ef8-97aa-4473c4d31521","commitTimeStamp":"2017-03-31T21:32:31.3901408Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2326.json","@type":"CatalogPage","commitId":"ab44fea1-4e6d-48a8-9f34-766b627da751","commitTimeStamp":"2017-04-01T05:20:13.7787515Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page2327.json","@type":"CatalogPage","commitId":"55b82aec-a072-453b-8422-e47112309fdf","commitTimeStamp":"2017-04-01T16:12:07.4204148Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2328.json","@type":"CatalogPage","commitId":"66c1e64a-5b8d-4dcb-9843-233b4092b56b","commitTimeStamp":"2017-04-02T12:58:45.2782234Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2329.json","@type":"CatalogPage","commitId":"41e9b800-bd0f-4082-b75b-044f6d4601f6","commitTimeStamp":"2017-04-03T04:06:36.8319481Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2330.json","@type":"CatalogPage","commitId":"ce9d80fd-f6e7-4bec-9be4-81f96b7e0edf","commitTimeStamp":"2017-04-03T12:40:09.7358726Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page2331.json","@type":"CatalogPage","commitId":"6318b3be-36e9-43b8-b9e0-9076ff3fb5eb","commitTimeStamp":"2017-04-03T18:09:07.3129147Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2332.json","@type":"CatalogPage","commitId":"b6dd317b-f579-42b4-8c9b-8df66d4a1ac7","commitTimeStamp":"2017-04-04T02:53:55.2743894Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2333.json","@type":"CatalogPage","commitId":"1b24b2c1-7347-44f7-9d30-0e412ad697df","commitTimeStamp":"2017-04-04T09:07:59.5371335Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2334.json","@type":"CatalogPage","commitId":"b4f042d0-b256-4f74-8743-10818545b91d","commitTimeStamp":"2017-04-04T16:06:11.4348678Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2335.json","@type":"CatalogPage","commitId":"faa1aba6-f478-402c-82ec-66aa97de801c","commitTimeStamp":"2017-04-05T02:10:09.0063768Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2336.json","@type":"CatalogPage","commitId":"0febf600-ae34-45f2-ac50-c751b0eb3828","commitTimeStamp":"2017-04-05T05:27:42.5785425Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2337.json","@type":"CatalogPage","commitId":"5ac7a8f1-5cc7-4efa-8c34-ddbd7639c8dd","commitTimeStamp":"2017-04-05T09:59:14.4419046Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2338.json","@type":"CatalogPage","commitId":"317261c5-ed4f-4391-be55-2fe7d2c1c3fb","commitTimeStamp":"2017-04-05T14:22:11.7559866Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2339.json","@type":"CatalogPage","commitId":"afaa9b85-a93d-4704-a1e1-363bf53fe674","commitTimeStamp":"2017-04-05T18:47:45.9024685Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2340.json","@type":"CatalogPage","commitId":"d65f2b8e-734b-45e1-ac27-17d2706823f8","commitTimeStamp":"2017-04-06T07:16:15.1008078Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2341.json","@type":"CatalogPage","commitId":"2a46a5b9-9aff-4d7e-8971-f388c5617837","commitTimeStamp":"2017-04-06T10:29:08.9226286Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2342.json","@type":"CatalogPage","commitId":"b178c156-32b7-4f08-86af-4d5c50187452","commitTimeStamp":"2017-04-06T16:22:00.0246662Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2343.json","@type":"CatalogPage","commitId":"37e77ec6-c183-4b77-8ed4-0b5478b66b0b","commitTimeStamp":"2017-04-07T03:22:56.0006991Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2344.json","@type":"CatalogPage","commitId":"9a2cd278-310c-4470-b0d1-d394977ffb74","commitTimeStamp":"2017-04-07T11:08:48.4686621Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2345.json","@type":"CatalogPage","commitId":"0f6c7ef9-b9ad-4174-a744-211181d5103d","commitTimeStamp":"2017-04-07T19:26:16.9192892Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2346.json","@type":"CatalogPage","commitId":"6a72a527-e144-463c-87bd-cb8b3da03d51","commitTimeStamp":"2017-04-07T20:31:57.795706Z","count":533},{"@id":"https://api.nuget.org/v3/catalog0/page2347.json","@type":"CatalogPage","commitId":"fa2bb5ba-203c-4124-86cb-492cbe2a424b","commitTimeStamp":"2017-04-07T20:52:56.249236Z","count":544},{"@id":"https://api.nuget.org/v3/catalog0/page2348.json","@type":"CatalogPage","commitId":"960fd1b9-b62e-409d-8d86-f1082509a6a0","commitTimeStamp":"2017-04-07T21:04:01.5082757Z","count":543},{"@id":"https://api.nuget.org/v3/catalog0/page2349.json","@type":"CatalogPage","commitId":"dd719d2b-9629-4422-8fee-d6b6b6848ad9","commitTimeStamp":"2017-04-07T21:15:18.3264461Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2350.json","@type":"CatalogPage","commitId":"f1e10352-65b6-4a37-bbcd-7a70b4200f8a","commitTimeStamp":"2017-04-08T07:37:40.4528191Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2351.json","@type":"CatalogPage","commitId":"d642e779-dcad-4621-9ed7-adcf54de8761","commitTimeStamp":"2017-04-08T19:25:29.9309112Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2352.json","@type":"CatalogPage","commitId":"b1b879be-11a1-47ee-ba36-67b8c925bb60","commitTimeStamp":"2017-04-09T11:11:59.0104967Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2353.json","@type":"CatalogPage","commitId":"399a765c-008c-4c5a-9313-0e37b2f5b81f","commitTimeStamp":"2017-04-10T02:59:42.4706118Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2354.json","@type":"CatalogPage","commitId":"aa7e115d-9731-4040-988c-ebdd4a56e838","commitTimeStamp":"2017-04-10T11:05:42.0882022Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2355.json","@type":"CatalogPage","commitId":"54d944bd-20b9-4e8a-bf0f-8e15846c90ef","commitTimeStamp":"2017-04-10T19:10:46.8032263Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2356.json","@type":"CatalogPage","commitId":"800edc9c-fb7d-44fd-bd77-93f7a5154c36","commitTimeStamp":"2017-04-11T06:30:53.4717295Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2357.json","@type":"CatalogPage","commitId":"f365b433-8350-4888-ad25-eaba97a0ec03","commitTimeStamp":"2017-04-11T10:21:28.9300539Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2358.json","@type":"CatalogPage","commitId":"311cb70b-e5f7-4652-a659-c2f599a8103b","commitTimeStamp":"2017-04-11T17:42:36.4085325Z","count":543},{"@id":"https://api.nuget.org/v3/catalog0/page2359.json","@type":"CatalogPage","commitId":"8168df78-15d2-4908-9943-8f7556120521","commitTimeStamp":"2017-04-12T01:30:21.3933656Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2360.json","@type":"CatalogPage","commitId":"b369708a-8513-4c89-b564-162276801fb5","commitTimeStamp":"2017-04-12T08:29:00.516358Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2361.json","@type":"CatalogPage","commitId":"bd098404-aca4-40ef-9673-9b9a296360fe","commitTimeStamp":"2017-04-12T15:10:42.2519629Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2362.json","@type":"CatalogPage","commitId":"19cdb345-36f1-4751-90fd-288c5f1c7537","commitTimeStamp":"2017-04-12T20:20:45.8708141Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2363.json","@type":"CatalogPage","commitId":"b836da14-08ce-4aff-bf42-1308c7e6d5ea","commitTimeStamp":"2017-04-13T07:24:56.2163518Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2364.json","@type":"CatalogPage","commitId":"9b2c7229-dbef-4911-8e03-8e9fe86e03cd","commitTimeStamp":"2017-04-13T15:29:28.5781175Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2365.json","@type":"CatalogPage","commitId":"52cb1922-d5fa-413f-9703-a3ad45189dbb","commitTimeStamp":"2017-04-13T19:44:45.0941652Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2366.json","@type":"CatalogPage","commitId":"14ab8569-db11-4928-ad07-620dc6786ea9","commitTimeStamp":"2017-04-14T10:14:56.1823604Z","count":542},{"@id":"https://api.nuget.org/v3/catalog0/page2367.json","@type":"CatalogPage","commitId":"fdddb70c-56c6-47a5-9f4c-80a87db45302","commitTimeStamp":"2017-04-14T19:32:17.7625561Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2368.json","@type":"CatalogPage","commitId":"0a31cbdf-ecd8-4ebd-aba7-1dab519d90d3","commitTimeStamp":"2017-04-15T16:04:33.6375447Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2369.json","@type":"CatalogPage","commitId":"2ee8720e-e007-42b6-8e4a-a8d5b4d58b9c","commitTimeStamp":"2017-04-16T07:15:31.6701741Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2370.json","@type":"CatalogPage","commitId":"7b0bf044-8ce0-4ee0-9a2c-79807768e112","commitTimeStamp":"2017-04-17T05:17:25.8775193Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2371.json","@type":"CatalogPage","commitId":"458abdc8-293e-49b1-bdb6-f55d798056e5","commitTimeStamp":"2017-04-17T16:31:00.0838518Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2372.json","@type":"CatalogPage","commitId":"7e85b45f-979d-4c3a-94bc-dec2a1e4169e","commitTimeStamp":"2017-04-18T04:21:14.2626054Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2373.json","@type":"CatalogPage","commitId":"f9599ca1-a99e-4c5b-82b2-6ce0ca0a0343","commitTimeStamp":"2017-04-18T13:29:50.1787455Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2374.json","@type":"CatalogPage","commitId":"aa256fd0-fa89-4d9c-9676-53b8a481acec","commitTimeStamp":"2017-04-18T22:24:22.9072036Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2375.json","@type":"CatalogPage","commitId":"c65434f3-64e5-4b52-a874-ffdfa1719308","commitTimeStamp":"2017-04-19T06:38:00.8925991Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2376.json","@type":"CatalogPage","commitId":"809c4cf7-88df-4cf4-bd9d-264a1ddbbae5","commitTimeStamp":"2017-04-19T11:49:40.326486Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2377.json","@type":"CatalogPage","commitId":"5c989569-80ba-43c6-af78-3a557edba9ad","commitTimeStamp":"2017-04-19T15:44:34.7760152Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2378.json","@type":"CatalogPage","commitId":"622a0d50-d2ec-4a7c-9d47-063f93816db1","commitTimeStamp":"2017-04-19T21:48:05.318859Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2379.json","@type":"CatalogPage","commitId":"1b80c491-27a0-4731-8d41-0aafbadccffb","commitTimeStamp":"2017-04-20T01:16:28.8906375Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2380.json","@type":"CatalogPage","commitId":"dd6c3ff7-d446-47b5-9dd4-c9b4a0b58442","commitTimeStamp":"2017-04-20T05:17:05.1651317Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2381.json","@type":"CatalogPage","commitId":"e2e8fb5e-b2c2-4769-a833-114c87d6f3b2","commitTimeStamp":"2017-04-20T13:04:23.7880133Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2382.json","@type":"CatalogPage","commitId":"34eb3e93-17a7-4641-9137-b1c6501f7246","commitTimeStamp":"2017-04-20T19:26:58.2933816Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2383.json","@type":"CatalogPage","commitId":"918f7a2e-2df0-4f8a-9c01-6ccc9cbf9ac9","commitTimeStamp":"2017-04-21T00:33:53.9720406Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2384.json","@type":"CatalogPage","commitId":"754fd273-d7c9-4dbb-841e-9bd3ada352c6","commitTimeStamp":"2017-04-21T11:07:01.6646748Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2385.json","@type":"CatalogPage","commitId":"c87e6808-1b35-4a9a-bc21-7ffe29c65d31","commitTimeStamp":"2017-04-21T17:17:23.679744Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2386.json","@type":"CatalogPage","commitId":"c1971f98-5332-4621-8866-fa716b8b8849","commitTimeStamp":"2017-04-21T23:50:05.1508118Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2387.json","@type":"CatalogPage","commitId":"2dfd49af-fa8d-4990-9811-cbaf3b6d306c","commitTimeStamp":"2017-04-22T13:47:51.4104358Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2388.json","@type":"CatalogPage","commitId":"35d0be34-030d-4c0b-b450-09a18492b994","commitTimeStamp":"2017-04-23T09:31:28.5945053Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2389.json","@type":"CatalogPage","commitId":"4abbb186-0960-4f28-98c9-97ba0bcfc433","commitTimeStamp":"2017-04-24T03:39:32.9009823Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2390.json","@type":"CatalogPage","commitId":"6fe10585-76fc-49fe-a962-30edf0e3911a","commitTimeStamp":"2017-04-24T11:48:15.2216739Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2391.json","@type":"CatalogPage","commitId":"f3ff645f-e7ff-45d4-8f2e-6b5a58ec9617","commitTimeStamp":"2017-04-24T19:01:31.1564122Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2392.json","@type":"CatalogPage","commitId":"3dafdb93-e8dd-45f2-ad38-6dc3df8ce404","commitTimeStamp":"2017-04-25T04:32:08.3616114Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2393.json","@type":"CatalogPage","commitId":"5829940c-f4a5-4633-9c57-4d98c2769b0b","commitTimeStamp":"2017-04-25T12:43:42.6131301Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2394.json","@type":"CatalogPage","commitId":"aadacf57-9dc6-4aee-8bec-9eea05f46aed","commitTimeStamp":"2017-04-25T20:54:43.3093304Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2395.json","@type":"CatalogPage","commitId":"cdfb3e49-4735-4b29-8826-02e608377a4e","commitTimeStamp":"2017-04-26T09:26:17.9593188Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page2396.json","@type":"CatalogPage","commitId":"b413d1a0-145c-4e8a-831f-0c5f617a9bfa","commitTimeStamp":"2017-04-26T14:05:47.0682376Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2397.json","@type":"CatalogPage","commitId":"47d9c700-d353-47ff-bf52-df414b3d816a","commitTimeStamp":"2017-04-26T20:50:19.0958015Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2398.json","@type":"CatalogPage","commitId":"037c0ab2-7b89-4fe9-88d5-5d8c79c2b1a4","commitTimeStamp":"2017-04-27T08:54:45.8155945Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2399.json","@type":"CatalogPage","commitId":"e7092599-63c6-4905-8e62-03df28a3eee9","commitTimeStamp":"2017-04-27T15:22:02.8245949Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2400.json","@type":"CatalogPage","commitId":"e8ca9307-d90b-4838-b773-758f26313271","commitTimeStamp":"2017-04-27T22:38:26.7220337Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2401.json","@type":"CatalogPage","commitId":"0f118e3e-fc73-4a31-aa63-4ec124d1cd40","commitTimeStamp":"2017-04-28T10:21:27.8575474Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2402.json","@type":"CatalogPage","commitId":"69b76ba7-d2ec-4729-8ec6-c63de91052b9","commitTimeStamp":"2017-04-28T15:53:24.0136152Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2403.json","@type":"CatalogPage","commitId":"dbdeb771-2285-47ea-b72f-f5ddb872c4e7","commitTimeStamp":"2017-04-28T22:38:11.5921086Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2404.json","@type":"CatalogPage","commitId":"ede2c081-cf1d-428f-89b8-31de2bdee4bc","commitTimeStamp":"2017-04-29T13:52:50.3525131Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2405.json","@type":"CatalogPage","commitId":"11fdd3f6-806f-40db-9c22-e747fa4d5311","commitTimeStamp":"2017-04-30T11:11:25.8106317Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2406.json","@type":"CatalogPage","commitId":"bda802b3-ac10-4465-aea3-f85147982efe","commitTimeStamp":"2017-05-01T11:11:31.9128791Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2407.json","@type":"CatalogPage","commitId":"33f41502-5092-4932-86e6-81d2d1b48665","commitTimeStamp":"2017-05-01T20:07:56.4772321Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2408.json","@type":"CatalogPage","commitId":"3cb32931-10c8-43eb-9988-589a9f509b1f","commitTimeStamp":"2017-05-02T09:17:07.32454Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2409.json","@type":"CatalogPage","commitId":"55bd192f-5bc4-4ba9-8029-a82b1d570ee7","commitTimeStamp":"2017-05-02T17:05:07.3289609Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2410.json","@type":"CatalogPage","commitId":"181eaace-3c2f-4d3d-8250-e77f08b395bb","commitTimeStamp":"2017-05-03T00:45:17.8843658Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2411.json","@type":"CatalogPage","commitId":"4785b134-bd7a-4773-a244-c29276ba2f6c","commitTimeStamp":"2017-05-03T09:10:53.0951668Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2412.json","@type":"CatalogPage","commitId":"9a16fcba-b86a-4512-b9ed-27cfc7899971","commitTimeStamp":"2017-05-03T16:47:08.9352976Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2413.json","@type":"CatalogPage","commitId":"f4d96be3-7b05-4b8c-91db-89494daffa2b","commitTimeStamp":"2017-05-04T04:48:29.4699903Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2414.json","@type":"CatalogPage","commitId":"37c07fe2-1bf4-44f4-a450-89ab8763694b","commitTimeStamp":"2017-05-04T12:24:07.7173609Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2415.json","@type":"CatalogPage","commitId":"8881f17c-7236-4b75-8db7-58d28aaa2ee8","commitTimeStamp":"2017-05-04T19:39:53.2900872Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2416.json","@type":"CatalogPage","commitId":"6446f955-a7b9-492c-a1cc-b6806c2d2e70","commitTimeStamp":"2017-05-05T02:14:27.6951905Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2417.json","@type":"CatalogPage","commitId":"65b8abec-3fd2-4442-b94e-56ddb69db1b0","commitTimeStamp":"2017-05-05T11:27:19.6319114Z","count":544},{"@id":"https://api.nuget.org/v3/catalog0/page2418.json","@type":"CatalogPage","commitId":"452bebf9-d90e-41a0-b352-1c8e4d5b2e51","commitTimeStamp":"2017-05-05T17:49:22.7130718Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2419.json","@type":"CatalogPage","commitId":"1c2fe0fb-cf86-4f1b-b76e-8cd24a72ee10","commitTimeStamp":"2017-05-06T08:20:07.0740118Z","count":543},{"@id":"https://api.nuget.org/v3/catalog0/page2420.json","@type":"CatalogPage","commitId":"9ab9bf3b-8601-4889-a9d6-b76fd81ca868","commitTimeStamp":"2017-05-07T03:24:42.704694Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2421.json","@type":"CatalogPage","commitId":"ffbf178a-20cc-45ef-80f0-a767d7f14ff9","commitTimeStamp":"2017-05-08T00:59:46.3473886Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2422.json","@type":"CatalogPage","commitId":"85e7ce26-e5e6-4635-aab2-f57bfa34c67e","commitTimeStamp":"2017-05-08T12:33:01.6326332Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2423.json","@type":"CatalogPage","commitId":"9bb1aacd-0f5a-4a45-9e4c-a151f24ac31d","commitTimeStamp":"2017-05-08T18:32:04.0210962Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2424.json","@type":"CatalogPage","commitId":"da4f4629-384c-4632-b831-e374635beddd","commitTimeStamp":"2017-05-09T02:21:55.7567978Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2425.json","@type":"CatalogPage","commitId":"bf71e08d-df6d-43a9-a29f-b81f3fb0b0b3","commitTimeStamp":"2017-05-09T11:25:38.0358895Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2426.json","@type":"CatalogPage","commitId":"d66c7071-1305-4899-b411-246e3b48004d","commitTimeStamp":"2017-05-09T16:35:09.5958178Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2427.json","@type":"CatalogPage","commitId":"f41ddbba-8069-4fc9-84f8-139102fcba77","commitTimeStamp":"2017-05-09T19:25:35.6463426Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2428.json","@type":"CatalogPage","commitId":"dbab2fbc-a3a3-440d-b197-4c5ae0245157","commitTimeStamp":"2017-05-09T23:16:36.8883655Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2429.json","@type":"CatalogPage","commitId":"03869597-f059-4017-ab4e-59031fef00de","commitTimeStamp":"2017-05-10T08:37:28.331293Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2430.json","@type":"CatalogPage","commitId":"01a547b0-4b88-4059-9f86-df77d0c0b926","commitTimeStamp":"2017-05-10T13:59:47.0143185Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2431.json","@type":"CatalogPage","commitId":"60ab5149-0def-4c66-8142-52dfb42d51d6","commitTimeStamp":"2017-05-10T20:32:21.8140578Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2432.json","@type":"CatalogPage","commitId":"f32115d1-2f08-4976-b08f-59efdcd595ca","commitTimeStamp":"2017-05-11T08:00:44.1381138Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2433.json","@type":"CatalogPage","commitId":"dc7c5965-69d8-4165-a61f-92293d85d27f","commitTimeStamp":"2017-05-11T14:29:25.8299613Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2434.json","@type":"CatalogPage","commitId":"64ec7ad2-bd01-48a8-b520-6eb30ef543ce","commitTimeStamp":"2017-05-11T21:51:48.6354517Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2435.json","@type":"CatalogPage","commitId":"fc40a96a-da65-4808-9f87-f8e3e62c781c","commitTimeStamp":"2017-05-12T05:59:51.9888332Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2436.json","@type":"CatalogPage","commitId":"92390057-88ec-4d3c-85dd-430ffd29d250","commitTimeStamp":"2017-05-12T13:27:22.215145Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2437.json","@type":"CatalogPage","commitId":"0240a935-5437-4d7b-af46-fe35ff136a19","commitTimeStamp":"2017-05-12T19:16:13.4398022Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page2438.json","@type":"CatalogPage","commitId":"6e20d439-95e7-4fff-b1e2-27622cb9e737","commitTimeStamp":"2017-05-13T08:42:44.8731147Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2439.json","@type":"CatalogPage","commitId":"aca906b4-0d47-4482-a7ae-109746e66b63","commitTimeStamp":"2017-05-14T01:24:35.2817861Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2440.json","@type":"CatalogPage","commitId":"d976d57b-1834-4f98-9bec-9f89f1ab4925","commitTimeStamp":"2017-05-14T19:17:28.4458994Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2441.json","@type":"CatalogPage","commitId":"69b63b09-33bd-4655-a1a4-10cce85b8153","commitTimeStamp":"2017-05-15T08:47:26.9747296Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2442.json","@type":"CatalogPage","commitId":"3992d287-029b-44e5-9ad0-3949c4cbf48f","commitTimeStamp":"2017-05-15T16:32:52.109789Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2443.json","@type":"CatalogPage","commitId":"6647c5fc-5b31-4892-b5f2-2321eb0a6723","commitTimeStamp":"2017-05-16T03:58:49.8480094Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2444.json","@type":"CatalogPage","commitId":"d535b564-bc8a-46b2-8dfb-04392cd6b5e3","commitTimeStamp":"2017-05-16T12:25:06.8528801Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2445.json","@type":"CatalogPage","commitId":"2aafeb04-8301-41de-af7f-c684bdac5269","commitTimeStamp":"2017-05-16T20:36:57.3468883Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2446.json","@type":"CatalogPage","commitId":"ed98aa46-c04c-4877-97cf-d92b658a6b1d","commitTimeStamp":"2017-05-17T08:34:05.2773282Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2447.json","@type":"CatalogPage","commitId":"7726c5ad-89d7-40aa-9fd7-0c6122af0de6","commitTimeStamp":"2017-05-17T15:46:38.1017051Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page2448.json","@type":"CatalogPage","commitId":"cb3ec59b-f5fb-4714-abc5-efff92a8c1c8","commitTimeStamp":"2017-05-17T19:43:25.0289641Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2449.json","@type":"CatalogPage","commitId":"9bf58ebf-421d-46cf-bff9-2de2f353c3b4","commitTimeStamp":"2017-05-18T08:20:53.9491083Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2450.json","@type":"CatalogPage","commitId":"b43eac06-790d-4afb-a939-931f8868ffb6","commitTimeStamp":"2017-05-18T14:24:18.9641482Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2451.json","@type":"CatalogPage","commitId":"592c4dd3-8a43-4c34-9830-32e4b7b42516","commitTimeStamp":"2017-05-18T22:02:36.9234055Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2452.json","@type":"CatalogPage","commitId":"ac46f222-bca5-46be-b5a6-059769fd75f7","commitTimeStamp":"2017-05-19T10:23:51.9202562Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2453.json","@type":"CatalogPage","commitId":"a486d776-76bd-4340-9c0c-3224a80a198e","commitTimeStamp":"2017-05-19T16:48:43.3998317Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2454.json","@type":"CatalogPage","commitId":"9070e277-9cf6-4099-9f12-5004735d4f97","commitTimeStamp":"2017-05-19T22:09:45.8619183Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2455.json","@type":"CatalogPage","commitId":"0ec4162d-5e8d-44e7-84a5-8d4196ee92fb","commitTimeStamp":"2017-05-20T18:33:40.0107505Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2456.json","@type":"CatalogPage","commitId":"be80512a-d1f5-4ded-b276-2e8c3e0bf6f1","commitTimeStamp":"2017-05-21T15:32:46.9986725Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2457.json","@type":"CatalogPage","commitId":"d3b0eee0-f96f-4421-9ca3-e8af9cc5aea1","commitTimeStamp":"2017-05-22T07:52:39.7192271Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2458.json","@type":"CatalogPage","commitId":"b7985019-fea0-4a7f-9b21-e6cb7b9d39bf","commitTimeStamp":"2017-05-22T15:18:28.806417Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2459.json","@type":"CatalogPage","commitId":"75723eba-4a85-44ec-bb72-9636ae4f60c5","commitTimeStamp":"2017-05-22T21:06:35.0165801Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2460.json","@type":"CatalogPage","commitId":"432a4c8a-9ac1-4f87-aac8-0ab535b18ed9","commitTimeStamp":"2017-05-23T06:35:33.4874406Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2461.json","@type":"CatalogPage","commitId":"2e883b71-ebfa-476e-8a43-54daed3efae1","commitTimeStamp":"2017-05-23T13:59:09.5065769Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2462.json","@type":"CatalogPage","commitId":"cb820820-579c-4e63-9d4b-bcb994e8bcc9","commitTimeStamp":"2017-05-23T20:03:48.7795297Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2463.json","@type":"CatalogPage","commitId":"7130a7f1-ba4a-4b19-be89-ce57396e8940","commitTimeStamp":"2017-05-24T05:07:24.0869255Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2464.json","@type":"CatalogPage","commitId":"6d238a88-b88e-4e2e-b0d3-bb1b998fea71","commitTimeStamp":"2017-05-24T09:38:22.4433585Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2465.json","@type":"CatalogPage","commitId":"b4d47bc1-a594-4fc8-aebb-a04f27c20c98","commitTimeStamp":"2017-05-24T15:30:16.5193284Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2466.json","@type":"CatalogPage","commitId":"639f227b-0969-4d76-bb9d-c46407909918","commitTimeStamp":"2017-05-24T23:17:07.7874132Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2467.json","@type":"CatalogPage","commitId":"0f9f5aa3-e378-4a14-999a-90c6e6f668f2","commitTimeStamp":"2017-05-25T10:03:05.1040957Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page2468.json","@type":"CatalogPage","commitId":"f5fa9948-0002-46e3-ad4f-bff42395c54d","commitTimeStamp":"2017-05-25T17:03:24.4875089Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page2469.json","@type":"CatalogPage","commitId":"56961719-b1ec-4d7a-ad2f-2c1e81ff4e9b","commitTimeStamp":"2017-05-25T22:20:57.3681187Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2470.json","@type":"CatalogPage","commitId":"2de81e37-8d1c-423d-a13e-5219175a6b47","commitTimeStamp":"2017-05-26T09:16:18.6086324Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2471.json","@type":"CatalogPage","commitId":"a6218cb7-c1d1-4904-ac62-2ec4e4e2052a","commitTimeStamp":"2017-05-26T15:22:23.6245882Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2472.json","@type":"CatalogPage","commitId":"d99877e1-b766-4a48-87f6-f456f417d2c7","commitTimeStamp":"2017-05-27T00:55:52.9733157Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2473.json","@type":"CatalogPage","commitId":"46e9c551-fa68-48c5-8ff8-ebd375a5be79","commitTimeStamp":"2017-05-27T21:01:25.4849996Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2474.json","@type":"CatalogPage","commitId":"210f87f2-b4f2-4d3c-8534-5bef0d93b8f6","commitTimeStamp":"2017-05-28T17:48:42.2568351Z","count":543},{"@id":"https://api.nuget.org/v3/catalog0/page2475.json","@type":"CatalogPage","commitId":"007036b1-0dca-4cba-8fcb-398278bd55cb","commitTimeStamp":"2017-05-29T08:38:59.563451Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2476.json","@type":"CatalogPage","commitId":"0a090b45-3662-40d4-a595-5b851ce19b97","commitTimeStamp":"2017-05-29T14:31:18.8726021Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2477.json","@type":"CatalogPage","commitId":"b0b567b4-bcb9-4096-b73c-d0fee51c7017","commitTimeStamp":"2017-05-30T06:01:34.6833274Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2478.json","@type":"CatalogPage","commitId":"f3fd3e85-a5a4-4a4e-b51d-85952cec8fd2","commitTimeStamp":"2017-05-30T13:56:54.9816973Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2479.json","@type":"CatalogPage","commitId":"c86d9fd9-d6aa-4a24-a66d-827560ae0152","commitTimeStamp":"2017-05-30T21:17:31.7182317Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2480.json","@type":"CatalogPage","commitId":"00e910d1-200d-49fd-9df6-5fb23632624d","commitTimeStamp":"2017-05-31T08:35:40.8834612Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2481.json","@type":"CatalogPage","commitId":"559972ec-36da-47aa-b249-ccc502be841b","commitTimeStamp":"2017-05-31T15:03:16.5075226Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2482.json","@type":"CatalogPage","commitId":"62b3ced5-23a4-493f-8dd7-5df6db94e7ca","commitTimeStamp":"2017-05-31T21:20:32.829022Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2483.json","@type":"CatalogPage","commitId":"5ad8cc7d-a462-4ead-9d2a-fa418fbe2af2","commitTimeStamp":"2017-06-01T08:33:29.1085219Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2484.json","@type":"CatalogPage","commitId":"272f4018-9766-40f1-9235-9fa3fb31d411","commitTimeStamp":"2017-06-01T12:00:02.6042542Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2485.json","@type":"CatalogPage","commitId":"3c5571e8-dd16-4300-8ad3-5f60ab981c29","commitTimeStamp":"2017-06-01T13:17:03.1611021Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2486.json","@type":"CatalogPage","commitId":"8e58cdce-a44a-4658-affc-e61517f3b85f","commitTimeStamp":"2017-06-01T17:18:10.865967Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2487.json","@type":"CatalogPage","commitId":"55674358-2c5b-4572-9d9a-95ddc7aa33b0","commitTimeStamp":"2017-06-02T06:35:06.2032159Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2488.json","@type":"CatalogPage","commitId":"536be45d-5a59-4f24-beae-a8e86dc98ce8","commitTimeStamp":"2017-06-02T14:20:33.8837786Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2489.json","@type":"CatalogPage","commitId":"7188fab6-5072-4bfc-9766-33118d12c376","commitTimeStamp":"2017-06-02T21:10:10.3406408Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2490.json","@type":"CatalogPage","commitId":"6be86d6f-1e64-4767-905f-403b137406e7","commitTimeStamp":"2017-06-03T15:38:43.1793354Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2491.json","@type":"CatalogPage","commitId":"986d791c-0d8c-4e41-840d-a94385fec939","commitTimeStamp":"2017-06-04T10:29:29.2497655Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2492.json","@type":"CatalogPage","commitId":"6f12bc72-0a5b-4566-b9a8-6c2ef6886a1a","commitTimeStamp":"2017-06-05T01:00:06.9647565Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2493.json","@type":"CatalogPage","commitId":"20f89ad5-c5a4-46af-be00-aae9cf2d8a3b","commitTimeStamp":"2017-06-05T10:37:00.7528067Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2494.json","@type":"CatalogPage","commitId":"195eb72d-752b-487c-acf7-b1e14b64b17f","commitTimeStamp":"2017-06-05T19:07:50.6318247Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2495.json","@type":"CatalogPage","commitId":"d1acf437-b131-4da6-9a3d-2e399b5b139e","commitTimeStamp":"2017-06-06T08:37:32.2685114Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2496.json","@type":"CatalogPage","commitId":"3edae5a1-4a69-4955-b20f-7a0c1f7c2bc8","commitTimeStamp":"2017-06-06T15:33:51.969518Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2497.json","@type":"CatalogPage","commitId":"19cff9a2-f53f-4bd8-b12f-52e1c2e7ba72","commitTimeStamp":"2017-06-06T20:50:05.0079398Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2498.json","@type":"CatalogPage","commitId":"834bc3cf-73ca-462d-820e-7f258030dbad","commitTimeStamp":"2017-06-07T08:35:07.4945658Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2499.json","@type":"CatalogPage","commitId":"1775f14a-cc0a-4bd8-8b8f-bf31596bd951","commitTimeStamp":"2017-06-07T14:45:44.9007814Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page2500.json","@type":"CatalogPage","commitId":"86b16888-4c4a-44c7-82cb-6ac0f335f011","commitTimeStamp":"2017-06-07T19:09:40.659879Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2501.json","@type":"CatalogPage","commitId":"5cc5658b-bb89-470f-8f84-77a0788ef116","commitTimeStamp":"2017-06-08T01:44:25.9259043Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2502.json","@type":"CatalogPage","commitId":"1c1dd0d7-8c90-4a80-a190-be946774e2eb","commitTimeStamp":"2017-06-08T10:04:05.2598562Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2503.json","@type":"CatalogPage","commitId":"70a7bbcf-64bd-43ed-ad71-27f1190d359f","commitTimeStamp":"2017-06-08T10:56:52.9998592Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2504.json","@type":"CatalogPage","commitId":"8a494d3d-610b-4ed0-aa2e-d153d8ab6596","commitTimeStamp":"2017-06-08T13:46:50.5786043Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2505.json","@type":"CatalogPage","commitId":"be9296dd-8d22-4cc9-bf4e-c4266b482a98","commitTimeStamp":"2017-06-08T19:20:02.0769395Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2506.json","@type":"CatalogPage","commitId":"20f1f06c-3567-4dbb-ba39-630d8c27ce07","commitTimeStamp":"2017-06-09T06:58:46.1952466Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2507.json","@type":"CatalogPage","commitId":"146f323f-59ba-453c-8d7f-f85839886bf6","commitTimeStamp":"2017-06-09T12:41:07.3095069Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2508.json","@type":"CatalogPage","commitId":"f303ce56-1ff9-4c4f-819f-e0362a78eff6","commitTimeStamp":"2017-06-09T21:12:24.7832012Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2509.json","@type":"CatalogPage","commitId":"7ae5d712-1b22-41f4-a098-eb39a58a78ad","commitTimeStamp":"2017-06-10T13:08:39.4061336Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2510.json","@type":"CatalogPage","commitId":"f09634ac-1b79-4367-b96b-fb9b9b217bb5","commitTimeStamp":"2017-06-11T12:56:23.0941518Z","count":542},{"@id":"https://api.nuget.org/v3/catalog0/page2511.json","@type":"CatalogPage","commitId":"3dccde62-4490-4015-8b8f-ab8f82b569fc","commitTimeStamp":"2017-06-12T01:34:39.9409075Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2512.json","@type":"CatalogPage","commitId":"510b090f-4f6c-4455-889d-decacc487df7","commitTimeStamp":"2017-06-12T14:20:51.3054851Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2513.json","@type":"CatalogPage","commitId":"155885da-1062-4e19-bc8a-19fa26fbd461","commitTimeStamp":"2017-06-13T01:36:12.0087775Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2514.json","@type":"CatalogPage","commitId":"573f7d30-3998-4031-b9dc-0f062c538141","commitTimeStamp":"2017-06-13T09:55:41.6676947Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2515.json","@type":"CatalogPage","commitId":"b6e63d28-c9bb-4b04-8f2d-5eb51bacebcc","commitTimeStamp":"2017-06-13T18:00:45.5258137Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2516.json","@type":"CatalogPage","commitId":"cdc7f0ce-eb35-4775-a985-f8b853bacae6","commitTimeStamp":"2017-06-14T03:35:31.9637345Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2517.json","@type":"CatalogPage","commitId":"471a7998-45d4-4fd2-98ff-c0e6881e617f","commitTimeStamp":"2017-06-14T10:03:24.8823199Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2518.json","@type":"CatalogPage","commitId":"19fb5023-8547-4ce9-8c6e-2ae24a2ea54a","commitTimeStamp":"2017-06-14T16:10:46.6933976Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2519.json","@type":"CatalogPage","commitId":"741ee57c-00ea-4d2b-b212-e49fe1949d2e","commitTimeStamp":"2017-06-15T00:38:38.9020029Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page2520.json","@type":"CatalogPage","commitId":"0ebc985c-8e17-4c54-acd2-61d5a50a1736","commitTimeStamp":"2017-06-15T09:35:51.8714151Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2521.json","@type":"CatalogPage","commitId":"4db24a52-ad18-4ace-9eb5-d736b8b176b0","commitTimeStamp":"2017-06-15T19:45:23.1214619Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2522.json","@type":"CatalogPage","commitId":"25a20860-081d-487e-900a-69bcbe347af0","commitTimeStamp":"2017-06-16T04:08:02.3007682Z","count":534},{"@id":"https://api.nuget.org/v3/catalog0/page2523.json","@type":"CatalogPage","commitId":"b6a0dab4-bb3f-464d-aa01-7d1154549ef4","commitTimeStamp":"2017-06-16T10:28:12.2745047Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2524.json","@type":"CatalogPage","commitId":"e3de2217-f2cf-4072-a700-d18961e509cc","commitTimeStamp":"2017-06-16T20:15:46.4368908Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2525.json","@type":"CatalogPage","commitId":"47d9dad5-55ac-45bd-94e8-1227c16167fb","commitTimeStamp":"2017-06-17T09:24:33.2477243Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2526.json","@type":"CatalogPage","commitId":"e11a8ae7-ca71-48fe-bc49-cae5832313e3","commitTimeStamp":"2017-06-18T05:14:18.9894234Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2527.json","@type":"CatalogPage","commitId":"882e8f11-17c8-470a-8931-3b89b4959e38","commitTimeStamp":"2017-06-18T22:00:46.8684942Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2528.json","@type":"CatalogPage","commitId":"80b611e7-36b3-4581-89a4-41e73eba70db","commitTimeStamp":"2017-06-19T11:16:09.1476211Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2529.json","@type":"CatalogPage","commitId":"f49ab661-31f8-421a-b6b1-7409e06f67c3","commitTimeStamp":"2017-06-19T17:29:21.0345575Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2530.json","@type":"CatalogPage","commitId":"7ca3bb71-3f60-4ed2-a503-a9d91f3c60d1","commitTimeStamp":"2017-06-20T03:51:29.8154703Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2531.json","@type":"CatalogPage","commitId":"3a97be64-822b-41c6-b03b-a2589c265840","commitTimeStamp":"2017-06-20T12:44:59.7127061Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2532.json","@type":"CatalogPage","commitId":"c08e7338-3d37-402c-af2b-964dcee24fb8","commitTimeStamp":"2017-06-20T18:09:04.5561665Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2533.json","@type":"CatalogPage","commitId":"326bf919-c8b0-4628-a97a-d71ccfdd2e75","commitTimeStamp":"2017-06-21T03:17:47.8638971Z","count":542},{"@id":"https://api.nuget.org/v3/catalog0/page2534.json","@type":"CatalogPage","commitId":"d0845930-d3af-40a9-88f9-627c2ce9143b","commitTimeStamp":"2017-06-21T11:48:40.5009491Z","count":542},{"@id":"https://api.nuget.org/v3/catalog0/page2535.json","@type":"CatalogPage","commitId":"bc2c3c84-8652-401a-9e73-f80480a40d36","commitTimeStamp":"2017-06-21T19:19:32.7323344Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2536.json","@type":"CatalogPage","commitId":"1e577788-dd03-47f9-b6f2-9be568561609","commitTimeStamp":"2017-06-22T07:19:45.2440036Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2537.json","@type":"CatalogPage","commitId":"67301705-908e-48ff-9f54-bfc1a26fc24c","commitTimeStamp":"2017-06-22T13:55:13.4366018Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2538.json","@type":"CatalogPage","commitId":"358855b5-9d73-4b33-a0f2-63c85aa1f225","commitTimeStamp":"2017-06-22T22:15:35.0422414Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2539.json","@type":"CatalogPage","commitId":"a5333bb9-8804-413a-a8a6-c0e8329f2e35","commitTimeStamp":"2017-06-23T08:58:31.5189659Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2540.json","@type":"CatalogPage","commitId":"0733ada1-ac98-4f92-aa30-da1bcd06a045","commitTimeStamp":"2017-06-23T15:12:50.8008384Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2541.json","@type":"CatalogPage","commitId":"77fd26b8-b8f2-4267-82f8-402167e1b594","commitTimeStamp":"2017-06-23T22:33:39.4436128Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2542.json","@type":"CatalogPage","commitId":"dec0aeb8-8e45-4dcf-8304-91ecafddbea1","commitTimeStamp":"2017-06-24T18:26:13.738195Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2543.json","@type":"CatalogPage","commitId":"2d9c8c40-42fd-43ac-88f9-1100c132014e","commitTimeStamp":"2017-06-25T19:24:58.3590787Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2544.json","@type":"CatalogPage","commitId":"092fc630-b716-4197-b0d0-6ee20a289af4","commitTimeStamp":"2017-06-26T11:26:02.0920102Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2545.json","@type":"CatalogPage","commitId":"735b9d7e-0db4-4aa1-8f2e-7b95e02211d4","commitTimeStamp":"2017-06-26T18:28:04.4558708Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2546.json","@type":"CatalogPage","commitId":"5213a216-55a3-4b42-ad50-34c7be54515f","commitTimeStamp":"2017-06-27T05:09:40.3629263Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2547.json","@type":"CatalogPage","commitId":"a2d49b1e-cef2-4637-abbe-02c332e7210f","commitTimeStamp":"2017-06-27T14:38:23.2692128Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2548.json","@type":"CatalogPage","commitId":"e8e64a59-9f8a-4806-873b-b9113df89c6e","commitTimeStamp":"2017-06-27T23:11:58.2949369Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2549.json","@type":"CatalogPage","commitId":"204866da-31b1-460e-b2cd-83dac9e6da86","commitTimeStamp":"2017-06-28T06:11:47.7848194Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2550.json","@type":"CatalogPage","commitId":"a55738e9-d908-474e-bd6e-ac8164417afc","commitTimeStamp":"2017-06-28T14:22:57.822131Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page2551.json","@type":"CatalogPage","commitId":"d65a7a7d-4649-4a02-a78b-f36915545ab2","commitTimeStamp":"2017-06-28T20:07:53.7547188Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2552.json","@type":"CatalogPage","commitId":"2e0816fc-368d-4378-8b0e-80dea816f52c","commitTimeStamp":"2017-06-29T05:44:52.1894914Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2553.json","@type":"CatalogPage","commitId":"fb054d8f-fbb6-4106-8388-c34e76bf609a","commitTimeStamp":"2017-06-29T12:53:57.2765298Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2554.json","@type":"CatalogPage","commitId":"64f48b66-2d6a-4d64-9536-3dee6f0307d8","commitTimeStamp":"2017-06-29T21:08:52.5760599Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2555.json","@type":"CatalogPage","commitId":"1e3fd9cd-25c6-4439-a3a3-2ad6ed788255","commitTimeStamp":"2017-06-30T05:44:41.7100953Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2556.json","@type":"CatalogPage","commitId":"d940aa00-868e-4d25-ad36-541b48fa5aa9","commitTimeStamp":"2017-06-30T14:12:42.0573378Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2557.json","@type":"CatalogPage","commitId":"c8df04f5-49b9-4c6b-a420-cd8e898ed7a0","commitTimeStamp":"2017-06-30T20:41:36.1783381Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2558.json","@type":"CatalogPage","commitId":"a9f91f02-49a8-4759-ae89-bffc511c71e9","commitTimeStamp":"2017-07-01T20:47:27.9947987Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2559.json","@type":"CatalogPage","commitId":"3c631830-ec35-40ef-948d-953e928b303e","commitTimeStamp":"2017-07-02T19:43:20.3468477Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2560.json","@type":"CatalogPage","commitId":"04bb2475-975c-442c-8283-a61be8fa5832","commitTimeStamp":"2017-07-03T10:18:00.0407907Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2561.json","@type":"CatalogPage","commitId":"5600075e-ecda-43da-8b3e-28ef1ae97800","commitTimeStamp":"2017-07-03T17:22:13.3194947Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2562.json","@type":"CatalogPage","commitId":"7ce1559b-3c3a-472d-8526-6eb8fb42b93b","commitTimeStamp":"2017-07-04T02:47:49.8474218Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page2563.json","@type":"CatalogPage","commitId":"444240ac-d329-4b1d-8230-54da7eb30231","commitTimeStamp":"2017-07-04T10:45:51.4506998Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2564.json","@type":"CatalogPage","commitId":"9c99d1cd-24b8-44d1-a1fa-55c26186e960","commitTimeStamp":"2017-07-04T18:59:43.1344426Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2565.json","@type":"CatalogPage","commitId":"ee7ab4a7-3f9b-4cbb-b1f5-f5e8b6790375","commitTimeStamp":"2017-07-05T07:12:16.4066793Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2566.json","@type":"CatalogPage","commitId":"1bfcf600-73e4-47f5-9054-8a3a2c47a882","commitTimeStamp":"2017-07-05T13:18:06.7543619Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2567.json","@type":"CatalogPage","commitId":"1cabe5d7-59e9-4a8f-9deb-41655dccbe5c","commitTimeStamp":"2017-07-05T18:52:38.1150368Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2568.json","@type":"CatalogPage","commitId":"53550090-491f-4be0-9bf7-ba8a3dbbb18b","commitTimeStamp":"2017-07-06T00:02:59.9769476Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2569.json","@type":"CatalogPage","commitId":"b2102f90-bda9-439c-9cc4-671f60fb37e6","commitTimeStamp":"2017-07-06T08:00:03.2475995Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2570.json","@type":"CatalogPage","commitId":"8a612b28-aaea-4057-b1b7-137132836696","commitTimeStamp":"2017-07-06T15:30:55.7243076Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2571.json","@type":"CatalogPage","commitId":"7e843e5b-e921-4907-b794-ec7e4613203e","commitTimeStamp":"2017-07-06T21:28:53.7103071Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2572.json","@type":"CatalogPage","commitId":"795c891f-478e-4fb9-ac73-99d45d0d5073","commitTimeStamp":"2017-07-07T07:18:06.8314272Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2573.json","@type":"CatalogPage","commitId":"15be1118-48fa-4de1-9812-98f19a8f5b13","commitTimeStamp":"2017-07-07T12:10:02.2083044Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2574.json","@type":"CatalogPage","commitId":"ddfe340e-871f-4276-b8c8-29d0ff39c117","commitTimeStamp":"2017-07-07T21:07:13.71446Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2575.json","@type":"CatalogPage","commitId":"535e8d4f-7663-4b3d-8ffe-4e64c0f46a82","commitTimeStamp":"2017-07-08T15:16:22.81941Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2576.json","@type":"CatalogPage","commitId":"c7d6fcec-550b-4abe-8a31-e80ea2fdca71","commitTimeStamp":"2017-07-09T17:49:53.6486959Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2577.json","@type":"CatalogPage","commitId":"c6defdde-526d-48c9-8bdd-b275916a098b","commitTimeStamp":"2017-07-10T10:47:31.4217133Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2578.json","@type":"CatalogPage","commitId":"292bf790-6333-4cf2-a915-fd36cc738ba3","commitTimeStamp":"2017-07-10T18:21:14.4014521Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2579.json","@type":"CatalogPage","commitId":"88ebea45-d4d3-4cda-890f-e741b3888083","commitTimeStamp":"2017-07-11T04:00:01.9321646Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2580.json","@type":"CatalogPage","commitId":"05bd2892-6e25-4006-8268-a54811fd3b33","commitTimeStamp":"2017-07-11T13:17:26.388317Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page2581.json","@type":"CatalogPage","commitId":"2b28432d-d909-4a33-b909-d9fbcc752bfe","commitTimeStamp":"2017-07-11T20:48:21.9386903Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2582.json","@type":"CatalogPage","commitId":"9fc60de9-2156-46fa-af0e-eb549152157e","commitTimeStamp":"2017-07-12T04:36:43.1529644Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2583.json","@type":"CatalogPage","commitId":"ec236468-ce03-407c-a1a8-93b5515944c9","commitTimeStamp":"2017-07-12T10:58:39.7151584Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2584.json","@type":"CatalogPage","commitId":"73dc8b0e-e553-4efd-8eb6-b3accded2a53","commitTimeStamp":"2017-07-12T18:22:51.6423507Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2585.json","@type":"CatalogPage","commitId":"d30e6108-7904-4544-a2ff-73050f91f148","commitTimeStamp":"2017-07-13T05:58:14.8615333Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2586.json","@type":"CatalogPage","commitId":"b3c3a4c8-750b-4c76-8954-e1d7b9c395a1","commitTimeStamp":"2017-07-13T09:53:13.777133Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2587.json","@type":"CatalogPage","commitId":"ef6658b6-3b84-4306-a6d6-ed86f5c6dc66","commitTimeStamp":"2017-07-13T15:00:23.7282159Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2588.json","@type":"CatalogPage","commitId":"b6683089-790c-433b-ab51-5ee9098e4347","commitTimeStamp":"2017-07-13T21:20:23.6947523Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2589.json","@type":"CatalogPage","commitId":"49ca7596-4bec-48b6-91a5-0eb12a269a49","commitTimeStamp":"2017-07-14T08:29:16.6854807Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2590.json","@type":"CatalogPage","commitId":"f304e398-c352-45c1-8853-f2e89724a45a","commitTimeStamp":"2017-07-14T13:36:43.1251519Z","count":538},{"@id":"https://api.nuget.org/v3/catalog0/page2591.json","@type":"CatalogPage","commitId":"c023cb3a-f32d-48f3-a73e-65d543d4d851","commitTimeStamp":"2017-07-14T18:45:29.4538245Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2592.json","@type":"CatalogPage","commitId":"873b2a31-9236-4e0d-af61-005184449a83","commitTimeStamp":"2017-07-15T05:40:23.1681867Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2593.json","@type":"CatalogPage","commitId":"76a9076f-afb5-486f-beed-398e3e0f93be","commitTimeStamp":"2017-07-15T15:30:07.9708946Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2594.json","@type":"CatalogPage","commitId":"570a0d5b-48f3-48ff-ac7b-cbda7b788297","commitTimeStamp":"2017-07-16T07:40:20.6598242Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2595.json","@type":"CatalogPage","commitId":"56bf8fd0-9d31-4b9d-b863-cc21582d481e","commitTimeStamp":"2017-07-16T21:50:54.0114061Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2596.json","@type":"CatalogPage","commitId":"4c2c0624-8282-487f-8ae2-116cae85a861","commitTimeStamp":"2017-07-17T09:07:37.3777517Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2597.json","@type":"CatalogPage","commitId":"d7a27cb4-bfaa-423f-93d3-b7b1dfdf286b","commitTimeStamp":"2017-07-17T16:33:48.7051289Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2598.json","@type":"CatalogPage","commitId":"e1e9f2d6-44c4-41fa-b2d4-c86838dfbb9f","commitTimeStamp":"2017-07-18T05:52:36.9702175Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2599.json","@type":"CatalogPage","commitId":"2c0f663d-30ae-461f-af49-5c87e42b06a1","commitTimeStamp":"2017-07-18T10:59:11.1251538Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2600.json","@type":"CatalogPage","commitId":"e500d3a9-ee49-499f-84d9-3ec85e826a7d","commitTimeStamp":"2017-07-18T17:45:08.2212112Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2601.json","@type":"CatalogPage","commitId":"3e60e0bc-3907-4ccb-ab37-ecef00ccb293","commitTimeStamp":"2017-07-19T04:44:50.441302Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2602.json","@type":"CatalogPage","commitId":"78f71d2b-d8d9-4db4-8ac5-e771408cca79","commitTimeStamp":"2017-07-19T11:17:36.1541714Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2603.json","@type":"CatalogPage","commitId":"22213f58-43ec-4590-8b7b-03a887aa2c1b","commitTimeStamp":"2017-07-19T16:01:40.3675701Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2604.json","@type":"CatalogPage","commitId":"75b1034f-8361-4278-86a4-68565257b29f","commitTimeStamp":"2017-07-20T05:15:34.957004Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2605.json","@type":"CatalogPage","commitId":"2a750a8f-0a3d-412f-984c-bc19ee9043dd","commitTimeStamp":"2017-07-20T09:36:01.5484454Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2606.json","@type":"CatalogPage","commitId":"8f28cc17-bf01-4a69-8d0f-b289a24acac8","commitTimeStamp":"2017-07-20T18:48:39.9642229Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2607.json","@type":"CatalogPage","commitId":"7d5fc4b8-794f-44e0-a42b-17bcb51bf989","commitTimeStamp":"2017-07-21T05:14:38.2286687Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2608.json","@type":"CatalogPage","commitId":"19bf90dd-4ab4-4169-a61e-665d7bfea09d","commitTimeStamp":"2017-07-21T12:34:19.6735173Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2609.json","@type":"CatalogPage","commitId":"e369104a-f058-419c-a2b4-e146cd6f7ca4","commitTimeStamp":"2017-07-21T16:15:49.9205936Z","count":531},{"@id":"https://api.nuget.org/v3/catalog0/page2610.json","@type":"CatalogPage","commitId":"12960795-a868-409b-a400-bac1e86a0826","commitTimeStamp":"2017-07-21T17:37:00.3863908Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2611.json","@type":"CatalogPage","commitId":"760f4caf-1889-423d-a984-1f43f0284314","commitTimeStamp":"2017-07-22T07:04:15.8263278Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2612.json","@type":"CatalogPage","commitId":"a2388f2c-a26b-425f-947f-0ebb6e272967","commitTimeStamp":"2017-07-22T21:36:40.9370911Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2613.json","@type":"CatalogPage","commitId":"ced1186a-ff2f-4f70-aa7f-4c6517b155b8","commitTimeStamp":"2017-07-23T06:07:05.2633848Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2614.json","@type":"CatalogPage","commitId":"e760bf1c-af90-4e4a-81ae-c7b853ed1cb4","commitTimeStamp":"2017-07-23T07:48:42.8918752Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2615.json","@type":"CatalogPage","commitId":"2526f517-d135-4639-a208-a82a56fd038e","commitTimeStamp":"2017-07-23T09:20:59.2368487Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2616.json","@type":"CatalogPage","commitId":"013e7b9f-5e4b-4929-a182-b60452f329b1","commitTimeStamp":"2017-07-23T11:10:47.3170422Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2617.json","@type":"CatalogPage","commitId":"c06124d7-9874-4e2d-90e8-d52ec292506c","commitTimeStamp":"2017-07-23T11:47:39.137516Z","count":534},{"@id":"https://api.nuget.org/v3/catalog0/page2618.json","@type":"CatalogPage","commitId":"4b997eeb-6dc0-4acc-b2b4-89552d4e46ab","commitTimeStamp":"2017-07-23T13:33:12.5262136Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2619.json","@type":"CatalogPage","commitId":"74690f91-ee04-436e-9037-b26d5492e220","commitTimeStamp":"2017-07-24T07:40:17.4364222Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2620.json","@type":"CatalogPage","commitId":"e17fc6f0-35e3-48a0-95af-2012e1344dbd","commitTimeStamp":"2017-07-24T15:55:49.7547102Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2621.json","@type":"CatalogPage","commitId":"a43095c9-ca25-400c-bbaa-bf554d9d82e4","commitTimeStamp":"2017-07-24T23:38:58.0715358Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2622.json","@type":"CatalogPage","commitId":"17122827-3921-4c8d-8a05-8f114c181ea2","commitTimeStamp":"2017-07-25T08:40:29.0408093Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2623.json","@type":"CatalogPage","commitId":"991464cb-608c-4468-9274-2f304dc9c29e","commitTimeStamp":"2017-07-25T15:57:38.2738939Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2624.json","@type":"CatalogPage","commitId":"3c1f619e-d1ff-4738-b59c-edef66da700c","commitTimeStamp":"2017-07-25T23:46:00.7678009Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page2625.json","@type":"CatalogPage","commitId":"8714b276-a1b4-49b5-aa3f-a9e16c7bac5f","commitTimeStamp":"2017-07-26T08:19:54.6293789Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2626.json","@type":"CatalogPage","commitId":"78962726-6f38-4618-8fd8-6b81103d742b","commitTimeStamp":"2017-07-26T11:20:18.2079197Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2627.json","@type":"CatalogPage","commitId":"fd8d250b-6f82-4dcb-a0cf-58fe951c6bd7","commitTimeStamp":"2017-07-26T18:22:21.3626496Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2628.json","@type":"CatalogPage","commitId":"5374dd3d-e7a1-47a1-a80c-e18de48c993c","commitTimeStamp":"2017-07-27T02:49:32.3721841Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2629.json","@type":"CatalogPage","commitId":"875a2a4d-1505-49ed-b8a9-7a5dbd7ff61d","commitTimeStamp":"2017-07-27T10:30:38.266449Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2630.json","@type":"CatalogPage","commitId":"74c9a47f-50b5-4a6c-aca6-7c0c097789c6","commitTimeStamp":"2017-07-27T17:53:46.4165001Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2631.json","@type":"CatalogPage","commitId":"381e99ad-975b-40ef-b54b-3404a6914a90","commitTimeStamp":"2017-07-28T00:02:38.3075899Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2632.json","@type":"CatalogPage","commitId":"087ae5d8-25b8-4f8f-b31e-4ea6923c367c","commitTimeStamp":"2017-07-28T07:23:53.3564817Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2633.json","@type":"CatalogPage","commitId":"dcf19766-d133-4707-9cb7-13c6b81b41b4","commitTimeStamp":"2017-07-28T14:40:41.7543296Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2634.json","@type":"CatalogPage","commitId":"05f93021-222c-4e5f-bcc8-064e44e9b6fa","commitTimeStamp":"2017-07-28T22:19:49.8243121Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2635.json","@type":"CatalogPage","commitId":"e682ed30-39ac-46e6-a800-c242ee828fa1","commitTimeStamp":"2017-07-29T14:58:05.9087057Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2636.json","@type":"CatalogPage","commitId":"eb0e72ca-c94e-49bd-ac95-bec115f29c49","commitTimeStamp":"2017-07-30T14:29:46.2857561Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2637.json","@type":"CatalogPage","commitId":"a22fc47f-5017-462d-be7c-9df5d88b8e74","commitTimeStamp":"2017-07-31T03:02:44.3883244Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2638.json","@type":"CatalogPage","commitId":"08cee9fc-501e-48ea-aecf-9ef6c0761d71","commitTimeStamp":"2017-07-31T10:11:33.14303Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2639.json","@type":"CatalogPage","commitId":"cbcb4215-e703-463c-a71a-70179d5633a5","commitTimeStamp":"2017-07-31T17:27:45.81181Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2640.json","@type":"CatalogPage","commitId":"45c16910-6845-498d-9613-e89811427dd4","commitTimeStamp":"2017-08-01T06:22:15.3494961Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2641.json","@type":"CatalogPage","commitId":"84d7bb68-54fb-44cd-ac8b-fd46f4b36269","commitTimeStamp":"2017-08-01T10:47:34.0915744Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2642.json","@type":"CatalogPage","commitId":"9cf41eb5-d7e6-4902-8cab-9cf517dcf5b1","commitTimeStamp":"2017-08-01T16:31:07.1843154Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2643.json","@type":"CatalogPage","commitId":"278b391c-06bb-4a4d-b540-097287aaab58","commitTimeStamp":"2017-08-01T21:51:15.4479689Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2644.json","@type":"CatalogPage","commitId":"c32ea022-5481-46f4-9fa2-8f60debf9782","commitTimeStamp":"2017-08-02T08:58:16.0062967Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2645.json","@type":"CatalogPage","commitId":"974e43bd-2091-4a37-be13-0f16f8fff7ad","commitTimeStamp":"2017-08-02T13:30:03.7261854Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2646.json","@type":"CatalogPage","commitId":"c7c0e10f-1e6a-4cb4-a3a5-2efb417ec7c7","commitTimeStamp":"2017-08-02T19:36:07.7100677Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2647.json","@type":"CatalogPage","commitId":"0e692e46-fecb-4625-b98a-2b1deba0fddc","commitTimeStamp":"2017-08-03T06:11:14.3120166Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2648.json","@type":"CatalogPage","commitId":"625dc6f0-52e6-45e5-ae0d-6e8988658bb2","commitTimeStamp":"2017-08-03T13:02:46.9334901Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page2649.json","@type":"CatalogPage","commitId":"345b5920-9c12-4e23-802b-bd5431010bea","commitTimeStamp":"2017-08-03T20:33:48.8781542Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2650.json","@type":"CatalogPage","commitId":"aa968f46-0359-4888-806d-a6ca4ef7bb10","commitTimeStamp":"2017-08-04T07:30:47.6790053Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2651.json","@type":"CatalogPage","commitId":"827e7d0a-79b4-4731-8b85-b9701eef1d66","commitTimeStamp":"2017-08-04T13:48:16.3027234Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2652.json","@type":"CatalogPage","commitId":"beaaf6be-3db5-4d37-8193-3e5943b4ad15","commitTimeStamp":"2017-08-04T17:17:23.6096501Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2653.json","@type":"CatalogPage","commitId":"77bcba35-a1b6-4b5e-ac68-defdd59a90e4","commitTimeStamp":"2017-08-05T16:21:44.8332849Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2654.json","@type":"CatalogPage","commitId":"4f6e082b-4539-4314-8786-7651bc19d771","commitTimeStamp":"2017-08-06T16:28:23.379398Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2655.json","@type":"CatalogPage","commitId":"f1c31b85-e496-4b54-bdf1-6c5727de5653","commitTimeStamp":"2017-08-07T07:26:05.1176415Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2656.json","@type":"CatalogPage","commitId":"0758eb8e-7117-43eb-bae1-20f31252d75d","commitTimeStamp":"2017-08-07T10:12:34.3736398Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2657.json","@type":"CatalogPage","commitId":"0bf49f9d-f852-4b65-8b59-fd4e6809f6e8","commitTimeStamp":"2017-08-07T16:29:24.1721909Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2658.json","@type":"CatalogPage","commitId":"8f5b0572-91cf-4113-9b61-5f9a648febaf","commitTimeStamp":"2017-08-08T03:24:32.943959Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2659.json","@type":"CatalogPage","commitId":"805f7139-42e1-48e1-b038-5a50e00cce8e","commitTimeStamp":"2017-08-08T13:07:10.7299238Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2660.json","@type":"CatalogPage","commitId":"339426c6-d27f-4c43-be3e-d2a608836486","commitTimeStamp":"2017-08-08T20:41:02.6996845Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2661.json","@type":"CatalogPage","commitId":"dccfe960-81b1-4afc-98a6-a04d942fe6e2","commitTimeStamp":"2017-08-09T08:18:02.493436Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2662.json","@type":"CatalogPage","commitId":"fbe6624f-8d39-4986-80a1-c91e8cf9d2e7","commitTimeStamp":"2017-08-09T14:21:38.3975468Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2663.json","@type":"CatalogPage","commitId":"a90f62ba-1d46-4bb0-a89e-f2ce3f1b0de7","commitTimeStamp":"2017-08-09T19:30:41.6871684Z","count":543},{"@id":"https://api.nuget.org/v3/catalog0/page2664.json","@type":"CatalogPage","commitId":"aa5c1998-f708-4215-b48a-0ca9535f7377","commitTimeStamp":"2017-08-10T06:35:41.7122307Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2665.json","@type":"CatalogPage","commitId":"aae42d14-880c-45aa-978f-8b75b473aff5","commitTimeStamp":"2017-08-10T14:25:12.5536762Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2666.json","@type":"CatalogPage","commitId":"97619e4d-bd94-40fc-a172-70d952427a2a","commitTimeStamp":"2017-08-11T02:18:02.3464271Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2667.json","@type":"CatalogPage","commitId":"277c4a0c-46c9-4cf6-b4c6-18e50d1a9459","commitTimeStamp":"2017-08-11T08:57:49.8177609Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2668.json","@type":"CatalogPage","commitId":"dbaf06cf-2da5-4807-8178-7c1516a7edcc","commitTimeStamp":"2017-08-11T17:58:23.5423712Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2669.json","@type":"CatalogPage","commitId":"a166d780-d9aa-4f34-9d54-6689fb639ca1","commitTimeStamp":"2017-08-11T20:58:06.8854304Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2670.json","@type":"CatalogPage","commitId":"04ac57b7-60c4-4984-9f9b-3ff247601466","commitTimeStamp":"2017-08-12T13:37:06.4333983Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2671.json","@type":"CatalogPage","commitId":"71a15fb1-584b-4096-bf7a-0f0afae8eb3c","commitTimeStamp":"2017-08-13T13:13:34.4439831Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page2672.json","@type":"CatalogPage","commitId":"f3e09abe-979b-4e10-a2c2-855f7f782543","commitTimeStamp":"2017-08-14T06:02:55.0359612Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2673.json","@type":"CatalogPage","commitId":"c1e3c4e5-5a42-4c3b-b318-47958ef010ab","commitTimeStamp":"2017-08-14T12:30:08.2839647Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2674.json","@type":"CatalogPage","commitId":"cd9fc206-ef47-4c1f-8a76-bb823562a878","commitTimeStamp":"2017-08-14T19:55:18.8910124Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2675.json","@type":"CatalogPage","commitId":"8534cfb5-8afb-4202-874f-fda941e6c149","commitTimeStamp":"2017-08-15T05:57:34.8747378Z","count":544},{"@id":"https://api.nuget.org/v3/catalog0/page2676.json","@type":"CatalogPage","commitId":"0aeb5f95-65a6-403c-bc11-185e53247681","commitTimeStamp":"2017-08-15T12:53:23.4351841Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2677.json","@type":"CatalogPage","commitId":"7f78513a-ab6e-4662-862a-c10854633f04","commitTimeStamp":"2017-08-15T16:15:39.0266817Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2678.json","@type":"CatalogPage","commitId":"01f1b011-6eda-4d71-afdd-a56e31d9e634","commitTimeStamp":"2017-08-15T22:13:48.009109Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2679.json","@type":"CatalogPage","commitId":"3f266a9c-d72d-4f6e-bd40-64e0b8f0af83","commitTimeStamp":"2017-08-16T07:31:21.535025Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2680.json","@type":"CatalogPage","commitId":"18ac3335-5308-4f44-a2f1-b10c1eb09ad0","commitTimeStamp":"2017-08-16T12:35:59.6234521Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2681.json","@type":"CatalogPage","commitId":"694e345a-80d3-4703-b9f6-26aad095ac70","commitTimeStamp":"2017-08-16T17:18:21.6043691Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2682.json","@type":"CatalogPage","commitId":"2fb59a69-ed7e-4efd-bd51-40b11775225b","commitTimeStamp":"2017-08-17T00:46:14.4073793Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2683.json","@type":"CatalogPage","commitId":"c7b0ffa7-7b71-4036-a0cb-7d650809b06b","commitTimeStamp":"2017-08-17T08:39:46.4828199Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page2684.json","@type":"CatalogPage","commitId":"e9e06e9e-479a-4c4f-8056-3b4024b7bc18","commitTimeStamp":"2017-08-17T16:02:45.863197Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2685.json","@type":"CatalogPage","commitId":"bb44f8ee-4fb6-476b-82fd-b0d6fbdb8b3a","commitTimeStamp":"2017-08-18T03:25:03.0827019Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2686.json","@type":"CatalogPage","commitId":"8302ea8d-6918-4d4b-aace-4096d33eda63","commitTimeStamp":"2017-08-18T09:27:56.1769231Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2687.json","@type":"CatalogPage","commitId":"86261181-daf2-48c8-8f03-54aa14eb22e9","commitTimeStamp":"2017-08-18T15:34:30.5267005Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2688.json","@type":"CatalogPage","commitId":"7d83bc52-2985-4503-b22f-a00c2a9c87de","commitTimeStamp":"2017-08-19T05:43:35.5575178Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2689.json","@type":"CatalogPage","commitId":"1afc86b4-69c2-459b-8bce-f3d336ee662e","commitTimeStamp":"2017-08-19T09:06:10.1565286Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2690.json","@type":"CatalogPage","commitId":"3a4f7d33-6703-4b3b-a167-816e3447aa15","commitTimeStamp":"2017-08-19T10:58:54.3439609Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2691.json","@type":"CatalogPage","commitId":"bb2e792d-3101-4718-bd07-15b97271ca9b","commitTimeStamp":"2017-08-19T12:47:13.2318139Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2692.json","@type":"CatalogPage","commitId":"3efed500-0f38-48fd-9281-c9c8b5ee7eec","commitTimeStamp":"2017-08-19T14:34:15.7888069Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2693.json","@type":"CatalogPage","commitId":"08883a32-149e-4b7e-8259-286ca51a5d1f","commitTimeStamp":"2017-08-19T16:59:00.3058914Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2694.json","@type":"CatalogPage","commitId":"e46830ee-e8fc-4120-b9a4-287d1797f701","commitTimeStamp":"2017-08-20T11:08:28.397938Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2695.json","@type":"CatalogPage","commitId":"72f68514-1315-4524-864e-33bfbbab340f","commitTimeStamp":"2017-08-20T23:21:48.7247833Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2696.json","@type":"CatalogPage","commitId":"b9681649-3b4d-4ed0-bacc-45a5e93eec62","commitTimeStamp":"2017-08-21T08:41:53.4744666Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2697.json","@type":"CatalogPage","commitId":"6a3099a3-c1f4-498e-a8ce-b2df85a81e71","commitTimeStamp":"2017-08-21T15:03:46.2397799Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2698.json","@type":"CatalogPage","commitId":"75b7a9cf-bebf-480a-bd0f-cba5f0d4a740","commitTimeStamp":"2017-08-21T16:02:31.2032541Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2699.json","@type":"CatalogPage","commitId":"7e49ded4-b606-462a-8ecb-4656474d24da","commitTimeStamp":"2017-08-21T16:20:24.0925433Z","count":535},{"@id":"https://api.nuget.org/v3/catalog0/page2700.json","@type":"CatalogPage","commitId":"9f8882f9-daa4-4b00-88aa-b5e0dadc859a","commitTimeStamp":"2017-08-21T16:34:08.0663638Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2701.json","@type":"CatalogPage","commitId":"8799d1c8-e186-4d29-bc4c-32840914fb12","commitTimeStamp":"2017-08-21T17:10:17.3928397Z","count":541},{"@id":"https://api.nuget.org/v3/catalog0/page2702.json","@type":"CatalogPage","commitId":"4188da9b-984b-4491-9494-e55c78081771","commitTimeStamp":"2017-08-21T17:26:26.9476687Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2703.json","@type":"CatalogPage","commitId":"ad7e523b-5068-4e37-a32f-f7b5d510171f","commitTimeStamp":"2017-08-21T17:50:15.1998977Z","count":541},{"@id":"https://api.nuget.org/v3/catalog0/page2704.json","@type":"CatalogPage","commitId":"106ebb6f-1749-4b3e-8d23-f7e1e56a93dc","commitTimeStamp":"2017-08-21T18:06:05.4663021Z","count":543},{"@id":"https://api.nuget.org/v3/catalog0/page2705.json","@type":"CatalogPage","commitId":"6fb00dea-909c-43bd-94f7-433202958ed3","commitTimeStamp":"2017-08-21T18:19:52.4511899Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2706.json","@type":"CatalogPage","commitId":"0aafb3df-a4ed-4e4f-81d9-f37151b6f37e","commitTimeStamp":"2017-08-21T18:34:58.9321989Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page2707.json","@type":"CatalogPage","commitId":"6d43e83a-7c1f-4374-9c86-e75e04de2c14","commitTimeStamp":"2017-08-21T18:49:24.8136562Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2708.json","@type":"CatalogPage","commitId":"0d4496be-771b-4d1a-8236-df031d5c0e67","commitTimeStamp":"2017-08-21T19:03:46.5186704Z","count":542},{"@id":"https://api.nuget.org/v3/catalog0/page2709.json","@type":"CatalogPage","commitId":"55f64d36-4f1f-4fd3-bdcd-e57ff41464c5","commitTimeStamp":"2017-08-22T00:50:40.7044609Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2710.json","@type":"CatalogPage","commitId":"8cb50c46-ce68-45cb-a2f3-a0cb649d007d","commitTimeStamp":"2017-08-22T07:43:22.3458292Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2711.json","@type":"CatalogPage","commitId":"7b31e7ee-25bf-43d5-85a5-092ad450475d","commitTimeStamp":"2017-08-22T11:44:04.8967466Z","count":542},{"@id":"https://api.nuget.org/v3/catalog0/page2712.json","@type":"CatalogPage","commitId":"e556f904-f592-4e72-82ed-37be06130d45","commitTimeStamp":"2017-08-22T12:03:03.334657Z","count":544},{"@id":"https://api.nuget.org/v3/catalog0/page2713.json","@type":"CatalogPage","commitId":"1fdfa113-254c-4f3a-9a48-d4bd81fc02ea","commitTimeStamp":"2017-08-22T12:37:14.4119844Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2714.json","@type":"CatalogPage","commitId":"fbe06252-db1a-4a3a-b516-7e0ff2902ee4","commitTimeStamp":"2017-08-22T14:14:05.7786755Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2715.json","@type":"CatalogPage","commitId":"a199eb65-23c9-4a45-b7b1-f9649b9c4a0d","commitTimeStamp":"2017-08-22T22:33:23.120293Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2716.json","@type":"CatalogPage","commitId":"d59f6941-3241-4d0c-8d00-afb2b53eefd7","commitTimeStamp":"2017-08-23T08:43:47.2338578Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2717.json","@type":"CatalogPage","commitId":"2d5f1d40-6887-4072-982f-89bff8489144","commitTimeStamp":"2017-08-23T14:48:01.6959036Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2718.json","@type":"CatalogPage","commitId":"1b939368-d8cf-4140-99f8-88f9bc22b436","commitTimeStamp":"2017-08-23T21:11:10.899057Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2719.json","@type":"CatalogPage","commitId":"d4330edf-7c23-45c7-8b04-8cab8f92bbba","commitTimeStamp":"2017-08-24T07:55:20.4685777Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2720.json","@type":"CatalogPage","commitId":"978f14e2-46a5-4385-943f-150e7cbb401f","commitTimeStamp":"2017-08-24T14:17:23.8474643Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2721.json","@type":"CatalogPage","commitId":"ef821231-fde1-4c54-a1da-800ca7938160","commitTimeStamp":"2017-08-24T19:58:26.4907274Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2722.json","@type":"CatalogPage","commitId":"d5c2a7b2-b0fd-46e4-aa61-2ff4f18cf1e1","commitTimeStamp":"2017-08-25T08:09:08.2382054Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2723.json","@type":"CatalogPage","commitId":"1aefc3f8-475a-4964-a837-c32e596f6719","commitTimeStamp":"2017-08-25T14:53:23.4027168Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2724.json","@type":"CatalogPage","commitId":"1b1f2ca7-923e-457f-8a29-70752c332a46","commitTimeStamp":"2017-08-26T01:12:23.499556Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2725.json","@type":"CatalogPage","commitId":"1d7ccf25-a69d-4cc6-9d88-453daa90583c","commitTimeStamp":"2017-08-26T21:08:25.6704417Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page2726.json","@type":"CatalogPage","commitId":"dbcbe59f-73be-4f61-8bd6-393669d08fcb","commitTimeStamp":"2017-08-27T11:54:20.8690039Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2727.json","@type":"CatalogPage","commitId":"01f14923-9782-4907-95cc-07fb1562d436","commitTimeStamp":"2017-08-27T15:59:43.7554034Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2728.json","@type":"CatalogPage","commitId":"ee6dd92e-a4a4-4a8d-b784-25ae0bc6de0e","commitTimeStamp":"2017-08-28T07:56:08.6737768Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2729.json","@type":"CatalogPage","commitId":"5d77f7ef-bb56-49c8-9d0b-070a878c7ed9","commitTimeStamp":"2017-08-28T16:18:15.8597112Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2730.json","@type":"CatalogPage","commitId":"b72d2bb2-0b21-4794-a37f-4e3170db564d","commitTimeStamp":"2017-08-28T21:37:10.7133317Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2731.json","@type":"CatalogPage","commitId":"847216e3-0618-49a2-9143-c4e87543c276","commitTimeStamp":"2017-08-29T08:16:26.8094489Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2732.json","@type":"CatalogPage","commitId":"48dc8961-8679-4f04-a65a-fd5e057efdad","commitTimeStamp":"2017-08-29T13:08:21.0597153Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2733.json","@type":"CatalogPage","commitId":"2d5b2c77-412d-4d44-b051-f647bf3feb2c","commitTimeStamp":"2017-08-29T20:13:12.9252731Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2734.json","@type":"CatalogPage","commitId":"9e56d404-c002-40ae-bd48-abad6507eb4b","commitTimeStamp":"2017-08-30T05:35:06.4307852Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2735.json","@type":"CatalogPage","commitId":"3df5cb1c-88ce-419b-82dd-daf7c43b3ac8","commitTimeStamp":"2017-08-30T12:03:18.9085728Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2736.json","@type":"CatalogPage","commitId":"14d4a73b-f3c5-4687-b7b3-3be85732922a","commitTimeStamp":"2017-08-30T14:02:14.6081827Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2737.json","@type":"CatalogPage","commitId":"751c2fa7-90b5-4e84-a0d3-8009e067ac4d","commitTimeStamp":"2017-08-30T18:14:34.0000917Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2738.json","@type":"CatalogPage","commitId":"b5ec5d21-91fe-4ead-bf7d-ad4062c68684","commitTimeStamp":"2017-08-30T22:59:53.606819Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2739.json","@type":"CatalogPage","commitId":"78b62ec2-83d2-4b76-9e5a-a4ea491369e1","commitTimeStamp":"2017-08-31T07:12:44.6417772Z","count":541},{"@id":"https://api.nuget.org/v3/catalog0/page2740.json","@type":"CatalogPage","commitId":"51a096f9-e934-484f-b576-df0ef0303dd2","commitTimeStamp":"2017-08-31T13:01:11.2513139Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2741.json","@type":"CatalogPage","commitId":"f66f0cee-32a9-4904-8bd4-8b9afc855c63","commitTimeStamp":"2017-08-31T19:30:24.7638595Z","count":536},{"@id":"https://api.nuget.org/v3/catalog0/page2742.json","@type":"CatalogPage","commitId":"f14e7734-56de-4041-91d6-6195d5001196","commitTimeStamp":"2017-09-01T07:02:26.704155Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2743.json","@type":"CatalogPage","commitId":"0a26133c-b81e-4fa3-9ce1-b45b4272260b","commitTimeStamp":"2017-09-01T10:01:46.6804896Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2744.json","@type":"CatalogPage","commitId":"49a3ed07-d4ae-45c6-9090-dbdf037818fd","commitTimeStamp":"2017-09-01T14:52:15.2600425Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2745.json","@type":"CatalogPage","commitId":"8af5a315-c766-44bf-82b7-c98682ac5584","commitTimeStamp":"2017-09-02T03:17:18.9756612Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2746.json","@type":"CatalogPage","commitId":"a4328f2a-d0f9-45d8-ba56-495b1c252d41","commitTimeStamp":"2017-09-02T22:38:25.6259565Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2747.json","@type":"CatalogPage","commitId":"9b0ec374-1cb4-4247-84c7-d6087ffd1981","commitTimeStamp":"2017-09-03T19:21:01.1095955Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2748.json","@type":"CatalogPage","commitId":"9530505a-4e90-4cec-a3e7-eeee056fc94b","commitTimeStamp":"2017-09-04T08:51:56.9371065Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2749.json","@type":"CatalogPage","commitId":"3d3ed194-030a-4fa3-87dd-17e42e079f96","commitTimeStamp":"2017-09-04T15:20:12.7254112Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2750.json","@type":"CatalogPage","commitId":"3820ab7c-b62f-464a-b065-b3b5ce80eb6b","commitTimeStamp":"2017-09-04T20:50:16.1309936Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2751.json","@type":"CatalogPage","commitId":"5587968c-f399-4790-a5c1-014657e79324","commitTimeStamp":"2017-09-05T06:11:46.4689918Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2752.json","@type":"CatalogPage","commitId":"54240501-e10c-4409-8369-d69ca91cfb48","commitTimeStamp":"2017-09-05T11:54:23.7643979Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2753.json","@type":"CatalogPage","commitId":"7d4685c0-34de-4574-82eb-3c6a866cd83e","commitTimeStamp":"2017-09-05T16:30:48.1949774Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2754.json","@type":"CatalogPage","commitId":"f982d849-5d1d-48e9-88f8-d4213ade07bd","commitTimeStamp":"2017-09-06T00:56:07.3773317Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2755.json","@type":"CatalogPage","commitId":"12993951-78b8-428c-854a-8c6a9bc511b4","commitTimeStamp":"2017-09-06T07:10:58.6527142Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page2756.json","@type":"CatalogPage","commitId":"2ca80fec-d143-466b-868e-63ae62aa5058","commitTimeStamp":"2017-09-06T12:24:47.4390742Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2757.json","@type":"CatalogPage","commitId":"4b902635-f840-44c4-97b4-78f7740f5616","commitTimeStamp":"2017-09-06T17:27:27.6926763Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2758.json","@type":"CatalogPage","commitId":"89231ea6-dd99-4c47-af4f-27147275a785","commitTimeStamp":"2017-09-06T23:30:38.1337179Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page2759.json","@type":"CatalogPage","commitId":"674cd491-5a84-4197-b45a-d478b3640730","commitTimeStamp":"2017-09-07T06:33:07.182553Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2760.json","@type":"CatalogPage","commitId":"2aa5c910-e855-40f9-9fe5-9a63fcb124d3","commitTimeStamp":"2017-09-07T12:57:54.5471965Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2761.json","@type":"CatalogPage","commitId":"975dc65e-3a25-4370-9fdb-5cbd93b78aae","commitTimeStamp":"2017-09-07T18:44:40.9685755Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2762.json","@type":"CatalogPage","commitId":"e677c9c6-dd44-41db-84e4-2272d707a96e","commitTimeStamp":"2017-09-08T04:23:21.9257069Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2763.json","@type":"CatalogPage","commitId":"3856b6bf-5c4a-4b27-9d3d-2850d6ac2b2e","commitTimeStamp":"2017-09-08T09:47:57.6992295Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2764.json","@type":"CatalogPage","commitId":"f4970313-ece8-4df9-8119-c85a05689eaf","commitTimeStamp":"2017-09-08T13:41:42.8050141Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2765.json","@type":"CatalogPage","commitId":"ff82e6f1-0bdb-48fb-9ddd-2629baefd8ca","commitTimeStamp":"2017-09-08T20:43:38.1043191Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2766.json","@type":"CatalogPage","commitId":"41fb396e-9f91-421f-a86a-081c47f7255d","commitTimeStamp":"2017-09-08T22:39:17.476813Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2767.json","@type":"CatalogPage","commitId":"48e8e091-7681-43a8-b438-05089fb60ddc","commitTimeStamp":"2017-09-09T07:25:20.475249Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2768.json","@type":"CatalogPage","commitId":"e8dc582d-9573-4e7c-b802-675fe6020920","commitTimeStamp":"2017-09-10T00:59:20.2175089Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2769.json","@type":"CatalogPage","commitId":"c020c49c-a8e7-4ab1-ad3d-214ef3fccc45","commitTimeStamp":"2017-09-10T14:09:56.1678402Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2770.json","@type":"CatalogPage","commitId":"c11c951f-f217-423e-a374-5e096987d175","commitTimeStamp":"2017-09-11T07:08:42.9477939Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2771.json","@type":"CatalogPage","commitId":"6bb973a4-e139-454f-bb99-a84e6fa484e0","commitTimeStamp":"2017-09-11T13:57:27.0847405Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2772.json","@type":"CatalogPage","commitId":"ae99184a-725b-4515-924d-24e4c6c47924","commitTimeStamp":"2017-09-11T19:24:33.7127647Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2773.json","@type":"CatalogPage","commitId":"09486409-a28a-458a-87d4-c0769a32e313","commitTimeStamp":"2017-09-12T06:44:48.3483395Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2774.json","@type":"CatalogPage","commitId":"ff4ac1f3-5f4a-451f-9099-b23da2d7a1a5","commitTimeStamp":"2017-09-12T11:01:06.6730188Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2775.json","@type":"CatalogPage","commitId":"c3d78ea4-b398-4d69-8b7a-58470a54362c","commitTimeStamp":"2017-09-12T15:24:33.9388757Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2776.json","@type":"CatalogPage","commitId":"847fa02b-1b6f-43ce-bd1e-e5437ffb5854","commitTimeStamp":"2017-09-12T20:19:15.0007319Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2777.json","@type":"CatalogPage","commitId":"d173af9e-18b2-446d-bb35-cbddf0aca03a","commitTimeStamp":"2017-09-13T07:18:11.0087513Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2778.json","@type":"CatalogPage","commitId":"f5a2c465-fd5a-46fa-ad44-099564cad228","commitTimeStamp":"2017-09-13T08:33:19.7924018Z","count":531},{"@id":"https://api.nuget.org/v3/catalog0/page2779.json","@type":"CatalogPage","commitId":"28b6c507-d672-42b2-ae39-5e2648773b88","commitTimeStamp":"2017-09-13T09:58:07.4227323Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2780.json","@type":"CatalogPage","commitId":"3403a8eb-4412-4a39-981d-517fcbe3ea80","commitTimeStamp":"2017-09-13T11:16:56.4202506Z","count":541},{"@id":"https://api.nuget.org/v3/catalog0/page2781.json","@type":"CatalogPage","commitId":"93ebefbb-d0b0-4259-bb1f-c171ddbb0b7e","commitTimeStamp":"2017-09-13T12:44:58.6264616Z","count":541},{"@id":"https://api.nuget.org/v3/catalog0/page2782.json","@type":"CatalogPage","commitId":"d19ca6ce-5998-47d9-b629-cdc361910b6a","commitTimeStamp":"2017-09-13T14:31:44.8100879Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2783.json","@type":"CatalogPage","commitId":"eda73312-f063-41b8-8131-eb2d211deac3","commitTimeStamp":"2017-09-13T17:08:08.0442651Z","count":544},{"@id":"https://api.nuget.org/v3/catalog0/page2784.json","@type":"CatalogPage","commitId":"47ceb9cd-a95f-4d6f-a27a-b678a43450ce","commitTimeStamp":"2017-09-14T01:35:38.263954Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2785.json","@type":"CatalogPage","commitId":"79e36769-1d07-4b11-94f0-29e1df36f4ce","commitTimeStamp":"2017-09-14T11:26:34.8588115Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2786.json","@type":"CatalogPage","commitId":"9bd436e8-92b7-4e51-ab53-dad83ff56682","commitTimeStamp":"2017-09-14T18:43:14.1908333Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2787.json","@type":"CatalogPage","commitId":"dcfc1456-6691-442e-93ab-5be1c3e982b8","commitTimeStamp":"2017-09-15T00:38:04.2778064Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2788.json","@type":"CatalogPage","commitId":"265f08f5-4df7-40c2-8438-617f6e06102a","commitTimeStamp":"2017-09-15T12:32:54.2678097Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2789.json","@type":"CatalogPage","commitId":"b7643efe-a1c6-49ed-a81e-b20edec6cf5c","commitTimeStamp":"2017-09-15T19:34:16.9793018Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2790.json","@type":"CatalogPage","commitId":"e7c8d5de-c5ef-4fce-9c2c-0e52bf3eeda8","commitTimeStamp":"2017-09-16T09:57:55.474857Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2791.json","@type":"CatalogPage","commitId":"8e97d861-410c-47bc-9da8-bb909d351408","commitTimeStamp":"2017-09-17T06:52:48.0073433Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2792.json","@type":"CatalogPage","commitId":"1bc1855b-7327-4718-9e31-650745a099d6","commitTimeStamp":"2017-09-18T00:17:46.9719019Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2793.json","@type":"CatalogPage","commitId":"0e26a256-4866-4e75-a92d-43fa99f380b9","commitTimeStamp":"2017-09-18T10:43:39.7529309Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2794.json","@type":"CatalogPage","commitId":"5cae7182-d201-4f97-bba9-64bbdaf7d5c4","commitTimeStamp":"2017-09-18T15:22:06.7707397Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2795.json","@type":"CatalogPage","commitId":"e2a076b7-be68-45a4-a0d9-7f88c34e5d11","commitTimeStamp":"2017-09-18T18:38:09.1634065Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2796.json","@type":"CatalogPage","commitId":"aa403788-dbec-47e5-b952-4d49d4422479","commitTimeStamp":"2017-09-19T00:01:55.2490635Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page2797.json","@type":"CatalogPage","commitId":"4c47e9c4-7699-4d8a-9851-5e56f3fe4909","commitTimeStamp":"2017-09-19T08:55:52.558155Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2798.json","@type":"CatalogPage","commitId":"a0552057-44d1-4e3b-a958-75f63607a934","commitTimeStamp":"2017-09-19T12:59:24.7963939Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2799.json","@type":"CatalogPage","commitId":"4f3e0443-c7bc-468c-a94c-a1c4412c7280","commitTimeStamp":"2017-09-19T18:18:20.3269674Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2800.json","@type":"CatalogPage","commitId":"c67d0c2f-8ca3-4b16-9aed-5b5b8f8191ab","commitTimeStamp":"2017-09-20T04:15:02.3119643Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2801.json","@type":"CatalogPage","commitId":"5d1935b2-15ca-4515-a9f5-b0b384dd3832","commitTimeStamp":"2017-09-20T08:37:44.3908068Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2802.json","@type":"CatalogPage","commitId":"77f6b2ee-333d-4bf0-9a2b-c2b09e1edf23","commitTimeStamp":"2017-09-20T15:42:37.873333Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2803.json","@type":"CatalogPage","commitId":"a2b34baa-de89-4a62-8455-ee00b3845a28","commitTimeStamp":"2017-09-20T17:01:19.6568174Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page2804.json","@type":"CatalogPage","commitId":"128f2bdf-27ef-411d-8e86-dd9d96aea98b","commitTimeStamp":"2017-09-20T20:21:40.3268953Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2805.json","@type":"CatalogPage","commitId":"b9d2dcad-f800-4c06-a73f-d02426cbf5c2","commitTimeStamp":"2017-09-21T05:33:37.9614579Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2806.json","@type":"CatalogPage","commitId":"dd7f98b0-20d7-4d9a-b12d-a5a3f0456cf9","commitTimeStamp":"2017-09-21T09:02:07.2988947Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2807.json","@type":"CatalogPage","commitId":"c27d311b-75b1-40c6-9a53-dd8d5b201553","commitTimeStamp":"2017-09-21T15:15:45.479387Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2808.json","@type":"CatalogPage","commitId":"df62b208-8a8d-4968-b628-0ec9dc8c4f4a","commitTimeStamp":"2017-09-21T23:29:08.1730118Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page2809.json","@type":"CatalogPage","commitId":"69d3b2d3-e70c-48f7-be98-01b8ef24c018","commitTimeStamp":"2017-09-22T07:16:03.7972105Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2810.json","@type":"CatalogPage","commitId":"ec878889-ecc0-4cd6-878c-757f7cee98cb","commitTimeStamp":"2017-09-22T12:20:26.8742858Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2811.json","@type":"CatalogPage","commitId":"68143ed4-c7dc-48a9-97cd-1b8aa48db6d0","commitTimeStamp":"2017-09-22T18:53:26.6490491Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2812.json","@type":"CatalogPage","commitId":"5a3bdd06-8765-499f-a5ee-2a1d2e8b145e","commitTimeStamp":"2017-09-23T08:22:31.1056776Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2813.json","@type":"CatalogPage","commitId":"d73a10a8-075b-42c6-bbe7-0f5ba46ff333","commitTimeStamp":"2017-09-24T02:33:03.1246098Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2814.json","@type":"CatalogPage","commitId":"74ada193-ef29-48d2-84f5-1b614b8e0404","commitTimeStamp":"2017-09-24T21:50:28.7537208Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2815.json","@type":"CatalogPage","commitId":"b45cfb91-309c-4ea1-b9de-89624b4b1aa2","commitTimeStamp":"2017-09-25T01:55:19.7682325Z","count":544},{"@id":"https://api.nuget.org/v3/catalog0/page2816.json","@type":"CatalogPage","commitId":"2e124373-6df1-4b03-bc05-ca6818df1e57","commitTimeStamp":"2017-09-25T03:40:26.6758845Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2817.json","@type":"CatalogPage","commitId":"14affd79-ad83-4359-8490-1b911be9edb5","commitTimeStamp":"2017-09-25T05:32:24.2664576Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2818.json","@type":"CatalogPage","commitId":"7f6efae1-bfe3-4307-9b2b-05af95f7bebf","commitTimeStamp":"2017-09-25T07:16:42.1689805Z","count":543},{"@id":"https://api.nuget.org/v3/catalog0/page2819.json","@type":"CatalogPage","commitId":"cad8c21e-e809-4830-9462-372567eea653","commitTimeStamp":"2017-09-25T09:32:22.4106919Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2820.json","@type":"CatalogPage","commitId":"f017a92e-9282-4a56-8369-b50b30a8bf8e","commitTimeStamp":"2017-09-25T15:38:19.196076Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2821.json","@type":"CatalogPage","commitId":"294981f0-747d-4abb-a7cc-594e3e4d89fc","commitTimeStamp":"2017-09-25T21:29:21.0477409Z","count":544},{"@id":"https://api.nuget.org/v3/catalog0/page2822.json","@type":"CatalogPage","commitId":"071c2b09-105f-469a-950f-aab0a54e9110","commitTimeStamp":"2017-09-26T07:08:36.3544262Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2823.json","@type":"CatalogPage","commitId":"d6526a20-649e-4fed-af9a-fe502bec8e38","commitTimeStamp":"2017-09-26T11:59:46.154692Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2824.json","@type":"CatalogPage","commitId":"e89b39ca-10ef-47c8-9569-93342289cef1","commitTimeStamp":"2017-09-26T17:51:48.8938858Z","count":541},{"@id":"https://api.nuget.org/v3/catalog0/page2825.json","@type":"CatalogPage","commitId":"b770a439-786e-4a00-bc1b-3701bfc24173","commitTimeStamp":"2017-09-27T02:13:58.319864Z","count":541},{"@id":"https://api.nuget.org/v3/catalog0/page2826.json","@type":"CatalogPage","commitId":"a1ef9679-36aa-4669-aab6-5f7253fb6a1b","commitTimeStamp":"2017-09-27T11:35:12.3264517Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2827.json","@type":"CatalogPage","commitId":"4092eb9d-bed1-4618-9f7a-e717c3407e04","commitTimeStamp":"2017-09-27T15:27:36.9496135Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2828.json","@type":"CatalogPage","commitId":"e06b8e2e-683a-4dc9-a7ca-88410977dc6a","commitTimeStamp":"2017-09-27T23:41:02.4534321Z","count":536},{"@id":"https://api.nuget.org/v3/catalog0/page2829.json","@type":"CatalogPage","commitId":"673697e5-6e26-4e15-99de-051cae2176e7","commitTimeStamp":"2017-09-28T10:39:58.0818909Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2830.json","@type":"CatalogPage","commitId":"67db116c-4f25-4dc1-86b1-a74334d76af4","commitTimeStamp":"2017-09-28T17:36:13.1688267Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2831.json","@type":"CatalogPage","commitId":"e066fcd5-27ad-4614-93a5-39c4f99ec857","commitTimeStamp":"2017-09-29T03:55:32.4428146Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2832.json","@type":"CatalogPage","commitId":"05b3356e-b758-4dcc-a2a4-759cb291a69d","commitTimeStamp":"2017-09-29T12:48:22.4214061Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2833.json","@type":"CatalogPage","commitId":"275fad36-c35b-4e8a-9b6e-1d224d2c658a","commitTimeStamp":"2017-09-29T20:27:23.7548241Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2834.json","@type":"CatalogPage","commitId":"beb4b7b6-711d-46a2-9268-223405c1dde9","commitTimeStamp":"2017-09-30T14:03:05.6347662Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page2835.json","@type":"CatalogPage","commitId":"5f98d66b-beab-4757-b3dc-89bb8cd10329","commitTimeStamp":"2017-10-01T12:30:32.9621669Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2836.json","@type":"CatalogPage","commitId":"f50f2ad5-dd56-440e-b122-a2327255e36d","commitTimeStamp":"2017-10-01T22:05:37.6729553Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2837.json","@type":"CatalogPage","commitId":"6dbb244a-040d-4390-9f27-4d4c94a7e7af","commitTimeStamp":"2017-10-02T04:38:18.923159Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2838.json","@type":"CatalogPage","commitId":"676953ec-642f-4d83-8179-5fe0544ccd0b","commitTimeStamp":"2017-10-02T12:49:29.4081055Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2839.json","@type":"CatalogPage","commitId":"0e6f8b6d-a1b4-456f-8ace-a9f4282a8730","commitTimeStamp":"2017-10-02T17:31:45.6153636Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2840.json","@type":"CatalogPage","commitId":"851c853c-a4bc-489b-9196-fca2e4b007ec","commitTimeStamp":"2017-10-03T02:50:08.3179412Z","count":543},{"@id":"https://api.nuget.org/v3/catalog0/page2841.json","@type":"CatalogPage","commitId":"2de35907-ec15-4fb7-914f-30e6c09e0651","commitTimeStamp":"2017-10-03T09:25:37.945236Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2842.json","@type":"CatalogPage","commitId":"b4a4c4e1-e8b8-4219-b253-4722236375e3","commitTimeStamp":"2017-10-03T14:41:11.9050932Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2843.json","@type":"CatalogPage","commitId":"4690cec8-5464-4dee-b9c7-e1d726437dc0","commitTimeStamp":"2017-10-03T20:33:19.3904452Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2844.json","@type":"CatalogPage","commitId":"a2c0cb5b-a0c1-4fe1-9afe-82c6bb99a5b5","commitTimeStamp":"2017-10-04T01:20:47.9971568Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2845.json","@type":"CatalogPage","commitId":"6f8d713a-becf-436d-9184-73a3023182fd","commitTimeStamp":"2017-10-04T08:08:46.7307347Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2846.json","@type":"CatalogPage","commitId":"448405f0-5a97-46c0-8a9c-b8ffa957ab77","commitTimeStamp":"2017-10-04T14:38:43.7513368Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2847.json","@type":"CatalogPage","commitId":"ce7c3cfa-ddfa-4662-804b-45526a76aa76","commitTimeStamp":"2017-10-04T18:28:03.054163Z","count":543},{"@id":"https://api.nuget.org/v3/catalog0/page2848.json","@type":"CatalogPage","commitId":"2bcde4ee-5a19-43e0-8104-340fcd335b20","commitTimeStamp":"2017-10-05T00:58:03.2239527Z","count":542},{"@id":"https://api.nuget.org/v3/catalog0/page2849.json","@type":"CatalogPage","commitId":"4f54a5fe-90b7-499a-8e3e-28ed5ac6eb9d","commitTimeStamp":"2017-10-05T08:32:39.6727744Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2850.json","@type":"CatalogPage","commitId":"c2af4348-e5f3-4c0d-8927-d4a6800cb40c","commitTimeStamp":"2017-10-05T15:24:34.632818Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2851.json","@type":"CatalogPage","commitId":"ca5fd6fe-cf4b-4cf1-9b28-f30ba7bb7910","commitTimeStamp":"2017-10-05T23:31:44.5199142Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2852.json","@type":"CatalogPage","commitId":"94101a07-0c99-48cd-ab47-bb54334120af","commitTimeStamp":"2017-10-06T09:01:13.4788131Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2853.json","@type":"CatalogPage","commitId":"8d4766b4-6c44-4e76-885f-94536deb5b0a","commitTimeStamp":"2017-10-06T14:56:42.6192901Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2854.json","@type":"CatalogPage","commitId":"aa2f6e10-4a66-4622-9c46-4d85b05d8b4e","commitTimeStamp":"2017-10-06T20:21:02.9639998Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2855.json","@type":"CatalogPage","commitId":"8d20c96c-e9fa-448a-a04c-cb6db3207ed3","commitTimeStamp":"2017-10-07T09:30:38.169338Z","count":539},{"@id":"https://api.nuget.org/v3/catalog0/page2856.json","@type":"CatalogPage","commitId":"fa482e38-2bb5-4b1c-b666-4fde443e7f98","commitTimeStamp":"2017-10-07T22:21:26.0885373Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2857.json","@type":"CatalogPage","commitId":"60f6e2ff-a868-4155-8705-0b316f9f436f","commitTimeStamp":"2017-10-08T15:15:42.319325Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2858.json","@type":"CatalogPage","commitId":"fb15f5bd-fa7e-453e-ae8a-0ca3f655b406","commitTimeStamp":"2017-10-09T06:13:21.923978Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2859.json","@type":"CatalogPage","commitId":"49a2cc98-11e0-495b-8dd3-6668af04ee93","commitTimeStamp":"2017-10-09T13:21:57.8268162Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2860.json","@type":"CatalogPage","commitId":"362e8e60-c13c-4035-9b60-9bd687d38470","commitTimeStamp":"2017-10-09T19:11:33.0958453Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2861.json","@type":"CatalogPage","commitId":"fb7242a4-02e8-4229-9329-5b086b1248a4","commitTimeStamp":"2017-10-10T07:11:00.5746156Z","count":543},{"@id":"https://api.nuget.org/v3/catalog0/page2862.json","@type":"CatalogPage","commitId":"2a40631b-743e-4790-bf51-20ba5a567d46","commitTimeStamp":"2017-10-10T13:24:52.7470596Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2863.json","@type":"CatalogPage","commitId":"02a3272a-4467-40ec-a716-6d90a12ce92e","commitTimeStamp":"2017-10-10T18:14:55.8199019Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2864.json","@type":"CatalogPage","commitId":"39257a59-a94d-4cff-803f-4bd5b773a193","commitTimeStamp":"2017-10-11T00:51:02.4765391Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2865.json","@type":"CatalogPage","commitId":"40d1f0bc-5e59-4efe-9190-b305d6e76c42","commitTimeStamp":"2017-10-11T08:46:10.1786927Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2866.json","@type":"CatalogPage","commitId":"c7cdc44f-36ea-46ab-a9ac-28297e4cf548","commitTimeStamp":"2017-10-11T14:35:20.8798762Z","count":543},{"@id":"https://api.nuget.org/v3/catalog0/page2867.json","@type":"CatalogPage","commitId":"21aacb98-8043-447d-95e7-b7b71d2c4fc5","commitTimeStamp":"2017-10-11T20:33:12.2621679Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2868.json","@type":"CatalogPage","commitId":"2f45fb29-6e20-471c-a49f-604fb1b8e8aa","commitTimeStamp":"2017-10-12T10:19:18.6288779Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2869.json","@type":"CatalogPage","commitId":"79efc0e3-e774-46f7-81bd-bb0f465f2d07","commitTimeStamp":"2017-10-12T16:47:13.8214956Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2870.json","@type":"CatalogPage","commitId":"44f41c8c-4046-43ef-9bd4-400339031dac","commitTimeStamp":"2017-10-12T20:49:42.561161Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page2871.json","@type":"CatalogPage","commitId":"99f77248-da21-43f5-a6d4-7fa68888e356","commitTimeStamp":"2017-10-13T05:55:22.831741Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2872.json","@type":"CatalogPage","commitId":"f7d1fbbc-58e0-46a8-bd69-e7891b312957","commitTimeStamp":"2017-10-13T11:14:22.3510522Z","count":544},{"@id":"https://api.nuget.org/v3/catalog0/page2873.json","@type":"CatalogPage","commitId":"4a3e8ab7-5591-4fac-ab78-abddbfd30cfb","commitTimeStamp":"2017-10-13T14:54:20.5715162Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2874.json","@type":"CatalogPage","commitId":"34f6089e-3f25-4237-8761-5944ce0db56c","commitTimeStamp":"2017-10-13T22:55:21.2179505Z","count":542},{"@id":"https://api.nuget.org/v3/catalog0/page2875.json","@type":"CatalogPage","commitId":"87ecbc7e-64ee-4910-873e-159772c6c1c3","commitTimeStamp":"2017-10-14T17:40:06.4388966Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2876.json","@type":"CatalogPage","commitId":"d499b29a-c492-4cfb-8139-db33e10bd1c5","commitTimeStamp":"2017-10-15T18:12:17.2610952Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2877.json","@type":"CatalogPage","commitId":"e2f23589-1e23-4022-b76d-838627b73fa8","commitTimeStamp":"2017-10-16T05:16:10.118176Z","count":543},{"@id":"https://api.nuget.org/v3/catalog0/page2878.json","@type":"CatalogPage","commitId":"2b4fc091-1780-47e7-8d00-cab8da49b44e","commitTimeStamp":"2017-10-16T11:46:42.1279304Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2879.json","@type":"CatalogPage","commitId":"f6c3644b-21bb-4d94-aa38-d61f19538bfa","commitTimeStamp":"2017-10-16T18:07:23.8263497Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2880.json","@type":"CatalogPage","commitId":"b5a332b5-e2d1-457f-bab5-4b835300dde1","commitTimeStamp":"2017-10-17T05:38:35.9098609Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2881.json","@type":"CatalogPage","commitId":"475daf60-bfa4-4d2d-b97e-999eb7f7686a","commitTimeStamp":"2017-10-17T12:07:55.4459449Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2882.json","@type":"CatalogPage","commitId":"74ebbb83-7c8b-4281-b07f-bbd56dcd89b7","commitTimeStamp":"2017-10-17T17:26:13.5189869Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2883.json","@type":"CatalogPage","commitId":"d61ee9ec-4dab-4d3d-b356-28cafdca23cf","commitTimeStamp":"2017-10-17T22:53:45.3384631Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page2884.json","@type":"CatalogPage","commitId":"deed69b1-8a5e-4de4-9aad-a92a5df7270f","commitTimeStamp":"2017-10-18T08:14:00.7659959Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2885.json","@type":"CatalogPage","commitId":"1d9aa8c5-b223-4cbe-bad6-924ca40a89c5","commitTimeStamp":"2017-10-18T12:18:48.2122326Z","count":536},{"@id":"https://api.nuget.org/v3/catalog0/page2886.json","@type":"CatalogPage","commitId":"3f9b47d4-0642-41c6-968f-ffb6ae07123f","commitTimeStamp":"2017-10-18T16:48:05.15643Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page2887.json","@type":"CatalogPage","commitId":"c23b6c69-5468-4a9d-962e-22cd53cf18f6","commitTimeStamp":"2017-10-18T23:25:33.5578212Z","count":542},{"@id":"https://api.nuget.org/v3/catalog0/page2888.json","@type":"CatalogPage","commitId":"341f16ae-aff4-4340-885b-4615af44bed3","commitTimeStamp":"2017-10-19T08:41:59.3433858Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2889.json","@type":"CatalogPage","commitId":"4c35684e-aa37-4a15-890a-fbfa5742b449","commitTimeStamp":"2017-10-19T15:30:38.8959092Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2890.json","@type":"CatalogPage","commitId":"6962b4b2-e5e4-4cad-9aac-7364ec0ebe03","commitTimeStamp":"2017-10-19T22:34:03.0603566Z","count":541},{"@id":"https://api.nuget.org/v3/catalog0/page2891.json","@type":"CatalogPage","commitId":"28add5fa-e830-4a09-b73f-f43534f5f23c","commitTimeStamp":"2017-10-20T07:59:20.7774948Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2892.json","@type":"CatalogPage","commitId":"0f599242-0330-4e9c-9af2-d9a06baec2cd","commitTimeStamp":"2017-10-20T14:12:36.4406004Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2893.json","@type":"CatalogPage","commitId":"81f5d5d2-60e8-4566-a8ca-48df0b382d28","commitTimeStamp":"2017-10-20T21:37:12.9855985Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2894.json","@type":"CatalogPage","commitId":"acb98442-f126-4379-a078-2cfe60d5ed59","commitTimeStamp":"2017-10-21T11:31:59.2095716Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2895.json","@type":"CatalogPage","commitId":"02da78ec-ca1e-4583-afb7-82f539ff9ffe","commitTimeStamp":"2017-10-22T08:14:41.3831163Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2896.json","@type":"CatalogPage","commitId":"a0720b78-f1ff-41bc-a9e6-e5f1548cf13c","commitTimeStamp":"2017-10-23T00:35:54.3321076Z","count":544},{"@id":"https://api.nuget.org/v3/catalog0/page2897.json","@type":"CatalogPage","commitId":"c432e1f5-fbc7-4cc6-b002-d7487aa8032d","commitTimeStamp":"2017-10-23T08:38:51.7095095Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2898.json","@type":"CatalogPage","commitId":"a1489ea1-a619-4881-95f7-7b12e470e1d4","commitTimeStamp":"2017-10-23T14:27:46.8399722Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2899.json","@type":"CatalogPage","commitId":"ab47ec6a-d83e-4a80-bbdb-af4454d2f99d","commitTimeStamp":"2017-10-23T20:23:13.6972185Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2900.json","@type":"CatalogPage","commitId":"4c86fbdc-8831-475c-8997-636eb7c28ff3","commitTimeStamp":"2017-10-24T01:27:57.1718777Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2901.json","@type":"CatalogPage","commitId":"d66d7ff3-3638-47a3-98f9-018dc8d50976","commitTimeStamp":"2017-10-24T07:26:15.7982225Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2902.json","@type":"CatalogPage","commitId":"31f998a0-736a-47a6-8807-04022df2d6a3","commitTimeStamp":"2017-10-24T14:07:23.9664852Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2903.json","@type":"CatalogPage","commitId":"a11396d1-e1c3-4f26-bb43-3bd7b5b4ccbe","commitTimeStamp":"2017-10-24T18:57:53.769667Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2904.json","@type":"CatalogPage","commitId":"8d47425f-742a-4704-9f62-4938f3269e9b","commitTimeStamp":"2017-10-25T03:59:20.0030645Z","count":542},{"@id":"https://api.nuget.org/v3/catalog0/page2905.json","@type":"CatalogPage","commitId":"071087e0-50cf-49b7-b65b-b1009bf91eb8","commitTimeStamp":"2017-10-25T10:06:23.5654476Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2906.json","@type":"CatalogPage","commitId":"041a0f2b-20cb-4b09-95b4-dd90fe060a5d","commitTimeStamp":"2017-10-25T14:41:26.3711337Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2907.json","@type":"CatalogPage","commitId":"bcf58161-eec8-4213-907e-1f2b9a5ecc79","commitTimeStamp":"2017-10-25T20:58:36.7353216Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2908.json","@type":"CatalogPage","commitId":"c3a9e519-7c62-456f-9ce7-4c0d7dc8cc1d","commitTimeStamp":"2017-10-26T08:42:42.8585347Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2909.json","@type":"CatalogPage","commitId":"a0ae6994-e68f-4647-b019-2c1ee6098243","commitTimeStamp":"2017-10-26T12:59:25.7197605Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2910.json","@type":"CatalogPage","commitId":"46380553-d6c6-4032-a801-0bae46bd7f3a","commitTimeStamp":"2017-10-26T16:59:22.5347518Z","count":542},{"@id":"https://api.nuget.org/v3/catalog0/page2911.json","@type":"CatalogPage","commitId":"e51d143d-20d7-40f7-a9fb-1862fb88b766","commitTimeStamp":"2017-10-26T23:19:56.3376766Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2912.json","@type":"CatalogPage","commitId":"77f013af-099a-4759-a457-e3a3e1adcbf0","commitTimeStamp":"2017-10-27T07:01:25.3352543Z","count":543},{"@id":"https://api.nuget.org/v3/catalog0/page2913.json","@type":"CatalogPage","commitId":"2765437a-b4e9-403f-800c-8adceff1dc57","commitTimeStamp":"2017-10-27T15:27:16.8725509Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2914.json","@type":"CatalogPage","commitId":"6addab96-2f95-4193-be85-a42b4a70c90d","commitTimeStamp":"2017-10-27T22:16:41.2904957Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2915.json","@type":"CatalogPage","commitId":"8621e4d4-a088-41dd-ad3a-0909095a9661","commitTimeStamp":"2017-10-28T18:19:10.0435684Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2916.json","@type":"CatalogPage","commitId":"7d1fff22-ae11-40d0-bec7-97366ae0928a","commitTimeStamp":"2017-10-29T08:50:20.4625234Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2917.json","@type":"CatalogPage","commitId":"521f6c48-ca95-4b3a-acf3-802aa67a03cc","commitTimeStamp":"2017-10-30T01:23:35.4445284Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2918.json","@type":"CatalogPage","commitId":"a6697af4-0054-4246-bc06-014a01460bbf","commitTimeStamp":"2017-10-30T08:47:36.4873999Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2919.json","@type":"CatalogPage","commitId":"f00e9f0f-3177-4fd5-bdec-e03b2b69bf2b","commitTimeStamp":"2017-10-30T13:25:22.635908Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2920.json","@type":"CatalogPage","commitId":"1321525a-7bee-4ee8-87a1-d1a193a92856","commitTimeStamp":"2017-10-30T17:27:55.1832099Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2921.json","@type":"CatalogPage","commitId":"86932e54-2360-4c69-b8d2-7da6f40983e1","commitTimeStamp":"2017-10-30T23:31:39.6747952Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2922.json","@type":"CatalogPage","commitId":"cc635227-1227-49f8-8e4b-48594aa836ea","commitTimeStamp":"2017-10-31T09:13:33.2502916Z","count":546},{"@id":"https://api.nuget.org/v3/catalog0/page2923.json","@type":"CatalogPage","commitId":"70383469-ef7b-43c1-a043-dbc9ae1247aa","commitTimeStamp":"2017-10-31T12:45:14.4086205Z","count":547},{"@id":"https://api.nuget.org/v3/catalog0/page2924.json","@type":"CatalogPage","commitId":"fcc0e991-b2a2-4b96-b466-630a5c6bfd80","commitTimeStamp":"2017-10-31T16:11:05.4189798Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2925.json","@type":"CatalogPage","commitId":"3ad0301d-f5f3-40e4-a5e3-b93d7e1f73a8","commitTimeStamp":"2017-10-31T22:08:31.3799214Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2926.json","@type":"CatalogPage","commitId":"b94fe609-3598-4a2f-93d5-dae5c5ba3516","commitTimeStamp":"2017-11-01T06:34:17.3578611Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2927.json","@type":"CatalogPage","commitId":"73757577-8b18-4852-95f9-e10965d4fb57","commitTimeStamp":"2017-11-01T07:10:01.5979547Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page2928.json","@type":"CatalogPage","commitId":"cd47de1b-be48-4887-8c2c-7e8faf1b3d5a","commitTimeStamp":"2017-11-01T12:35:49.8375871Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2929.json","@type":"CatalogPage","commitId":"7e876a46-64bb-49df-b135-930d15eb6919","commitTimeStamp":"2017-11-01T17:03:44.2197429Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2930.json","@type":"CatalogPage","commitId":"c949a438-516b-4c82-b6ee-71979f5cb16b","commitTimeStamp":"2017-11-01T23:41:58.511788Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2931.json","@type":"CatalogPage","commitId":"d941bab5-0d0f-4670-ab77-5fd691be5c50","commitTimeStamp":"2017-11-02T07:02:22.8306219Z","count":545},{"@id":"https://api.nuget.org/v3/catalog0/page2932.json","@type":"CatalogPage","commitId":"0eeedad6-ca60-4e12-944f-9af18f15fe14","commitTimeStamp":"2017-11-02T11:21:13.183513Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2933.json","@type":"CatalogPage","commitId":"bd5a6b03-b691-4aa5-941a-4d430073cdd3","commitTimeStamp":"2017-11-02T16:13:10.1701543Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2934.json","@type":"CatalogPage","commitId":"9e658f43-d805-43b7-87fb-d710e20d6e31","commitTimeStamp":"2017-11-02T20:23:58.161543Z","count":544},{"@id":"https://api.nuget.org/v3/catalog0/page2935.json","@type":"CatalogPage","commitId":"c9963474-2d98-4f2d-a4ea-88bf0cc3d434","commitTimeStamp":"2017-11-03T04:20:32.4760307Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2936.json","@type":"CatalogPage","commitId":"112375cc-77c7-4ab7-ac34-6d3990d93d6c","commitTimeStamp":"2017-11-03T12:43:43.1367683Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2937.json","@type":"CatalogPage","commitId":"5c47519a-07d4-470d-8d14-9c9f1920ec66","commitTimeStamp":"2017-11-03T18:43:19.0789583Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2938.json","@type":"CatalogPage","commitId":"be0c75f8-05bc-456b-a597-d9a24bf710f3","commitTimeStamp":"2017-11-04T04:04:14.477004Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2939.json","@type":"CatalogPage","commitId":"883ca081-216c-4567-bce6-b8d663f62a85","commitTimeStamp":"2017-11-04T16:12:57.2557258Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2940.json","@type":"CatalogPage","commitId":"9b7e39ed-5342-4138-8e45-43d0690b75f8","commitTimeStamp":"2017-11-05T12:48:10.081492Z","count":550},{"@id":"https://api.nuget.org/v3/catalog0/page2941.json","@type":"CatalogPage","commitId":"084cff8d-7bd6-44dd-9646-6f996f97a4b7","commitTimeStamp":"2017-11-06T05:12:04.8612742Z","count":549},{"@id":"https://api.nuget.org/v3/catalog0/page2942.json","@type":"CatalogPage","commitId":"7ef6fc2e-7c3e-465a-a6f4-60aac3fe61ec","commitTimeStamp":"2017-11-06T13:07:34.4853812Z","count":548},{"@id":"https://api.nuget.org/v3/catalog0/page2943.json","@type":"CatalogPage","commitId":"ac845301-2ed7-4aa9-bba7-3c54c520419a","commitTimeStamp":"2017-11-06T18:10:27.926411Z","count":540},{"@id":"https://api.nuget.org/v3/catalog0/page2944.json","@type":"CatalogPage","commitId":"57de6c98-d4c6-4a24-95b9-1829c5013985","commitTimeStamp":"2017-11-06T19:30:56.0421411Z","count":112}],"@context":{"@vocab":"http://schema.nuget.org/catalog#","nuget":"http://schema.nuget.org/schema#","items":{"@id":"item","@container":"@set"},"parent":{"@type":"@id"},"commitTimeStamp":{"@type":"http://www.w3.org/2001/XMLSchema#dateTime"},"nuget:lastCreated":{"@type":"http://www.w3.org/2001/XMLSchema#dateTime"},"nuget:lastEdited":{"@type":"http://www.w3.org/2001/XMLSchema#dateTime"},"nuget:lastDeleted":{"@type":"http://www.w3.org/2001/XMLSchema#dateTime"}}} + + + https://api.nuget.org/v3/catalog0/index.json + + + {"@id":"https://api.nuget.org/v3/catalog0/page2944.json","@type":"CatalogPage","commitId":"f241ce46-35ba-44c2-bd72-790eb44539a5","commitTimeStamp":"2017-11-06T22:07:49.3270578Z","count":218,"parent":"https://api.nuget.org/v3/catalog0/index.json","items":[{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.22.07.49/dotnettency.container.1.3.2.json","@type":"nuget:PackageDetails","commitId":"f241ce46-35ba-44c2-bd72-790eb44539a5","commitTimeStamp":"2017-11-06T22:07:49.3270578Z","nuget:id":"Dotnettency.Container","nuget:version":"1.3.2"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.22.07.49/dotnettency.middlewarepipeline.1.3.2.json","@type":"nuget:PackageDetails","commitId":"f241ce46-35ba-44c2-bd72-790eb44539a5","commitTimeStamp":"2017-11-06T22:07:49.3270578Z","nuget:id":"Dotnettency.MiddlewarePipeline","nuget:version":"1.3.2"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.22.07.49/dotnettency.container.structuremap.1.3.2.json","@type":"nuget:PackageDetails","commitId":"f241ce46-35ba-44c2-bd72-790eb44539a5","commitTimeStamp":"2017-11-06T22:07:49.3270578Z","nuget:id":"Dotnettency.Container.StructureMap","nuget:version":"1.3.2"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.22.07.49/momentum.pm.portalapi.5.10.16-legacy.json","@type":"nuget:PackageDetails","commitId":"f241ce46-35ba-44c2-bd72-790eb44539a5","commitTimeStamp":"2017-11-06T22:07:49.3270578Z","nuget:id":"Momentum.Pm.PortalApi","nuget:version":"5.10.16-legacy"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.22.07.49/dotnettency.hostingenvironment.1.3.2.json","@type":"nuget:PackageDetails","commitId":"f241ce46-35ba-44c2-bd72-790eb44539a5","commitTimeStamp":"2017-11-06T22:07:49.3270578Z","nuget:id":"Dotnettency.HostingEnvironment","nuget:version":"1.3.2"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.22.07.49/momentum.pm.api.5.10.16-legacy.json","@type":"nuget:PackageDetails","commitId":"f241ce46-35ba-44c2-bd72-790eb44539a5","commitTimeStamp":"2017-11-06T22:07:49.3270578Z","nuget:id":"Momentum.Pm.Api","nuget:version":"5.10.16-legacy"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.22.07.49/dotnettency.1.3.2.json","@type":"nuget:PackageDetails","commitId":"f241ce46-35ba-44c2-bd72-790eb44539a5","commitTimeStamp":"2017-11-06T22:07:49.3270578Z","nuget:id":"Dotnettency","nuget:version":"1.3.2"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.22.05.31/dappermagician.1.1.3.json","@type":"nuget:PackageDetails","commitId":"e2d9d60f-14dd-435e-baf4-7050761fa1e6","commitTimeStamp":"2017-11-06T22:05:31.0971396Z","nuget:id":"DapperMagician","nuget:version":"1.1.3"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.22.05.21/dotnettency.modules.nancy.1.4.0-unstable0039.json","@type":"nuget:PackageDetails","commitId":"cfa15e2b-30c9-471d-bb05-83f94ae8bf61","commitTimeStamp":"2017-11-06T22:05:21.596839Z","nuget:id":"Dotnettency.Modules.Nancy","nuget:version":"1.4.0-unstable0039"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.22.05.11/dotnettency.hostingenvironment.1.4.0-unstable0039.json","@type":"nuget:PackageDetails","commitId":"e19d3711-20a5-478f-8694-f556f3fcbf50","commitTimeStamp":"2017-11-06T22:05:11.8934453Z","nuget:id":"Dotnettency.HostingEnvironment","nuget:version":"1.4.0-unstable0039"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.22.05.11/dotnettency.container.1.4.0-unstable0039.json","@type":"nuget:PackageDetails","commitId":"e19d3711-20a5-478f-8694-f556f3fcbf50","commitTimeStamp":"2017-11-06T22:05:11.8934453Z","nuget:id":"Dotnettency.Container","nuget:version":"1.4.0-unstable0039"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.22.05.11/inetlab.smpp.1.2.8.json","@type":"nuget:PackageDetails","commitId":"e19d3711-20a5-478f-8694-f556f3fcbf50","commitTimeStamp":"2017-11-06T22:05:11.8934453Z","nuget:id":"Inetlab.SMPP","nuget:version":"1.2.8"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.22.05.11/momentum.pm.api.5.12.200-beta.json","@type":"nuget:PackageDetails","commitId":"e19d3711-20a5-478f-8694-f556f3fcbf50","commitTimeStamp":"2017-11-06T22:05:11.8934453Z","nuget:id":"Momentum.Pm.Api","nuget:version":"5.12.200-beta"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.22.05.11/vm.tools.1.1.0.json","@type":"nuget:PackageDetails","commitId":"e19d3711-20a5-478f-8694-f556f3fcbf50","commitTimeStamp":"2017-11-06T22:05:11.8934453Z","nuget:id":"Vm.Tools","nuget:version":"1.1.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.22.05.11/dotnettency.modules.1.4.0-unstable0039.json","@type":"nuget:PackageDetails","commitId":"e19d3711-20a5-478f-8694-f556f3fcbf50","commitTimeStamp":"2017-11-06T22:05:11.8934453Z","nuget:id":"Dotnettency.Modules","nuget:version":"1.4.0-unstable0039"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.22.05.11/momentum.pm.portalapi.5.12.200-beta.json","@type":"nuget:PackageDetails","commitId":"e19d3711-20a5-478f-8694-f556f3fcbf50","commitTimeStamp":"2017-11-06T22:05:11.8934453Z","nuget:id":"Momentum.Pm.PortalApi","nuget:version":"5.12.200-beta"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.22.05.11/dotnettency.middlewarepipeline.1.4.0-unstable0039.json","@type":"nuget:PackageDetails","commitId":"e19d3711-20a5-478f-8694-f556f3fcbf50","commitTimeStamp":"2017-11-06T22:05:11.8934453Z","nuget:id":"Dotnettency.MiddlewarePipeline","nuget:version":"1.4.0-unstable0039"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.22.05.11/dotnettency.container.structuremap.1.4.0-unstable0039.json","@type":"nuget:PackageDetails","commitId":"e19d3711-20a5-478f-8694-f556f3fcbf50","commitTimeStamp":"2017-11-06T22:05:11.8934453Z","nuget:id":"Dotnettency.Container.StructureMap","nuget:version":"1.4.0-unstable0039"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.22.05.11/momentum.pm.api.5.11.108.json","@type":"nuget:PackageDetails","commitId":"e19d3711-20a5-478f-8694-f556f3fcbf50","commitTimeStamp":"2017-11-06T22:05:11.8934453Z","nuget:id":"Momentum.Pm.Api","nuget:version":"5.11.108"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.22.05.11/dotnettency.1.4.0-unstable0039.json","@type":"nuget:PackageDetails","commitId":"e19d3711-20a5-478f-8694-f556f3fcbf50","commitTimeStamp":"2017-11-06T22:05:11.8934453Z","nuget:id":"Dotnettency","nuget:version":"1.4.0-unstable0039"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.22.05.11/momentum.pm.portalapi.5.11.108.json","@type":"nuget:PackageDetails","commitId":"e19d3711-20a5-478f-8694-f556f3fcbf50","commitTimeStamp":"2017-11-06T22:05:11.8934453Z","nuget:id":"Momentum.Pm.PortalApi","nuget:version":"5.11.108"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.22.02.55/carbon.versioning.1.4.0.json","@type":"nuget:PackageDetails","commitId":"e85b23fb-793c-41e8-ad62-44fcf574e02f","commitTimeStamp":"2017-11-06T22:02:55.0609451Z","nuget:id":"Carbon.Versioning","nuget:version":"1.4.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.22.00.38/carbon.kms.0.36.1.json","@type":"nuget:PackageDetails","commitId":"85f7a36d-0e80-4c2f-a1b4-4592f29f19d5","commitTimeStamp":"2017-11-06T22:00:38.0605673Z","nuget:id":"Carbon.Kms","nuget:version":"0.36.1"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.22.00.38/dappermagician.1.1.3.json","@type":"nuget:PackageDetails","commitId":"85f7a36d-0e80-4c2f-a1b4-4592f29f19d5","commitTimeStamp":"2017-11-06T22:00:38.0605673Z","nuget:id":"DapperMagician","nuget:version":"1.1.3"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.22.00.38/carbon.ci.0.46.6.json","@type":"nuget:PackageDetails","commitId":"85f7a36d-0e80-4c2f-a1b4-4592f29f19d5","commitTimeStamp":"2017-11-06T22:00:38.0605673Z","nuget:id":"Carbon.CI","nuget:version":"0.46.6"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.22.00.38/carbon.kms.abstractions.0.36.1.json","@type":"nuget:PackageDetails","commitId":"85f7a36d-0e80-4c2f-a1b4-4592f29f19d5","commitTimeStamp":"2017-11-06T22:00:38.0605673Z","nuget:id":"Carbon.Kms.Abstractions","nuget:version":"0.36.1"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.22.00.38/petprojects.framework.consul.0.9.1711.22.json","@type":"nuget:PackageDetails","commitId":"85f7a36d-0e80-4c2f-a1b4-4592f29f19d5","commitTimeStamp":"2017-11-06T22:00:38.0605673Z","nuget:id":"PetProjects.Framework.Consul","nuget:version":"0.9.1711.22"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.58.02/momentum.pm.portalapi.5.11.107.json","@type":"nuget:PackageDetails","commitId":"33e81d1f-efee-459d-b87f-dc57d8da56b4","commitTimeStamp":"2017-11-06T21:58:02.9394229Z","nuget:id":"Momentum.Pm.PortalApi","nuget:version":"5.11.107"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.57.38/momentum.pm.api.5.11.107.json","@type":"nuget:PackageDetails","commitId":"c003b8b3-0a26-4da4-ba2f-3b9d9d3c38ba","commitTimeStamp":"2017-11-06T21:57:38.0792646Z","nuget:id":"Momentum.Pm.Api","nuget:version":"5.11.107"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.57.09/naos.recipes.runwithretry.1.0.78.json","@type":"nuget:PackageDetails","commitId":"af713ba0-3041-423a-aafb-c645a2575a7b","commitTimeStamp":"2017-11-06T21:57:09.2657909Z","nuget:id":"Naos.Recipes.RunWithRetry","nuget:version":"1.0.78"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.57.09/naos.recipes.console.exampleconfig.1.0.78.json","@type":"nuget:PackageDetails","commitId":"af713ba0-3041-423a-aafb-c645a2575a7b","commitTimeStamp":"2017-11-06T21:57:09.2657909Z","nuget:id":"Naos.Recipes.Console.ExampleConfig","nuget:version":"1.0.78"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.57.09/naos.recipes.console.domain.1.0.78.json","@type":"nuget:PackageDetails","commitId":"af713ba0-3041-423a-aafb-c645a2575a7b","commitTimeStamp":"2017-11-06T21:57:09.2657909Z","nuget:id":"Naos.Recipes.Console.Domain","nuget:version":"1.0.78"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.57.09/momentum.pm.portalapi.5.12.199-beta.json","@type":"nuget:PackageDetails","commitId":"af713ba0-3041-423a-aafb-c645a2575a7b","commitTimeStamp":"2017-11-06T21:57:09.2657909Z","nuget:id":"Momentum.Pm.PortalApi","nuget:version":"5.12.199-beta"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.57.09/naos.recipes.initializetestproject.1.0.78.json","@type":"nuget:PackageDetails","commitId":"af713ba0-3041-423a-aafb-c645a2575a7b","commitTimeStamp":"2017-11-06T21:57:09.2657909Z","nuget:id":"Naos.Recipes.InitializeTestProject","nuget:version":"1.0.78"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.57.09/naos.recipes.tupleinitializers.1.0.78.json","@type":"nuget:PackageDetails","commitId":"af713ba0-3041-423a-aafb-c645a2575a7b","commitTimeStamp":"2017-11-06T21:57:09.2657909Z","nuget:id":"Naos.Recipes.TupleInitializers","nuget:version":"1.0.78"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.57.09/momentum.pm.api.5.12.199-beta.json","@type":"nuget:PackageDetails","commitId":"af713ba0-3041-423a-aafb-c645a2575a7b","commitTimeStamp":"2017-11-06T21:57:09.2657909Z","nuget:id":"Momentum.Pm.Api","nuget:version":"5.12.199-beta"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.57.09/naos.recipes.deployment.commonconfig.1.0.78.json","@type":"nuget:PackageDetails","commitId":"af713ba0-3041-423a-aafb-c645a2575a7b","commitTimeStamp":"2017-11-06T21:57:09.2657909Z","nuget:id":"Naos.Recipes.Deployment.CommonConfig","nuget:version":"1.0.78"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.57.09/naos.recipes.cryptography.hashing.1.0.78.json","@type":"nuget:PackageDetails","commitId":"af713ba0-3041-423a-aafb-c645a2575a7b","commitTimeStamp":"2017-11-06T21:57:09.2657909Z","nuget:id":"Naos.Recipes.Cryptography.Hashing","nuget:version":"1.0.78"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.57.09/naos.recipes.itsdomain.authorization.1.0.78.json","@type":"nuget:PackageDetails","commitId":"af713ba0-3041-423a-aafb-c645a2575a7b","commitTimeStamp":"2017-11-06T21:57:09.2657909Z","nuget:id":"Naos.Recipes.ItsDomain.Authorization","nuget:version":"1.0.78"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.54.32/securestrconvertor.varun_rusiya.1.0.0.9.json","@type":"nuget:PackageDetails","commitId":"b9aec44a-e9a5-4e03-9d75-088af3f32ec1","commitTimeStamp":"2017-11-06T21:54:32.6667795Z","nuget:id":"SecureStrConvertor.VARUN_RUSIYA","nuget:version":"1.0.0.9"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.54.22/naos.recipes.console.bootstrapper.1.0.78.json","@type":"nuget:PackageDetails","commitId":"f376901c-415e-48bf-9cab-f6ea0b7bd82c","commitTimeStamp":"2017-11-06T21:54:22.9789114Z","nuget:id":"Naos.Recipes.Console.Bootstrapper","nuget:version":"1.0.78"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.54.13/naos.recipes.configuration.setup.1.0.78.json","@type":"nuget:PackageDetails","commitId":"d1b111aa-7e99-41bc-b5f3-18ef9225ccca","commitTimeStamp":"2017-11-06T21:54:13.38485Z","nuget:id":"Naos.Recipes.Configuration.Setup","nuget:version":"1.0.78"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.54.04/naos.recipes.configuration.setup.1.0.77.json","@type":"nuget:PackageDetails","commitId":"fecb9cac-cb09-47ce-8966-99881aa124b8","commitTimeStamp":"2017-11-06T21:54:04.7439456Z","nuget:id":"Naos.Recipes.Configuration.Setup","nuget:version":"1.0.77"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.54.04/naos.recipes.console.bootstrapper.1.0.77.json","@type":"nuget:PackageDetails","commitId":"fecb9cac-cb09-47ce-8966-99881aa124b8","commitTimeStamp":"2017-11-06T21:54:04.7439456Z","nuget:id":"Naos.Recipes.Console.Bootstrapper","nuget:version":"1.0.77"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.51.49/momentum.pm.api.5.10.15-legacy.json","@type":"nuget:PackageDetails","commitId":"43892d0b-c3aa-46ac-b1e6-11d3317aeaee","commitTimeStamp":"2017-11-06T21:51:49.2395561Z","nuget:id":"Momentum.Pm.Api","nuget:version":"5.10.15-legacy"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.51.49/sourcecode.chasm.repository.hybrid.1.0.0-preview1-00218.json","@type":"nuget:PackageDetails","commitId":"43892d0b-c3aa-46ac-b1e6-11d3317aeaee","commitTimeStamp":"2017-11-06T21:51:49.2395561Z","nuget:id":"SourceCode.Chasm.Repository.Hybrid","nuget:version":"1.0.0-preview1-00218"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.51.49/sourcecode.chasm.repository.disk.1.0.0-preview1-00218.json","@type":"nuget:PackageDetails","commitId":"43892d0b-c3aa-46ac-b1e6-11d3317aeaee","commitTimeStamp":"2017-11-06T21:51:49.2395561Z","nuget:id":"SourceCode.Chasm.Repository.Disk","nuget:version":"1.0.0-preview1-00218"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.51.49/developmenthelpers.sqllogging.2.0.4.json","@type":"nuget:PackageDetails","commitId":"43892d0b-c3aa-46ac-b1e6-11d3317aeaee","commitTimeStamp":"2017-11-06T21:51:49.2395561Z","nuget:id":"DevelopmentHelpers.SqlLogging","nuget:version":"2.0.4"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.51.49/sourcecode.chasm.io.json.1.0.0-preview1-00218.json","@type":"nuget:PackageDetails","commitId":"43892d0b-c3aa-46ac-b1e6-11d3317aeaee","commitTimeStamp":"2017-11-06T21:51:49.2395561Z","nuget:id":"SourceCode.Chasm.IO.Json","nuget:version":"1.0.0-preview1-00218"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.51.49/sourcecode.chasm.repository.azureblob.1.0.0-preview1-00218.json","@type":"nuget:PackageDetails","commitId":"43892d0b-c3aa-46ac-b1e6-11d3317aeaee","commitTimeStamp":"2017-11-06T21:51:49.2395561Z","nuget:id":"SourceCode.Chasm.Repository.AzureBlob","nuget:version":"1.0.0-preview1-00218"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.51.49/sourcecode.chasm.repository.azuretable.1.0.0-preview1-00218.json","@type":"nuget:PackageDetails","commitId":"43892d0b-c3aa-46ac-b1e6-11d3317aeaee","commitTimeStamp":"2017-11-06T21:51:49.2395561Z","nuget:id":"SourceCode.Chasm.Repository.AzureTable","nuget:version":"1.0.0-preview1-00218"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.51.49/sourcecode.chasm.io.proto.1.0.0-preview1-00218.json","@type":"nuget:PackageDetails","commitId":"43892d0b-c3aa-46ac-b1e6-11d3317aeaee","commitTimeStamp":"2017-11-06T21:51:49.2395561Z","nuget:id":"SourceCode.Chasm.IO.Proto","nuget:version":"1.0.0-preview1-00218"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.51.49/sourcecode.chasm.1.0.0-preview1-00218.json","@type":"nuget:PackageDetails","commitId":"43892d0b-c3aa-46ac-b1e6-11d3317aeaee","commitTimeStamp":"2017-11-06T21:51:49.2395561Z","nuget:id":"SourceCode.Chasm","nuget:version":"1.0.0-preview1-00218"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.51.49/sourcecode.chasm.io.text.1.0.0-preview1-00218.json","@type":"nuget:PackageDetails","commitId":"43892d0b-c3aa-46ac-b1e6-11d3317aeaee","commitTimeStamp":"2017-11-06T21:51:49.2395561Z","nuget:id":"SourceCode.Chasm.IO.Text","nuget:version":"1.0.0-preview1-00218"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.51.49/momentum.pm.portalapi.5.10.15-legacy.json","@type":"nuget:PackageDetails","commitId":"43892d0b-c3aa-46ac-b1e6-11d3317aeaee","commitTimeStamp":"2017-11-06T21:51:49.2395561Z","nuget:id":"Momentum.Pm.PortalApi","nuget:version":"5.10.15-legacy"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.51.49/securestrconvertor.varun_rusiya.1.0.0.9.json","@type":"nuget:PackageDetails","commitId":"43892d0b-c3aa-46ac-b1e6-11d3317aeaee","commitTimeStamp":"2017-11-06T21:51:49.2395561Z","nuget:id":"SecureStrConvertor.VARUN_RUSIYA","nuget:version":"1.0.0.9"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.49.29/developmenthelpers.sqllogging.2.0.3.json","@type":"nuget:PackageDetails","commitId":"41aa9e9b-fea2-4578-abb7-c772025c63b0","commitTimeStamp":"2017-11-06T21:49:29.7872051Z","nuget:id":"DevelopmentHelpers.SqlLogging","nuget:version":"2.0.3"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.49.07/momentum.pm.portalapi.5.12.198-beta.json","@type":"nuget:PackageDetails","commitId":"4cd8fc4c-869d-4f21-8bc1-f7ec30bb3e66","commitTimeStamp":"2017-11-06T21:49:07.6146624Z","nuget:id":"Momentum.Pm.PortalApi","nuget:version":"5.12.198-beta"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.48.43/momentum.pm.api.5.12.198-beta.json","@type":"nuget:PackageDetails","commitId":"b8e04137-aff3-48ab-a2b1-48f55a51c766","commitTimeStamp":"2017-11-06T21:48:43.3950747Z","nuget:id":"Momentum.Pm.Api","nuget:version":"5.12.198-beta"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.48.43/dotnettency.modules.nancy.1.4.0-unstable0035.json","@type":"nuget:PackageDetails","commitId":"b8e04137-aff3-48ab-a2b1-48f55a51c766","commitTimeStamp":"2017-11-06T21:48:43.3950747Z","nuget:id":"Dotnettency.Modules.Nancy","nuget:version":"1.4.0-unstable0035"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.48.43/dotnettency.modules.1.4.0-unstable0035.json","@type":"nuget:PackageDetails","commitId":"b8e04137-aff3-48ab-a2b1-48f55a51c766","commitTimeStamp":"2017-11-06T21:48:43.3950747Z","nuget:id":"Dotnettency.Modules","nuget:version":"1.4.0-unstable0035"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.48.14/developmenthelpers.sqllogging.2.0.3.json","@type":"nuget:PackageDetails","commitId":"39759890-5824-4dee-a3e5-ca63a15398ec","commitTimeStamp":"2017-11-06T21:48:14.9253644Z","nuget:id":"DevelopmentHelpers.SqlLogging","nuget:version":"2.0.3"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.48.14/dotnettency.middlewarepipeline.1.4.0-unstable0035.json","@type":"nuget:PackageDetails","commitId":"39759890-5824-4dee-a3e5-ca63a15398ec","commitTimeStamp":"2017-11-06T21:48:14.9253644Z","nuget:id":"Dotnettency.MiddlewarePipeline","nuget:version":"1.4.0-unstable0035"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.48.14/dotnettency.hostingenvironment.1.4.0-unstable0035.json","@type":"nuget:PackageDetails","commitId":"39759890-5824-4dee-a3e5-ca63a15398ec","commitTimeStamp":"2017-11-06T21:48:14.9253644Z","nuget:id":"Dotnettency.HostingEnvironment","nuget:version":"1.4.0-unstable0035"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.47.46/gdaxapi.0.0.27.json","@type":"nuget:PackageDetails","commitId":"081de23f-abab-450b-b63b-562e63d4e7b1","commitTimeStamp":"2017-11-06T21:47:46.8932519Z","nuget:id":"GdaxApi","nuget:version":"0.0.27"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.47.46/dotnettency.container.1.4.0-unstable0035.json","@type":"nuget:PackageDetails","commitId":"081de23f-abab-450b-b63b-562e63d4e7b1","commitTimeStamp":"2017-11-06T21:47:46.8932519Z","nuget:id":"Dotnettency.Container","nuget:version":"1.4.0-unstable0035"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.47.46/dotnettency.container.structuremap.1.4.0-unstable0035.json","@type":"nuget:PackageDetails","commitId":"081de23f-abab-450b-b63b-562e63d4e7b1","commitTimeStamp":"2017-11-06T21:47:46.8932519Z","nuget:id":"Dotnettency.Container.StructureMap","nuget:version":"1.4.0-unstable0035"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.47.46/dotnettency.1.4.0-unstable0035.json","@type":"nuget:PackageDetails","commitId":"081de23f-abab-450b-b63b-562e63d4e7b1","commitTimeStamp":"2017-11-06T21:47:46.8932519Z","nuget:id":"Dotnettency","nuget:version":"1.4.0-unstable0035"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.47.46/momentum.pm.portalapi.5.10.14-legacy.json","@type":"nuget:PackageDetails","commitId":"081de23f-abab-450b-b63b-562e63d4e7b1","commitTimeStamp":"2017-11-06T21:47:46.8932519Z","nuget:id":"Momentum.Pm.PortalApi","nuget:version":"5.10.14-legacy"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.47.46/momentum.pm.api.5.10.14-legacy.json","@type":"nuget:PackageDetails","commitId":"081de23f-abab-450b-b63b-562e63d4e7b1","commitTimeStamp":"2017-11-06T21:47:46.8932519Z","nuget:id":"Momentum.Pm.Api","nuget:version":"5.10.14-legacy"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.45.11/microsoft.reportingservices.reportviewercontrol.winforms.140.1000.523.json","@type":"nuget:PackageDetails","commitId":"b889a6e0-e1c9-4a8a-88e1-621fd49c41e2","commitTimeStamp":"2017-11-06T21:45:11.1210826Z","nuget:id":"Microsoft.ReportingServices.ReportViewerControl.Winforms","nuget:version":"140.1000.523"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.42.52/microsoft.reportingservices.reportviewercontrol.webforms.140.1000.523.json","@type":"nuget:PackageDetails","commitId":"e078407c-3dfd-4dae-a8c2-c136d01817f9","commitTimeStamp":"2017-11-06T21:42:52.4917023Z","nuget:id":"Microsoft.ReportingServices.ReportViewerControl.WebForms","nuget:version":"140.1000.523"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.40.36/mediadevices.1.4.0.json","@type":"nuget:PackageDetails","commitId":"c6889508-1296-47a1-a0f2-da748d3d65c1","commitTimeStamp":"2017-11-06T21:40:36.3769676Z","nuget:id":"MediaDevices","nuget:version":"1.4.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.40.36/wpfclipboardmonitor.1.0.0.json","@type":"nuget:PackageDetails","commitId":"c6889508-1296-47a1-a0f2-da748d3d65c1","commitTimeStamp":"2017-11-06T21:40:36.3769676Z","nuget:id":"WpfClipboardMonitor","nuget:version":"1.0.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.40.26/momentum.pm.portalapi.5.11.106.json","@type":"nuget:PackageDetails","commitId":"c1dbf254-82c3-4af8-9f4d-f8179d1a2aa5","commitTimeStamp":"2017-11-06T21:40:26.7516582Z","nuget:id":"Momentum.Pm.PortalApi","nuget:version":"5.11.106"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.40.26/momentum.pm.api.5.11.106.json","@type":"nuget:PackageDetails","commitId":"c1dbf254-82c3-4af8-9f4d-f8179d1a2aa5","commitTimeStamp":"2017-11-06T21:40:26.7516582Z","nuget:id":"Momentum.Pm.Api","nuget:version":"5.11.106"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.38.09/momentum.pm.api.5.11.105.json","@type":"nuget:PackageDetails","commitId":"62d83144-6384-484f-afe0-09e6e74b5fd9","commitTimeStamp":"2017-11-06T21:38:09.2003495Z","nuget:id":"Momentum.Pm.Api","nuget:version":"5.11.105"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.38.09/momentum.pm.portalapi.5.11.105.json","@type":"nuget:PackageDetails","commitId":"62d83144-6384-484f-afe0-09e6e74b5fd9","commitTimeStamp":"2017-11-06T21:38:09.2003495Z","nuget:id":"Momentum.Pm.PortalApi","nuget:version":"5.11.105"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.35.52/inflatable.1.0.50.json","@type":"nuget:PackageDetails","commitId":"941103bd-e749-4403-86f5-7519706ad9a2","commitTimeStamp":"2017-11-06T21:35:52.3363903Z","nuget:id":"Inflatable","nuget:version":"1.0.50"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.35.52/unity.abstractions.2.1.1.json","@type":"nuget:PackageDetails","commitId":"941103bd-e749-4403-86f5-7519706ad9a2","commitTimeStamp":"2017-11-06T21:35:52.3363903Z","nuget:id":"Unity.Abstractions","nuget:version":"2.1.1"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.35.52/zenseless.0.3.6.json","@type":"nuget:PackageDetails","commitId":"941103bd-e749-4403-86f5-7519706ad9a2","commitTimeStamp":"2017-11-06T21:35:52.3363903Z","nuget:id":"Zenseless","nuget:version":"0.3.6"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.33.32/momentum.pm.api.5.12.197-beta.json","@type":"nuget:PackageDetails","commitId":"c99efd36-6f7e-4264-a810-52196258d958","commitTimeStamp":"2017-11-06T21:33:32.3574864Z","nuget:id":"Momentum.Pm.Api","nuget:version":"5.12.197-beta"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.33.32/sourcecode.clay.threading.1.0.0-preview1-00278.json","@type":"nuget:PackageDetails","commitId":"c99efd36-6f7e-4264-a810-52196258d958","commitTimeStamp":"2017-11-06T21:33:32.3574864Z","nuget:id":"SourceCode.Clay.Threading","nuget:version":"1.0.0-preview1-00278"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.33.32/momentum.pm.portalapi.5.12.197-beta.json","@type":"nuget:PackageDetails","commitId":"c99efd36-6f7e-4264-a810-52196258d958","commitTimeStamp":"2017-11-06T21:33:32.3574864Z","nuget:id":"Momentum.Pm.PortalApi","nuget:version":"5.12.197-beta"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.31.13/homewizard.net.1.0.3.json","@type":"nuget:PackageDetails","commitId":"9dfdd7f8-5295-447f-940f-f59977fdd6cd","commitTimeStamp":"2017-11-06T21:31:13.622101Z","nuget:id":"HomeWizard.Net","nuget:version":"1.0.3"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.31.13/write-progressex.0.17.0.json","@type":"nuget:PackageDetails","commitId":"9dfdd7f8-5295-447f-940f-f59977fdd6cd","commitTimeStamp":"2017-11-06T21:31:13.622101Z","nuget:id":"Write-ProgressEx","nuget:version":"0.17.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.31.04/sourcecode.clay.text.1.0.0-preview1-00278.json","@type":"nuget:PackageDetails","commitId":"c589c2d3-7652-4cd6-bf80-46b03344e956","commitTimeStamp":"2017-11-06T21:31:04.1055481Z","nuget:id":"SourceCode.Clay.Text","nuget:version":"1.0.0-preview1-00278"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.30.55/sourcecode.clay.openapi.1.0.0-preview1-00278.json","@type":"nuget:PackageDetails","commitId":"4c840181-9967-4825-b770-ef2773d1f713","commitTimeStamp":"2017-11-06T21:30:55.0195475Z","nuget:id":"SourceCode.Clay.OpenApi","nuget:version":"1.0.0-preview1-00278"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.30.45/sourcecode.clay.json.1.0.0-preview1-00278.json","@type":"nuget:PackageDetails","commitId":"90b3b9e3-68db-48bf-9d45-0cc70ce9bed4","commitTimeStamp":"2017-11-06T21:30:45.7379688Z","nuget:id":"SourceCode.Clay.Json","nuget:version":"1.0.0-preview1-00278"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.30.36/sourcecode.clay.data.1.0.0-preview1-00278.json","@type":"nuget:PackageDetails","commitId":"7078dd2b-7831-4483-b614-bb1f4327e1a3","commitTimeStamp":"2017-11-06T21:30:36.9564653Z","nuget:id":"SourceCode.Clay.Data","nuget:version":"1.0.0-preview1-00278"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.30.36/storm.buildtasks.androidcolors.0.2.2.json","@type":"nuget:PackageDetails","commitId":"7078dd2b-7831-4483-b614-bb1f4327e1a3","commitTimeStamp":"2017-11-06T21:30:36.9564653Z","nuget:id":"Storm.BuildTasks.AndroidColors","nuget:version":"0.2.2"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.30.28/sourcecode.clay.collections.1.0.0-preview1-00278.json","@type":"nuget:PackageDetails","commitId":"87f51383-353b-4ec4-bbf2-b9aeab9ffa01","commitTimeStamp":"2017-11-06T21:30:28.0452768Z","nuget:id":"SourceCode.Clay.Collections","nuget:version":"1.0.0-preview1-00278"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.30.17/sourcecode.clay.1.0.0-preview1-00278.json","@type":"nuget:PackageDetails","commitId":"1dcf6f35-bbd0-4c96-8d30-51550a8ae21e","commitTimeStamp":"2017-11-06T21:30:17.9320566Z","nuget:id":"SourceCode.Clay","nuget:version":"1.0.0-preview1-00278"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.30.17/makesensframeworkcoreservices.2017.11.6.3.json","@type":"nuget:PackageDetails","commitId":"1dcf6f35-bbd0-4c96-8d30-51550a8ae21e","commitTimeStamp":"2017-11-06T21:30:17.9320566Z","nuget:id":"MakeSensFrameworkCoreServices","nuget:version":"2017.11.6.3"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.30.17/sourcecode.clay.buffers.1.0.0-preview1-00278.json","@type":"nuget:PackageDetails","commitId":"1dcf6f35-bbd0-4c96-8d30-51550a8ae21e","commitTimeStamp":"2017-11-06T21:30:17.9320566Z","nuget:id":"SourceCode.Clay.Buffers","nuget:version":"1.0.0-preview1-00278"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.27.57/med.configuracion.api.1.3.0.json","@type":"nuget:PackageDetails","commitId":"bd823677-1314-4e0a-ac48-85b4a586f12c","commitTimeStamp":"2017-11-06T21:27:57.955022Z","nuget:id":"Med.Configuracion.API","nuget:version":"1.3.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.27.57/homewizard.net.1.0.3.json","@type":"nuget:PackageDetails","commitId":"bd823677-1314-4e0a-ac48-85b4a586f12c","commitTimeStamp":"2017-11-06T21:27:57.955022Z","nuget:id":"HomeWizard.Net","nuget:version":"1.0.3"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.27.57/serilog.sinks.awscloudwatch.3.0.86.json","@type":"nuget:PackageDetails","commitId":"bd823677-1314-4e0a-ac48-85b4a586f12c","commitTimeStamp":"2017-11-06T21:27:57.955022Z","nuget:id":"Serilog.Sinks.AwsCloudWatch","nuget:version":"3.0.86"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.27.57/write-progressex.0.17.0.json","@type":"nuget:PackageDetails","commitId":"bd823677-1314-4e0a-ac48-85b4a586f12c","commitTimeStamp":"2017-11-06T21:27:57.955022Z","nuget:id":"Write-ProgressEx","nuget:version":"0.17.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.25.38/fluentregistration.2.5.1.json","@type":"nuget:PackageDetails","commitId":"e3d0105c-8fb6-4d61-af52-b79e56943532","commitTimeStamp":"2017-11-06T21:25:38.2091749Z","nuget:id":"FluentRegistration","nuget:version":"2.5.1"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.25.38/azurite.1.1.0.json","@type":"nuget:PackageDetails","commitId":"e3d0105c-8fb6-4d61-af52-b79e56943532","commitTimeStamp":"2017-11-06T21:25:38.2091749Z","nuget:id":"Azurite","nuget:version":"1.1.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.23.17/lykke.service.clientaccount.client.1.0.43-beta.json","@type":"nuget:PackageDetails","commitId":"38010446-604a-4a17-be0c-699513eed50c","commitTimeStamp":"2017-11-06T21:23:17.0080684Z","nuget:id":"Lykke.Service.ClientAccount.Client","nuget:version":"1.0.43-beta"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.18.41/securestrconvertor.varun_rusiya.1.0.0.8.json","@type":"nuget:PackageDetails","commitId":"0f5d4617-2122-43be-8d71-056d8dae489c","commitTimeStamp":"2017-11-06T21:18:41.1226055Z","nuget:id":"SecureStrConvertor.VARUN_RUSIYA","nuget:version":"1.0.0.8"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.18.31/rubberstamp.0.1.0.4.json","@type":"nuget:PackageDetails","commitId":"3d83b571-2a51-4eff-a3fa-05671c1aff4f","commitTimeStamp":"2017-11-06T21:18:31.9504356Z","nuget:id":"RubberStamp","nuget:version":"0.1.0.4"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.18.31/manatee.json.9.0.0.json","@type":"nuget:PackageDetails","commitId":"3d83b571-2a51-4eff-a3fa-05671c1aff4f","commitTimeStamp":"2017-11-06T21:18:31.9504356Z","nuget:id":"Manatee.Json","nuget:version":"9.0.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.21.18.31/securestrconvertor.varun_rusiya.1.0.0.8.json","@type":"nuget:PackageDetails","commitId":"3d83b571-2a51-4eff-a3fa-05671c1aff4f","commitTimeStamp":"2017-11-06T21:18:31.9504356Z","nuget:id":"SecureStrConvertor.VARUN_RUSIYA","nuget:version":"1.0.0.8"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.19.30.56/meziantou.framework.1.0.16.json","@type":"nuget:PackageDetails","commitId":"57de6c98-d4c6-4a24-95b9-1829c5013985","commitTimeStamp":"2017-11-06T19:30:56.0421411Z","nuget:id":"Meziantou.Framework","nuget:version":"1.0.16"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.19.30.56/makesensframeworkcoreservices.2017.11.6.2.json","@type":"nuget:PackageDetails","commitId":"57de6c98-d4c6-4a24-95b9-1829c5013985","commitTimeStamp":"2017-11-06T19:30:56.0421411Z","nuget:id":"MakeSensFrameworkCoreServices","nuget:version":"2017.11.6.2"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.19.30.56/crossroads.web.common.1.1.10.json","@type":"nuget:PackageDetails","commitId":"57de6c98-d4c6-4a24-95b9-1829c5013985","commitTimeStamp":"2017-11-06T19:30:56.0421411Z","nuget:id":"Crossroads.Web.Common","nuget:version":"1.1.10"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.19.30.56/genexcel.0.2.0.json","@type":"nuget:PackageDetails","commitId":"57de6c98-d4c6-4a24-95b9-1829c5013985","commitTimeStamp":"2017-11-06T19:30:56.0421411Z","nuget:id":"Genexcel","nuget:version":"0.2.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.19.30.56/meziantou.framework.codedom.1.0.8.json","@type":"nuget:PackageDetails","commitId":"57de6c98-d4c6-4a24-95b9-1829c5013985","commitTimeStamp":"2017-11-06T19:30:56.0421411Z","nuget:id":"Meziantou.Framework.CodeDom","nuget:version":"1.0.8"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.19.29.03/microsoft.azure.iot.edge.function.0.3.0.json","@type":"nuget:PackageDelete","commitId":"b429c4e3-5127-4430-9cc8-74927c9c3886","commitTimeStamp":"2017-11-06T19:29:03.6198426Z","nuget:id":"Microsoft.Azure.IoT.Edge.Function","nuget:version":"0.3.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.19.29.03/microsoft.azure.iot.edge.function.0.4.0.json","@type":"nuget:PackageDelete","commitId":"b429c4e3-5127-4430-9cc8-74927c9c3886","commitTimeStamp":"2017-11-06T19:29:03.6198426Z","nuget:id":"Microsoft.Azure.IoT.Edge.Function","nuget:version":"0.4.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.19.29.03/microsoft.azure.iot.edge.function.0.5.0.json","@type":"nuget:PackageDelete","commitId":"b429c4e3-5127-4430-9cc8-74927c9c3886","commitTimeStamp":"2017-11-06T19:29:03.6198426Z","nuget:id":"Microsoft.Azure.IoT.Edge.Function","nuget:version":"0.5.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.19.29.03/microsoft.azure.iot.edge.function.0.2.0.json","@type":"nuget:PackageDelete","commitId":"b429c4e3-5127-4430-9cc8-74927c9c3886","commitTimeStamp":"2017-11-06T19:29:03.6198426Z","nuget:id":"Microsoft.Azure.IoT.Edge.Function","nuget:version":"0.2.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.19.29.03/microsoft.azure.iot.edge.function.0.6.0.json","@type":"nuget:PackageDelete","commitId":"b429c4e3-5127-4430-9cc8-74927c9c3886","commitTimeStamp":"2017-11-06T19:29:03.6198426Z","nuget:id":"Microsoft.Azure.IoT.Edge.Function","nuget:version":"0.6.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.19.22.12/iccorp.infraestructura.repositorio.rabbitmq.1.0.0.7.json","@type":"nuget:PackageDetails","commitId":"68db1da1-68f9-47f3-9a74-23254d361ea8","commitTimeStamp":"2017-11-06T19:22:12.996134Z","nuget:id":"ICCorp.Infraestructura.Repositorio.RabbitMQ","nuget:version":"1.0.0.7"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.19.17.32/wkx.0.4.0.json","@type":"nuget:PackageDetails","commitId":"7ead9009-ba51-4708-84ab-fd79b77570a4","commitTimeStamp":"2017-11-06T19:17:32.6743228Z","nuget:id":"Wkx","nuget:version":"0.4.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.19.15.07/lykke.rabbitmqbroker.4.0.4.json","@type":"nuget:PackageDetails","commitId":"bd4622e0-268d-4091-9d0f-b58f5ceb715d","commitTimeStamp":"2017-11-06T19:15:07.1017103Z","nuget:id":"Lykke.RabbitMqBroker","nuget:version":"4.0.4"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.19.15.07/melanchall.drywetmidi.2.0.0.json","@type":"nuget:PackageDetails","commitId":"bd4622e0-268d-4091-9d0f-b58f5ceb715d","commitTimeStamp":"2017-11-06T19:15:07.1017103Z","nuget:id":"Melanchall.DryWetMidi","nuget:version":"2.0.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.19.12.40/lifeimage-agent.1.0.19.json","@type":"nuget:PackageDetails","commitId":"704a37e7-ac32-4fcf-86b4-167f020c76c7","commitTimeStamp":"2017-11-06T19:12:40.5339344Z","nuget:id":"lifeimage-agent","nuget:version":"1.0.19"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.19.10.16/lykke.rabbitmqbroker.4.0.3.json","@type":"nuget:PackageDetails","commitId":"4577e271-348a-4f3f-ae30-5d566dce6e35","commitTimeStamp":"2017-11-06T19:10:16.0983741Z","nuget:id":"Lykke.RabbitMqBroker","nuget:version":"4.0.3"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.19.05.31/naos.packaging.nuget.1.0.36.json","@type":"nuget:PackageDetails","commitId":"b8853431-9b69-487d-ab7a-d7c4dd8e59d0","commitTimeStamp":"2017-11-06T19:05:31.6034108Z","nuget:id":"Naos.Packaging.NuGet","nuget:version":"1.0.36"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.19.05.31/pickles.commandline.2.17.0.json","@type":"nuget:PackageDetails","commitId":"b8853431-9b69-487d-ab7a-d7c4dd8e59d0","commitTimeStamp":"2017-11-06T19:05:31.6034108Z","nuget:id":"Pickles.CommandLine","nuget:version":"2.17.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.19.05.31/naos.packaging.domain.1.0.36.json","@type":"nuget:PackageDetails","commitId":"b8853431-9b69-487d-ab7a-d7c4dd8e59d0","commitTimeStamp":"2017-11-06T19:05:31.6034108Z","nuget:id":"Naos.Packaging.Domain","nuget:version":"1.0.36"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.19.05.31/pickles.2.17.0.json","@type":"nuget:PackageDetails","commitId":"b8853431-9b69-487d-ab7a-d7c4dd8e59d0","commitTimeStamp":"2017-11-06T19:05:31.6034108Z","nuget:id":"Pickles","nuget:version":"2.17.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.19.05.31/pickles.msbuild.2.17.0.json","@type":"nuget:PackageDetails","commitId":"b8853431-9b69-487d-ab7a-d7c4dd8e59d0","commitTimeStamp":"2017-11-06T19:05:31.6034108Z","nuget:id":"Pickles.MSBuild","nuget:version":"2.17.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.19.02.41/mementofx.persistence.ravendb.2.0.0-pre1.json","@type":"nuget:PackageDetails","commitId":"d65aa625-3473-42ec-8802-2571d2423d40","commitTimeStamp":"2017-11-06T19:02:41.4391839Z","nuget:id":"MementoFX.Persistence.RavenDB","nuget:version":"2.0.0-pre1"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.19.02.33/mementofx.persistence.ravendb.2.0.0-pre1.json","@type":"nuget:PackageDetails","commitId":"d92b23b3-4b31-4006-944c-1539b9384012","commitTimeStamp":"2017-11-06T19:02:33.1290123Z","nuget:id":"MementoFX.Persistence.RavenDB","nuget:version":"2.0.0-pre1"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.19.00.02/operation.1.1.0.json","@type":"nuget:PackageDetails","commitId":"49dd5128-833f-4c1f-b983-667a1b7dfc31","commitTimeStamp":"2017-11-06T19:00:02.8750219Z","nuget:id":"Operation","nuget:version":"1.1.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.57.16/lightstone.microservice.billable.1.0.6.json","@type":"nuget:PackageDetails","commitId":"a1081394-01af-4f09-9b23-9d54914957b9","commitTimeStamp":"2017-11-06T18:57:16.5089345Z","nuget:id":"Lightstone.MicroService.Billable","nuget:version":"1.0.6"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.57.08/twentytwenty.mvc.0.7.2.json","@type":"nuget:PackageDetails","commitId":"4afbaa09-ccef-4e16-8c6c-b8c9a7934423","commitTimeStamp":"2017-11-06T18:57:08.0868979Z","nuget:id":"TwentyTwenty.Mvc","nuget:version":"0.7.2"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.57.08/operation.1.1.0.json","@type":"nuget:PackageDetails","commitId":"4afbaa09-ccef-4e16-8c6c-b8c9a7934423","commitTimeStamp":"2017-11-06T18:57:08.0868979Z","nuget:id":"Operation","nuget:version":"1.1.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.54.19/carbon.ci.0.46.5.json","@type":"nuget:PackageDetails","commitId":"fa817ce6-dea4-4dfe-8cee-e4b995583aa9","commitTimeStamp":"2017-11-06T18:54:19.4124314Z","nuget:id":"Carbon.CI","nuget:version":"0.46.5"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.54.11/skiarate.forms.0.5.1-pre.json","@type":"nuget:PackageDetails","commitId":"584a084c-a2d1-47fa-af79-2bef0d29ce56","commitTimeStamp":"2017-11-06T18:54:11.240255Z","nuget:id":"SkiaRate.Forms","nuget:version":"0.5.1-pre"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.54.11/carbon.kms.0.36.0.json","@type":"nuget:PackageDetails","commitId":"584a084c-a2d1-47fa-af79-2bef0d29ce56","commitTimeStamp":"2017-11-06T18:54:11.240255Z","nuget:id":"Carbon.Kms","nuget:version":"0.36.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.54.11/carbon.kms.abstractions.0.36.0.json","@type":"nuget:PackageDetails","commitId":"584a084c-a2d1-47fa-af79-2bef0d29ce56","commitTimeStamp":"2017-11-06T18:54:11.240255Z","nuget:id":"Carbon.Kms.Abstractions","nuget:version":"0.36.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.54.11/carbon.platform.client.0.66.3.json","@type":"nuget:PackageDetails","commitId":"584a084c-a2d1-47fa-af79-2bef0d29ce56","commitTimeStamp":"2017-11-06T18:54:11.240255Z","nuget:id":"Carbon.Platform.Client","nuget:version":"0.66.3"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.54.11/skiarate.0.5.1-pre.json","@type":"nuget:PackageDetails","commitId":"584a084c-a2d1-47fa-af79-2bef0d29ce56","commitTimeStamp":"2017-11-06T18:54:11.240255Z","nuget:id":"SkiaRate","nuget:version":"0.5.1-pre"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.49.24/asyncprocess.net.1.0.0.json","@type":"nuget:PackageDetails","commitId":"03fbde70-12b4-44c7-91ea-a482c0fb4a02","commitTimeStamp":"2017-11-06T18:49:24.1394642Z","nuget:id":"AsyncProcess.Net","nuget:version":"1.0.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.46.54/asyncprocess.net.1.0.0.json","@type":"nuget:PackageDetails","commitId":"60480846-6871-4bec-b35f-dea8be883b98","commitTimeStamp":"2017-11-06T18:46:54.9446581Z","nuget:id":"AsyncProcess.Net","nuget:version":"1.0.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.46.54/bogus.20.0.2.json","@type":"nuget:PackageDetails","commitId":"60480846-6871-4bec-b35f-dea8be883b98","commitTimeStamp":"2017-11-06T18:46:54.9446581Z","nuget:id":"Bogus","nuget:version":"20.0.2"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.44.27/lightstone.microservice.billable.1.0.6.json","@type":"nuget:PackageDetails","commitId":"3e40407c-a5b6-4f26-8af9-a2009b036252","commitTimeStamp":"2017-11-06T18:44:27.0162517Z","nuget:id":"Lightstone.MicroService.Billable","nuget:version":"1.0.6"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.44.18/lightstone.microservice.billable.1.0.6.json","@type":"nuget:PackageDetails","commitId":"17e453e6-957a-4f17-a85c-05e5875e1a0f","commitTimeStamp":"2017-11-06T18:44:18.5832415Z","nuget:id":"Lightstone.MicroService.Billable","nuget:version":"1.0.6"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.39.13/mysql.simple.3.5.0.json","@type":"nuget:PackageDetails","commitId":"444123aa-d571-4e39-905f-34337be0c889","commitTimeStamp":"2017-11-06T18:39:13.2077861Z","nuget:id":"MySql.Simple","nuget:version":"3.5.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.39.03/mysql.simple.3.5.0.json","@type":"nuget:PackageDetails","commitId":"a80dad57-3eed-4c61-a175-89477f20fe66","commitTimeStamp":"2017-11-06T18:39:03.2413943Z","nuget:id":"MySql.Simple","nuget:version":"3.5.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.39.03/gatewaycontroller.1.0.0.json","@type":"nuget:PackageDetails","commitId":"a80dad57-3eed-4c61-a175-89477f20fe66","commitTimeStamp":"2017-11-06T18:39:03.2413943Z","nuget:id":"GatewayController","nuget:version":"1.0.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.37.04/microsoft.azure.iot.edge.function.0.1.0.json","@type":"nuget:PackageDelete","commitId":"08e2f8a5-fa9e-4788-b437-5b043b618d40","commitTimeStamp":"2017-11-06T18:37:04.8953217Z","nuget:id":"Microsoft.Azure.IoT.Edge.Function","nuget:version":"0.1.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.30/appbrix.factory.0.10.0.json","@type":"nuget:PackageDetails","commitId":"179dbc0b-cec9-4de2-9890-2c655c6ad493","commitTimeStamp":"2017-11-06T18:34:30.6288667Z","nuget:id":"AppBrix.Factory","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.30/appbrix.logging.file.0.10.0.json","@type":"nuget:PackageDetails","commitId":"179dbc0b-cec9-4de2-9890-2c655c6ad493","commitTimeStamp":"2017-11-06T18:34:30.6288667Z","nuget:id":"AppBrix.Logging.File","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.30/appbrix.logging.console.0.10.0.json","@type":"nuget:PackageDetails","commitId":"179dbc0b-cec9-4de2-9890-2c655c6ad493","commitTimeStamp":"2017-11-06T18:34:30.6288667Z","nuget:id":"AppBrix.Logging.Console","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.30/appbrix.time.0.10.0.json","@type":"nuget:PackageDetails","commitId":"179dbc0b-cec9-4de2-9890-2c655c6ad493","commitTimeStamp":"2017-11-06T18:34:30.6288667Z","nuget:id":"AppBrix.Time","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.30/appbrix.text.0.10.0.json","@type":"nuget:PackageDetails","commitId":"179dbc0b-cec9-4de2-9890-2c655c6ad493","commitTimeStamp":"2017-11-06T18:34:30.6288667Z","nuget:id":"AppBrix.Text","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.30/raspberry.io.generalpurpose3.3.1.1.json","@type":"nuget:PackageDetails","commitId":"179dbc0b-cec9-4de2-9890-2c655c6ad493","commitTimeStamp":"2017-11-06T18:34:30.6288667Z","nuget:id":"Raspberry.IO.GeneralPurpose3","nuget:version":"3.1.1"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.30/appbrix.logging.0.10.0.json","@type":"nuget:PackageDetails","commitId":"179dbc0b-cec9-4de2-9890-2c655c6ad493","commitTimeStamp":"2017-11-06T18:34:30.6288667Z","nuget:id":"AppBrix.Logging","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.30/appbrix.web.server.0.10.0.json","@type":"nuget:PackageDetails","commitId":"179dbc0b-cec9-4de2-9890-2c655c6ad493","commitTimeStamp":"2017-11-06T18:34:30.6288667Z","nuget:id":"AppBrix.Web.Server","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.30/appbrix.events.schedule.timer.0.10.0.json","@type":"nuget:PackageDetails","commitId":"179dbc0b-cec9-4de2-9890-2c655c6ad493","commitTimeStamp":"2017-11-06T18:34:30.6288667Z","nuget:id":"AppBrix.Events.Schedule.Timer","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.30/appbrix.events.schedule.cron.0.10.0.json","@type":"nuget:PackageDetails","commitId":"179dbc0b-cec9-4de2-9890-2c655c6ad493","commitTimeStamp":"2017-11-06T18:34:30.6288667Z","nuget:id":"AppBrix.Events.Schedule.Cron","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.30/raspberry.io.interintegratedcircuit3.3.1.1.json","@type":"nuget:PackageDetails","commitId":"179dbc0b-cec9-4de2-9890-2c655c6ad493","commitTimeStamp":"2017-11-06T18:34:30.6288667Z","nuget:id":"Raspberry.IO.InterIntegratedCircuit3","nuget:version":"3.1.1"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.30/appbrix.web.client.0.10.0.json","@type":"nuget:PackageDetails","commitId":"179dbc0b-cec9-4de2-9890-2c655c6ad493","commitTimeStamp":"2017-11-06T18:34:30.6288667Z","nuget:id":"AppBrix.Web.Client","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.20/appbrix.configuration.files.0.10.0.json","@type":"nuget:PackageDetails","commitId":"9588120e-1f6b-4fc8-8b02-eed98536fd43","commitTimeStamp":"2017-11-06T18:34:20.5021327Z","nuget:id":"AppBrix.Configuration.Files","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.20/raspberry.io.serialperipheralinterface3.3.1.1.json","@type":"nuget:PackageDetails","commitId":"9588120e-1f6b-4fc8-8b02-eed98536fd43","commitTimeStamp":"2017-11-06T18:34:20.5021327Z","nuget:id":"Raspberry.IO.SerialPeripheralInterface3","nuget:version":"3.1.1"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.20/appbrix.data.migration.0.10.0.json","@type":"nuget:PackageDetails","commitId":"9588120e-1f6b-4fc8-8b02-eed98536fd43","commitTimeStamp":"2017-11-06T18:34:20.5021327Z","nuget:id":"AppBrix.Data.Migration","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.20/lifeimage-agent.1.0.18.json","@type":"nuget:PackageDetails","commitId":"9588120e-1f6b-4fc8-8b02-eed98536fd43","commitTimeStamp":"2017-11-06T18:34:20.5021327Z","nuget:id":"lifeimage-agent","nuget:version":"1.0.18"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.20/appbrix.data.0.10.0.json","@type":"nuget:PackageDetails","commitId":"9588120e-1f6b-4fc8-8b02-eed98536fd43","commitTimeStamp":"2017-11-06T18:34:20.5021327Z","nuget:id":"AppBrix.Data","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.20/syncsoft.cqrs.1.2.3.1.json","@type":"nuget:PackageDetails","commitId":"9588120e-1f6b-4fc8-8b02-eed98536fd43","commitTimeStamp":"2017-11-06T18:34:20.5021327Z","nuget:id":"SyncSoft.CQRS","nuget:version":"1.2.3.1"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.20/appbrix.events.0.10.0.json","@type":"nuget:PackageDetails","commitId":"9588120e-1f6b-4fc8-8b02-eed98536fd43","commitTimeStamp":"2017-11-06T18:34:20.5021327Z","nuget:id":"AppBrix.Events","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.20/appbrix.data.sqlite.0.10.0.json","@type":"nuget:PackageDetails","commitId":"9588120e-1f6b-4fc8-8b02-eed98536fd43","commitTimeStamp":"2017-11-06T18:34:20.5021327Z","nuget:id":"AppBrix.Data.Sqlite","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.20/appbrix.configuration.json.0.10.0.json","@type":"nuget:PackageDetails","commitId":"9588120e-1f6b-4fc8-8b02-eed98536fd43","commitTimeStamp":"2017-11-06T18:34:20.5021327Z","nuget:id":"AppBrix.Configuration.Json","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.20/appbrix.cloning.0.10.0.json","@type":"nuget:PackageDetails","commitId":"9588120e-1f6b-4fc8-8b02-eed98536fd43","commitTimeStamp":"2017-11-06T18:34:20.5021327Z","nuget:id":"AppBrix.Cloning","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.20/appbrix.data.sqlserver.0.10.0.json","@type":"nuget:PackageDetails","commitId":"9588120e-1f6b-4fc8-8b02-eed98536fd43","commitTimeStamp":"2017-11-06T18:34:20.5021327Z","nuget:id":"AppBrix.Data.SqlServer","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.20/appbrix.caching.0.10.0.json","@type":"nuget:PackageDetails","commitId":"9588120e-1f6b-4fc8-8b02-eed98536fd43","commitTimeStamp":"2017-11-06T18:34:20.5021327Z","nuget:id":"AppBrix.Caching","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.20/appbrix.events.schedule.0.10.0.json","@type":"nuget:PackageDetails","commitId":"9588120e-1f6b-4fc8-8b02-eed98536fd43","commitTimeStamp":"2017-11-06T18:34:20.5021327Z","nuget:id":"AppBrix.Events.Schedule","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.20/appbrix.data.inmemory.0.10.0.json","@type":"nuget:PackageDetails","commitId":"9588120e-1f6b-4fc8-8b02-eed98536fd43","commitTimeStamp":"2017-11-06T18:34:20.5021327Z","nuget:id":"AppBrix.Data.InMemory","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.20/appbrix.container.0.10.0.json","@type":"nuget:PackageDetails","commitId":"9588120e-1f6b-4fc8-8b02-eed98536fd43","commitTimeStamp":"2017-11-06T18:34:20.5021327Z","nuget:id":"AppBrix.Container","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.20/appbrix.events.async.0.10.0.json","@type":"nuget:PackageDetails","commitId":"9588120e-1f6b-4fc8-8b02-eed98536fd43","commitTimeStamp":"2017-11-06T18:34:20.5021327Z","nuget:id":"AppBrix.Events.Async","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.20/appbrix.configuration.yaml.0.10.0.json","@type":"nuget:PackageDetails","commitId":"9588120e-1f6b-4fc8-8b02-eed98536fd43","commitTimeStamp":"2017-11-06T18:34:20.5021327Z","nuget:id":"AppBrix.Configuration.Yaml","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.20/appbrix.configuration.memory.0.10.0.json","@type":"nuget:PackageDetails","commitId":"9588120e-1f6b-4fc8-8b02-eed98536fd43","commitTimeStamp":"2017-11-06T18:34:20.5021327Z","nuget:id":"AppBrix.Configuration.Memory","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.20/appbrix.caching.memory.0.10.0.json","@type":"nuget:PackageDetails","commitId":"9588120e-1f6b-4fc8-8b02-eed98536fd43","commitTimeStamp":"2017-11-06T18:34:20.5021327Z","nuget:id":"AppBrix.Caching.Memory","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.34.20/appbrix.utils.0.10.0.json","@type":"nuget:PackageDetails","commitId":"9588120e-1f6b-4fc8-8b02-eed98536fd43","commitTimeStamp":"2017-11-06T18:34:20.5021327Z","nuget:id":"AppBrix.Utils","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.32.18/iot.edge.function.0.1.0.json","@type":"nuget:PackageDelete","commitId":"c5d7a6b9-07e5-4273-9835-e6b52230e295","commitTimeStamp":"2017-11-06T18:32:18.2707545Z","nuget:id":"IoT.Edge.Function","nuget:version":"0.1.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.30.11/iot.edge.module.0.1.0.json","@type":"nuget:PackageDelete","commitId":"b82b18a1-5918-4625-8cb5-ca5689f371eb","commitTimeStamp":"2017-11-06T18:30:11.5733843Z","nuget:id":"IoT.Edge.Module","nuget:version":"0.1.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.28.07/kitaboosdk.1.0.0.2.json","@type":"nuget:PackageDelete","commitId":"8059ad1c-ce1c-4fb6-8d9b-bd897a65acd1","commitTimeStamp":"2017-11-06T18:28:07.3663249Z","nuget:id":"KitabooSDK","nuget:version":"1.0.0.2"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.25.40/appbrix.configuration.0.10.0.json","@type":"nuget:PackageDetails","commitId":"94357105-a901-4eb4-a619-700ffcb1c678","commitTimeStamp":"2017-11-06T18:25:40.6940307Z","nuget:id":"AppBrix.Configuration","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.25.31/raspberry.system3.3.1.1.json","@type":"nuget:PackageDetails","commitId":"8205fa6a-4015-473c-aaaf-44dd86c062cb","commitTimeStamp":"2017-11-06T18:25:31.6127782Z","nuget:id":"Raspberry.System3","nuget:version":"3.1.1"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.25.31/appbrix.0.10.0.json","@type":"nuget:PackageDetails","commitId":"8205fa6a-4015-473c-aaaf-44dd86c062cb","commitTimeStamp":"2017-11-06T18:25:31.6127782Z","nuget:id":"AppBrix","nuget:version":"0.10.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.23.10/lykke.wampsharp.1.0.2.json","@type":"nuget:PackageDetails","commitId":"d60c4c60-f4ff-4a5c-a800-1266047c9f9f","commitTimeStamp":"2017-11-06T18:23:10.7115861Z","nuget:id":"Lykke.WampSharp","nuget:version":"1.0.2"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.23.00/lykke.wampsharp.websockets.1.0.2.json","@type":"nuget:PackageDetails","commitId":"38bef28c-4676-483e-9550-a152f82967b4","commitTimeStamp":"2017-11-06T18:23:00.8808904Z","nuget:id":"Lykke.WampSharp.WebSockets","nuget:version":"1.0.2"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.22.50/lykke.wampsharp.default.client.1.0.2.json","@type":"nuget:PackageDetails","commitId":"2d08d48c-8c1e-46d1-96df-41f841191bab","commitTimeStamp":"2017-11-06T18:22:50.8080398Z","nuget:id":"Lykke.WampSharp.Default.Client","nuget:version":"1.0.2"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.22.50/lykke.wampsharp.newtonsoftmsgpack.1.0.2.json","@type":"nuget:PackageDetails","commitId":"2d08d48c-8c1e-46d1-96df-41f841191bab","commitTimeStamp":"2017-11-06T18:22:50.8080398Z","nuget:id":"Lykke.WampSharp.NewtonsoftMsgpack","nuget:version":"1.0.2"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.22.50/lykke.wampsharp.newtonsoftjson.1.0.2.json","@type":"nuget:PackageDetails","commitId":"2d08d48c-8c1e-46d1-96df-41f841191bab","commitTimeStamp":"2017-11-06T18:22:50.8080398Z","nuget:id":"Lykke.WampSharp.NewtonsoftJson","nuget:version":"1.0.2"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.22.50/lykke.wampsharp.websocket4net.1.0.2.json","@type":"nuget:PackageDetails","commitId":"2d08d48c-8c1e-46d1-96df-41f841191bab","commitTimeStamp":"2017-11-06T18:22:50.8080398Z","nuget:id":"Lykke.WampSharp.WebSocket4Net","nuget:version":"1.0.2"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.22.50/ah.framework.dataaccesslayer.3.0.0.json","@type":"nuget:PackageDetails","commitId":"2d08d48c-8c1e-46d1-96df-41f841191bab","commitTimeStamp":"2017-11-06T18:22:50.8080398Z","nuget:id":"Ah.Framework.DataAccessLayer","nuget:version":"3.0.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.22.50/lykke.wampsharp.aspnetcore.websockets.server.1.0.2.json","@type":"nuget:PackageDetails","commitId":"2d08d48c-8c1e-46d1-96df-41f841191bab","commitTimeStamp":"2017-11-06T18:22:50.8080398Z","nuget:id":"Lykke.WampSharp.AspNetCore.WebSockets.Server","nuget:version":"1.0.2"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.18.10/owlcarousel.1.3.3.json","@type":"nuget:PackageDetails","commitId":"890d2ee8-7b9b-4843-b1fe-85939614acd0","commitTimeStamp":"2017-11-06T18:18:10.2021165Z","nuget:id":"OwlCarousel","nuget:version":"1.3.3"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.18.01/winton.extensions.configuration.consul.1.1.0-master0003.json","@type":"nuget:PackageDetails","commitId":"4c95a935-4b0e-4650-8623-ba38b2992ba5","commitTimeStamp":"2017-11-06T18:18:01.6394392Z","nuget:id":"Winton.Extensions.Configuration.Consul","nuget:version":"1.1.0-master0003"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.15.34/moq.4.7.145.json","@type":"nuget:PackageDetails","commitId":"eec47a84-4488-4586-b7a7-371d4a5b7804","commitTimeStamp":"2017-11-06T18:15:34.0631069Z","nuget:id":"Moq","nuget:version":"4.7.145"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.15.34/claytondus.amazonmws.fbaoutbound.0.2.0.json","@type":"nuget:PackageDetails","commitId":"eec47a84-4488-4586-b7a7-371d4a5b7804","commitTimeStamp":"2017-11-06T18:15:34.0631069Z","nuget:id":"Claytondus.AmazonMWS.FbaOutbound","nuget:version":"0.2.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.13.05/walkingtec.mvvm.mvc.1.1.2.json","@type":"nuget:PackageDetails","commitId":"4fda0f59-5d64-4d89-971a-5025a170e014","commitTimeStamp":"2017-11-06T18:13:05.3692258Z","nuget:id":"WalkingTec.Mvvm.Mvc","nuget:version":"1.1.2"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.13.05/sentrydotnet.aspnetcore.1.1.0.json","@type":"nuget:PackageDetails","commitId":"4fda0f59-5d64-4d89-971a-5025a170e014","commitTimeStamp":"2017-11-06T18:13:05.3692258Z","nuget:id":"SentryDotNet.AspNetCore","nuget:version":"1.1.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.13.05/walkingtec.mvvm.taghelpers.layui.1.1.2.json","@type":"nuget:PackageDetails","commitId":"4fda0f59-5d64-4d89-971a-5025a170e014","commitTimeStamp":"2017-11-06T18:13:05.3692258Z","nuget:id":"WalkingTec.Mvvm.TagHelpers.LayUI","nuget:version":"1.1.2"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.13.05/walkingtec.mvvm.core.1.1.2.json","@type":"nuget:PackageDetails","commitId":"4fda0f59-5d64-4d89-971a-5025a170e014","commitTimeStamp":"2017-11-06T18:13:05.3692258Z","nuget:id":"WalkingTec.Mvvm.Core","nuget:version":"1.1.2"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.12.56/peachpie.library.pdo.sqlite.0.8.0-ci00457.json","@type":"nuget:PackageDetails","commitId":"355d531a-f3ac-43e4-8355-357ad8aa0456","commitTimeStamp":"2017-11-06T18:12:56.3806831Z","nuget:id":"Peachpie.Library.PDO.Sqlite","nuget:version":"0.8.0-CI00457"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.12.56/sentrydotnet.1.1.0.json","@type":"nuget:PackageDetails","commitId":"355d531a-f3ac-43e4-8355-357ad8aa0456","commitTimeStamp":"2017-11-06T18:12:56.3806831Z","nuget:id":"SentryDotNet","nuget:version":"1.1.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.12.56/peachpie.library.mysql.0.8.0-ci00457.json","@type":"nuget:PackageDetails","commitId":"355d531a-f3ac-43e4-8355-357ad8aa0456","commitTimeStamp":"2017-11-06T18:12:56.3806831Z","nuget:id":"Peachpie.Library.MySql","nuget:version":"0.8.0-CI00457"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.12.56/peachpie.library.pdo.firebird.0.8.0-ci00457.json","@type":"nuget:PackageDetails","commitId":"355d531a-f3ac-43e4-8355-357ad8aa0456","commitTimeStamp":"2017-11-06T18:12:56.3806831Z","nuget:id":"Peachpie.Library.PDO.Firebird","nuget:version":"0.8.0-CI00457"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.12.56/askmethat.xforms.controls.1.1.1.json","@type":"nuget:PackageDetails","commitId":"355d531a-f3ac-43e4-8355-357ad8aa0456","commitTimeStamp":"2017-11-06T18:12:56.3806831Z","nuget:id":"Askmethat.XForms.Controls","nuget:version":"1.1.1"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.12.56/peachpie.library.pdo.sqlsrv.0.8.0-ci00457.json","@type":"nuget:PackageDetails","commitId":"355d531a-f3ac-43e4-8355-357ad8aa0456","commitTimeStamp":"2017-11-06T18:12:56.3806831Z","nuget:id":"Peachpie.Library.PDO.SqlSrv","nuget:version":"0.8.0-CI00457"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.12.56/peachpie.requesthandler.0.8.0-ci00457.json","@type":"nuget:PackageDetails","commitId":"355d531a-f3ac-43e4-8355-357ad8aa0456","commitTimeStamp":"2017-11-06T18:12:56.3806831Z","nuget:id":"Peachpie.RequestHandler","nuget:version":"0.8.0-CI00457"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.12.56/walkingtec.mvvm.core.1.1.2.json","@type":"nuget:PackageDetails","commitId":"355d531a-f3ac-43e4-8355-357ad8aa0456","commitTimeStamp":"2017-11-06T18:12:56.3806831Z","nuget:id":"WalkingTec.Mvvm.Core","nuget:version":"1.1.2"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.12.56/peachpie.library.pdo.pgsql.0.8.0-ci00457.json","@type":"nuget:PackageDetails","commitId":"355d531a-f3ac-43e4-8355-357ad8aa0456","commitTimeStamp":"2017-11-06T18:12:56.3806831Z","nuget:id":"Peachpie.Library.PDO.PgSQL","nuget:version":"0.8.0-CI00457"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.12.56/peachpie.net.sdk.0.8.0-ci00457.json","@type":"nuget:PackageDetails","commitId":"355d531a-f3ac-43e4-8355-357ad8aa0456","commitTimeStamp":"2017-11-06T18:12:56.3806831Z","nuget:id":"Peachpie.NET.Sdk","nuget:version":"0.8.0-CI00457"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.12.56/sentrydotnet.aspnetcore.1.1.0.json","@type":"nuget:PackageDetails","commitId":"355d531a-f3ac-43e4-8355-357ad8aa0456","commitTimeStamp":"2017-11-06T18:12:56.3806831Z","nuget:id":"SentryDotNet.AspNetCore","nuget:version":"1.1.0"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.12.56/peachpie.library.pdo.mysql.0.8.0-ci00457.json","@type":"nuget:PackageDetails","commitId":"355d531a-f3ac-43e4-8355-357ad8aa0456","commitTimeStamp":"2017-11-06T18:12:56.3806831Z","nuget:id":"Peachpie.Library.PDO.MySQL","nuget:version":"0.8.0-CI00457"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.12.56/walkingtec.mvvm.taghelpers.layui.1.1.2.json","@type":"nuget:PackageDetails","commitId":"355d531a-f3ac-43e4-8355-357ad8aa0456","commitTimeStamp":"2017-11-06T18:12:56.3806831Z","nuget:id":"WalkingTec.Mvvm.TagHelpers.LayUI","nuget:version":"1.1.2"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.12.56/peachpie.library.pdo.0.8.0-ci00457.json","@type":"nuget:PackageDetails","commitId":"355d531a-f3ac-43e4-8355-357ad8aa0456","commitTimeStamp":"2017-11-06T18:12:56.3806831Z","nuget:id":"Peachpie.Library.PDO","nuget:version":"0.8.0-CI00457"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.12.56/walkingtec.mvvm.mvc.1.1.2.json","@type":"nuget:PackageDetails","commitId":"355d531a-f3ac-43e4-8355-357ad8aa0456","commitTimeStamp":"2017-11-06T18:12:56.3806831Z","nuget:id":"WalkingTec.Mvvm.Mvc","nuget:version":"1.1.2"},{"@id":"https://api.nuget.org/v3/catalog0/data/2017.11.06.18.12.56/peachpie.library.scripting.0.8.0-ci00457.json","@type":"nuget:PackageDetails","commitId":"355d531a-f3ac-43e4-8355-357ad8aa0456","commitTimeStamp":"2017-11-06T18:12:56.3806831Z","nuget:id":"Peachpie.Library.Scripting","nuget:version":"0.8.0-CI00457"}],"@context":{"@vocab":"http://schema.nuget.org/catalog#","nuget":"http://schema.nuget.org/schema#","items":{"@id":"item","@container":"@set"},"parent":{"@type":"@id"},"commitTimeStamp":{"@type":"http://www.w3.org/2001/XMLSchema#dateTime"},"nuget:lastCreated":{"@type":"http://www.w3.org/2001/XMLSchema#dateTime"},"nuget:lastEdited":{"@type":"http://www.w3.org/2001/XMLSchema#dateTime"},"nuget:lastDeleted":{"@type":"http://www.w3.org/2001/XMLSchema#dateTime"}}} + + + https://api.nuget.org/v3/catalog0/page2944.json + + + { + "@id": "https://api.nuget.org/v3/catalog0/data/2017.11.06.19.29.03/microsoft.azure.iot.edge.function.0.3.0.json", + "@type": [ + "PackageDelete", + "catalog:Permalink" + ], + "catalog:commitId": "b429c4e3-5127-4430-9cc8-74927c9c3886", + "catalog:commitTimeStamp": "2017-11-06T19:29:03.6198426Z", + "id": "Microsoft.Azure.IoT.Edge.Function", + "originalId": "Microsoft.Azure.IoT.Edge.Function", + "published": "2017-11-06T19:27:45.3684766Z", + "version": "0.3.0", + "@context": { + "@vocab": "http://schema.nuget.org/schema#", + "catalog": "http://schema.nuget.org/catalog#", + "xsd": "http://www.w3.org/2001/XMLSchema#", + "details": "catalog:details", + "catalog:commitTimeStamp": { + "@type": "xsd:dateTime" + }, + "published": { + "@type": "xsd:dateTime" + }, + "categories": { + "@container": "@set" + }, + "entries": { + "@container": "@set" + }, + "links": { + "@container": "@set" + }, + "tags": { + "@container": "@set" + }, + "packageContent": { + "@type": "@id" + } + } +} + + + https://api.nuget.org/v3/catalog0/data/2017.11.06.19.29.03/microsoft.azure.iot.edge.function.0.3.0.json + + + { + "@id": "https://api.nuget.org/v3/catalog0/data/2017.11.06.22.07.49/dotnettency.container.1.3.2.json", + "@type": [ + "PackageDetails", + "catalog:Permalink" + ], + "authors": "Darrell Tunnell", + "catalog:commitId": "f241ce46-35ba-44c2-bd72-790eb44539a5", + "catalog:commitTimeStamp": "2017-11-06T22:07:49.3270578Z", + "created": "2017-11-06T22:06:53.64Z", + "description": "Container support, for the dotnettency Mutlitenancy library for dotnet standard compatible applications.", + "id": "Dotnettency.Container", + "isPrerelease": false, + "lastEdited": "0001-01-01T00:00:00Z", + "listed": true, + "packageHash": "ig2qG5u7ua4mGifVb1PA1HyDt0pkKWsXzR1t4fBrsOP3ZDRm/1FeNho8G4QD4Pw/bGE+EdOpRe5+0MD+ANw4uw==", + "packageHashAlgorithm": "SHA512", + "packageSize": 7945, + "projectUrl": "https://github.com/dazinator/Dotnettency", + "published": "2017-11-06T22:06:53.64Z", + "requireLicenseAcceptance": false, + "verbatimVersion": "1.3.2", + "version": "1.3.2", + "dependencyGroups": [ + { + "@id": "https://api.nuget.org/v3/catalog0/data/2017.11.06.22.07.49/dotnettency.container.1.3.2.json#dependencygroup/.netstandard1.3", + "@type": "PackageDependencyGroup", + "dependencies": [ + { + "@id": "https://api.nuget.org/v3/catalog0/data/2017.11.06.22.07.49/dotnettency.container.1.3.2.json#dependencygroup/.netstandard1.3/dotnettency", + "@type": "PackageDependency", + "id": "Dotnettency", + "range": "[1.3.2, )" + }, + { + "@id": "https://api.nuget.org/v3/catalog0/data/2017.11.06.22.07.49/dotnettency.container.1.3.2.json#dependencygroup/.netstandard1.3/netstandard.library", + "@type": "PackageDependency", + "id": "NETStandard.Library", + "range": "[1.6.1, )" + }, + { + "@id": "https://api.nuget.org/v3/catalog0/data/2017.11.06.22.07.49/dotnettency.container.1.3.2.json#dependencygroup/.netstandard1.3/microsoft.extensions.dependencyinjection", + "@type": "PackageDependency", + "id": "Microsoft.Extensions.DependencyInjection", + "range": "[1.0.0, )" + } + ], + "targetFramework": ".NETStandard1.3" + } + ], + "packageEntries": [ + { + "@id": "https://api.nuget.org/v3/catalog0/data/2017.11.06.22.07.49/dotnettency.container.1.3.2.json#Dotnettency.Container.nuspec", + "@type": "PackageEntry", + "compressedLength": 478, + "fullName": "Dotnettency.Container.nuspec", + "length": 1016, + "name": "Dotnettency.Container.nuspec" + }, + { + "@id": "https://api.nuget.org/v3/catalog0/data/2017.11.06.22.07.49/dotnettency.container.1.3.2.json#lib/netstandard1.3/Dotnettency.Container.dll", + "@type": "PackageEntry", + "compressedLength": 5751, + "fullName": "lib/netstandard1.3/Dotnettency.Container.dll", + "length": 13312, + "name": "Dotnettency.Container.dll" + } + ], + "tags": [ + "Multitenancy", + "tenant", + "container" + ], + "@context": { + "@vocab": "http://schema.nuget.org/schema#", + "catalog": "http://schema.nuget.org/catalog#", + "xsd": "http://www.w3.org/2001/XMLSchema#", + "dependencies": { + "@id": "dependency", + "@container": "@set" + }, + "dependencyGroups": { + "@id": "dependencyGroup", + "@container": "@set" + }, + "packageEntries": { + "@id": "packageEntry", + "@container": "@set" + }, + "supportedFrameworks": { + "@id": "supportedFramework", + "@container": "@set" + }, + "tags": { + "@id": "tag", + "@container": "@set" + }, + "published": { + "@type": "xsd:dateTime" + }, + "created": { + "@type": "xsd:dateTime" + }, + "lastEdited": { + "@type": "xsd:dateTime" + }, + "catalog:commitTimeStamp": { + "@type": "xsd:dateTime" + } + } +} + + + https://api.nuget.org/v3/catalog0/data/2017.11.06.22.07.49/dotnettency.container.1.3.2.json + + \ No newline at end of file diff --git a/tests/NuGet.Protocol.Catalog.Tests/TestDataHttpMessageHandler.cs b/tests/NuGet.Protocol.Catalog.Tests/TestDataHttpMessageHandler.cs new file mode 100644 index 000000000..c417b9562 --- /dev/null +++ b/tests/NuGet.Protocol.Catalog.Tests/TestDataHttpMessageHandler.cs @@ -0,0 +1,50 @@ +// Copyright (c) .NET Foundation. All rights reserved. +// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information. + +using System; +using System.Collections.Generic; +using System.Net; +using System.Net.Http; +using System.Threading; +using System.Threading.Tasks; + +namespace NuGet.Protocol.Catalog +{ + public class TestDataHttpMessageHandler : HttpMessageHandler + { + private static readonly Dictionary> UrlToGetContent = new Dictionary> + { + { TestData.CatalogIndexUrl, () => TestData.CatalogIndex }, + { TestData.CatalogPageUrl, () => TestData.CatalogPage }, + { TestData.PackageDeleteCatalogLeafUrl, () => TestData.PackageDeleteCatalogLeaf }, + { TestData.PackageDetailsCatalogLeafUrl, () => TestData.PackageDetailsCatalogLeaf }, + }; + + protected override Task SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) + { + return Task.FromResult(Send(request)); + } + + private HttpResponseMessage Send(HttpRequestMessage request) + { + Func getContent; + if (request.Method != HttpMethod.Get + || !UrlToGetContent.TryGetValue(request.RequestUri.AbsoluteUri, out getContent)) + { + return new HttpResponseMessage + { + RequestMessage = request, + StatusCode = HttpStatusCode.NotFound, + Content = new StringContent(string.Empty), + }; + } + + return new HttpResponseMessage + { + RequestMessage = request, + StatusCode = HttpStatusCode.OK, + Content = new StringContent(getContent()), + }; + } + } +}