static async Task ProcessUkprns(long[] ukprns, CancellationToken cancellationToken)
        {
            const int batchSize = 100;
            var       position  = 0;

            while (position <= ukprns.Length)
            {
                var batch = ukprns.Skip(position).Take(batchSize).ToArray();
                _logger.Debug($"Processing {position} to {position + batch.Length} of {ukprns.Length} ukprns");

                var providers = await _ukrlpApiClient.GetProvidersAsync(batch, cancellationToken);

                // Timestamp
                var pointInTime          = DateTime.UtcNow.Date;
                var pointInTimeProviders = providers.Select(establishment => Clone <PointInTimeProvider>(establishment)).ToArray();
                foreach (var pointInTimeEstablishment in pointInTimeProviders)
                {
                    pointInTimeEstablishment.PointInTime = pointInTime;
                }

                foreach (var provider in pointInTimeProviders)
                {
                    await _providerRepository.StoreAsync(provider, cancellationToken);

                    _logger.Debug($"Stored {provider.UnitedKingdomProviderReferenceNumber} in repository");
                }

                position += batchSize;
            }
        }
        public async Task <LearningProvider[]> GetLearningProvidersAsync(string[] ids, string[] fields, bool readFromLive, DateTime?pointInTime, CancellationToken cancellationToken)
        {
            var ukprns = new long[ids.Length];

            for (var i = 0; i < ids.Length; i++)
            {
                long ukprn;
                if (!long.TryParse(ids[i], out ukprn))
                {
                    throw new ArgumentException($"id must be a number (ukprn) but received {ids[i]} at index {i}", nameof(ids));
                }

                if (ids[i].Length != 8)
                {
                    throw new ArgumentException($"UKPRN must be 8 digits but received {ids[i].Length} ({ids[i]}) at index {i}", nameof(ids));
                }

                ukprns[i] = ukprn;
            }

            var providers = readFromLive
                ? await _ukrlpApiClient.GetProvidersAsync(ukprns, cancellationToken)
                : await _providerRepository.GetProvidersAsync(ukprns, pointInTime, cancellationToken);

            var learningProviders = new LearningProvider[ukprns.Length];

            for (var i = 0; i < ukprns.Length; i++)
            {
                var provider = providers.SingleOrDefault(p => p.UnitedKingdomProviderReferenceNumber == ukprns[i]);
                if (provider == null)
                {
                    continue;
                }

                learningProviders[i] = await GetLearningProviderFromUkrlpProviderAsync(provider, fields, cancellationToken);
            }

            return(learningProviders);
        }