private Task ConsumeSpecificationInformation(CancellationToken cancellationToken,
                                                     dynamic context,
                                                     IEnumerable <MergeSpecificationRequest> items)
        {
            ConcurrentDictionary <string, FundingPeriod> fundingPeriods = ((MergeContext)context).FundingPeriods;

            foreach (MergeSpecificationRequest mergeSpecificationRequest in items)
            {
                SpecificationInformation requestSpecificationInformation = mergeSpecificationRequest.SpecificationInformation;

                _logger.Information($"Merging specification information {requestSpecificationInformation.Name} for provider id {mergeSpecificationRequest.ProviderId}");

                ProviderWithResultsForSpecifications providerWithResultsForSpecifications = GetProviderWithResultsForSpecificationsForProviderId(mergeSpecificationRequest.ProviderId);

                SpecificationInformation specificationInformation = new SpecificationInformation
                {
                    Id               = requestSpecificationInformation.Id,
                    Name             = requestSpecificationInformation.Name,
                    LastEditDate     = requestSpecificationInformation.LastEditDate,
                    FundingPeriodId  = requestSpecificationInformation.FundingPeriodId,
                    FundingPeriodEnd = fundingPeriods.TryGetValue(requestSpecificationInformation.FundingPeriodId, out FundingPeriod fundingPeriod) ? fundingPeriod.EndDate : (DateTimeOffset?)null
                };

                providerWithResultsForSpecifications.MergeSpecificationInformation(specificationInformation);
            }

            return(Task.CompletedTask);
        }
コード例 #2
0
        private async Task MergeSpecificationInformationForProviderBatch(SpecificationInformation specificationInformation,
                                                                         IEnumerable <string> providerIds,
                                                                         ConcurrentDictionary <string, FundingPeriod> fundingPeriods)
        {
            LogInformation($"Merging specification information for specification {specificationInformation.Id} into summary for provider batch with length {providerIds.Count()}");

            foreach (string providerId in providerIds)
            {
                LogInformation($"Merging specification information for specification {specificationInformation.Id} into summary for provider {providerId}");

                ProviderWithResultsForSpecifications providerWithResultsForSpecifications = await GetProviderWithResultsByProviderId(providerId);

                providerWithResultsForSpecifications ??= new ProviderWithResultsForSpecifications
                {
                    Provider = new ProviderInformation
                    {
                        Id = providerId
                    }
                };

                await EnsureFundingPeriodEndDateQueried(specificationInformation, fundingPeriods);

                providerWithResultsForSpecifications.MergeSpecificationInformation(specificationInformation);

                if (providerWithResultsForSpecifications.GetIsDirty())
                {
                    await _results.UpsertSpecificationWithProviderResults(providerWithResultsForSpecifications);
                }
            }

            LogInformation($"Completed merging specification information for specification {specificationInformation.Id} into summary for provider batch with length {providerIds.Count()}");
        }