Пример #1
0
        public async Task <Sandbox> AddAsync(Study study, Sandbox newSandbox)
        {
            var user = await _userService.GetCurrentUserAsync();

            newSandbox.CreatedBy             = user.UserName;
            newSandbox.TechnicalContactName  = user.FullName;
            newSandbox.TechnicalContactEmail = user.EmailAddress;

            SandboxPhaseUtil.InitiatePhaseHistory(newSandbox, user);

            newSandbox.Study = study;
            study.Sandboxes.Add(newSandbox);

            await _db.SaveChangesAsync();

            return(newSandbox);
        }
Пример #2
0
        public async Task <SandboxDetails> MoveToNextPhaseAsync(int sandboxId, CancellationToken cancellation = default)
        {
            _logger.LogInformation(_sandboxNextPhaseEventId, "Sandbox {0}: Starting", sandboxId);

            SandboxPhaseHistory newestHistoryItem = null;

            bool dataMightHaveBeenChanged = false;

            try
            {
                var user = await _userService.GetCurrentUserAsync();

                var sandboxFromDb = await GetSandboxForPhaseShift(sandboxId);

                var currentPhaseItem = SandboxPhaseUtil.GetCurrentPhaseHistoryItem(sandboxFromDb);

                if (currentPhaseItem == null)
                {
                    SandboxPhaseUtil.InitiatePhaseHistory(sandboxFromDb, user);
                    currentPhaseItem = SandboxPhaseUtil.GetCurrentPhaseHistoryItem(sandboxFromDb);
                }

                var nextPhase = SandboxPhaseUtil.GetNextPhase(sandboxFromDb);

                await ValidatePhaseMoveThrowIfNot(sandboxFromDb, currentPhaseItem.Phase, nextPhase, cancellation);

                _logger.LogInformation(_sandboxNextPhaseEventId, "Sandbox {0}: Moving from {1} to {2}", sandboxId, currentPhaseItem.Phase, nextPhase);

                newestHistoryItem = new SandboxPhaseHistory()
                {
                    Counter = currentPhaseItem.Counter + 1, Phase = nextPhase, CreatedBy = user.UserName
                };
                dataMightHaveBeenChanged = true;
                sandboxFromDb.PhaseHistory.Add(newestHistoryItem);
                await _db.SaveChangesAsync();

                _logger.LogInformation(_sandboxNextPhaseEventId, "Sandbox {0}: Phase added to db. Proceeding to make data available", sandboxId);

                if (nextPhase == SandboxPhase.DataAvailable)
                {
                    await MakeDatasetsAvailable(sandboxFromDb, cancellation);
                }

                _logger.LogInformation(_sandboxNextPhaseEventId, "Sandbox {0}: Done", sandboxId);

                return(await GetSandboxDetailsInternalAsync(sandboxId));
            }
            catch (Exception ex)
            {
                _logger.LogWarning(_sandboxNextPhaseEventId, ex, "Sandbox {0}: Phase shift failed.", sandboxId);

                if (dataMightHaveBeenChanged)
                {
                    _logger.LogWarning(_sandboxNextPhaseEventId, ex, "Data might have been changed. Rolling back");
                    await MakeDatasetsUnAvailable(sandboxId);
                    await AttemptRollbackPhase(sandboxId, newestHistoryItem);
                }

                throw;
            }
        }