private static List <MinPackage> GetSortedMinPackages(JObject mirrorJson, bool ignoreDeleted)
        {
            var list        = new List <MinPackage>();
            var arrayObject = mirrorJson[PackageIndexKey];

            if (arrayObject == null)
            {
                return(list);
            }

            var array = arrayObject as JArray;

            foreach (var item in array)
            {
                var jObject = item as JObject;
                if (jObject != null)
                {
                    var minPackage   = MinPackage.GetMinPackage(jObject);
                    var deletedToken = jObject[DeletedKey];
                    if (!ignoreDeleted || deletedToken == null)
                    {
                        list.Add(minPackage);
                    }
                }
            }

            list.Sort();
            return(list);
        }
        private static async Task SetListedPackages(Uri sourceUri, SqlConnectionStringBuilder cstr, List <MinPackage> destinationPackages, DateTime lastCreated)
        {
            var unlistedDataServicePackagesInSource = GetUnlistedPackages(sourceUri, lastCreated);

            NuGetV2RepositoryMirrorPackageDeletorEventSource.Log.SourceUnlistedPackagesCount(unlistedDataServicePackagesInSource.Count);
            var unlistedMinPackagesInDestination = destinationPackages.Where(p => !p.SourceJObject.Value <bool>(ListedKey)).ToList();

            NuGetV2RepositoryMirrorPackageDeletorEventSource.Log.DestinationUnlistedPackagesCount(unlistedMinPackagesInDestination.Count);
            List <MinPackage> unlistedMinPackagesInSource = new List <MinPackage>();

            foreach (var dataServicePackageWithCreated in unlistedDataServicePackagesInSource)
            {
                if (dataServicePackageWithCreated.IsListed)
                {
                    throw new InvalidOperationException("Package returned as unlisted from the source is listed. WRONG!");
                }
                var minPackage = destinationPackages.Where(mp => MinPackage.Equals(mp, dataServicePackageWithCreated)).SingleOrDefault();
                if (minPackage != null)
                {
                    unlistedMinPackagesInSource.Add(minPackage);
                }
            }

            var packagesToBeListedInDestination = unlistedMinPackagesInDestination.Where(p => !unlistedMinPackagesInSource.Contains(p)).ToList();

            NuGetV2RepositoryMirrorPackageDeletorEventSource.Log.PackagesToBeListedCount(packagesToBeListedInDestination.Count);
            var packagesToBeUnlistedInDestination = unlistedMinPackagesInSource.Where(p => !unlistedMinPackagesInDestination.Contains(p)).ToList();

            NuGetV2RepositoryMirrorPackageDeletorEventSource.Log.PackagesToBeUnlistedCount(packagesToBeUnlistedInDestination.Count);

            using (var connection = new SqlConnection(cstr.ConnectionString))
            {
                await connection.OpenAsync();

                // Set packages as listed
                foreach (var listedPackage in packagesToBeListedInDestination)
                {
                    await SetListed(connection, listedPackage.SourceJObject, listedPackage.Id, listedPackage.SemanticVersion.ToString(), isListed : true);
                }

                // Set packages as unlisted
                foreach (var unlistedPackage in packagesToBeUnlistedInDestination)
                {
                    await SetListed(connection, unlistedPackage.SourceJObject, unlistedPackage.Id, unlistedPackage.SemanticVersion.ToString(), isListed : false);
                }
            }
        }