// ReSharper disable once UnusedMember.Global
        public async Task PublishMethodologyFiles(
            [QueueTrigger(PublishMethodologyFilesQueue)]
            PublishMethodologyFilesMessage message,
            ExecutionContext executionContext,
            ILogger logger)
        {
            logger.LogInformation("{0} triggered: {1}",
                                  executionContext.FunctionName,
                                  message);

            await _publishingService.PublishMethodologyFiles(message.MethodologyId);

            logger.LogInformation("{0} completed",
                                  executionContext.FunctionName);
        }
Esempio n. 2
0
        private async Task <Either <ActionResult, MethodologyVersion> > UpdateStatus(
            MethodologyVersion methodologyVersionToUpdate,
            MethodologyApprovalUpdateRequest request)
        {
            if (!request.IsStatusUpdateForMethodology(methodologyVersionToUpdate))
            {
                // Status unchanged
                return(methodologyVersionToUpdate);
            }

            return(await
                   CheckCanUpdateStatus(methodologyVersionToUpdate, request.Status)
                   .OnSuccessDo(methodology => CheckMethodologyCanDependOnRelease(methodology, request))
                   .OnSuccessDo(RemoveUnusedImages)
                   .OnSuccess(async methodology =>
            {
                methodology.Status = request.Status;
                methodology.PublishingStrategy = request.PublishingStrategy;
                methodology.ScheduledWithReleaseId = WithRelease == request.PublishingStrategy
                        ? request.WithReleaseId
                        : null;
                methodology.InternalReleaseNote = Approved == request.Status
                        ? request.LatestInternalReleaseNote
                        : null;

                methodology.Updated = DateTime.UtcNow;

                _context.MethodologyVersions.Update(methodology);

                if (await _methodologyVersionRepository.IsPubliclyAccessible(methodology.Id))
                {
                    methodology.Published = DateTime.UtcNow;

                    await _publishingService.PublishMethodologyFiles(methodology.Id);

                    // Invalidate the 'All Methodologies' cache item
                    await _publicBlobCacheService.DeleteItem(new AllMethodologiesCacheKey());
                }

                _context.MethodologyVersions.Update(methodology);
                await _context.SaveChangesAsync();
                return methodology;
            }));
        }