public async Task <IActionResult> GetTemplateVersions(FindTemplateVersionQuery query)
        {
            ValidationResult validationResult = await _validatorFactory.Validate(query);

            if (!validationResult.IsValid)
            {
                return(validationResult.AsBadRequest());
            }

            if (!validationResult.IsValid)
            {
                return(validationResult.AsBadRequest());
            }

            IEnumerable <TemplateSummaryResponse> templateVersionResponses =
                await _templateBuilderService.FindVersionsByFundingStreamAndPeriod(query);

            return(Ok(templateVersionResponses));
        }
        public async Task <IEnumerable <TemplateVersion> > FindByFundingStreamAndPeriod(FindTemplateVersionQuery query)
        {
            Guard.IsNullOrWhiteSpace(query.FundingStreamId, nameof(query.FundingStreamId));
            Guard.IsNullOrWhiteSpace(query.FundingPeriodId, nameof(query.FundingPeriodId));

            query.Statuses ??= new List <TemplateStatus>();
            if (query.Statuses.Any())
            {
                return(await CosmosRepository.Query <TemplateVersion>(x =>
                                                                      x.Content.FundingStreamId == query.FundingStreamId &&
                                                                      x.Content.FundingPeriodId == query.FundingPeriodId &&
                                                                      query.Statuses.Contains(x.Content.Status)));
            }

            return(await CosmosRepository.Query <TemplateVersion>(x =>
                                                                  x.Content.FundingStreamId == query.FundingStreamId &&
                                                                  x.Content.FundingPeriodId == query.FundingPeriodId));
        }
Beispiel #3
0
        public async Task <IEnumerable <TemplateSummaryResponse> > FindVersionsByFundingStreamAndPeriod(FindTemplateVersionQuery query)
        {
            List <TemplateSummaryResponse> results  = new List <TemplateSummaryResponse>();
            List <TemplateVersion>         versions = (await _templateVersionRepository.FindByFundingStreamAndPeriod(query)).ToList();

            var tasks = new List <Task <Template> >();

            foreach (var templateId in versions.Select(v => v.TemplateId).Distinct())
            {
                tasks.Add(_templateRepository.GetTemplate(templateId));
            }

            await Task.WhenAll(tasks.ToArray());

            foreach (var task in tasks)
            {
                Template template = await task;
                results.AddRange(versions
                                 .Where(v => v.TemplateId == template.TemplateId)
                                 .Select(v => MapSummaryResponse(v, template)));
            }

            return(results
                   .OrderByDescending(x => x.LastModificationDate));
        }