public async Task CreateReleaseStatus()
{
var releaseStatusViewModel = new ReleaseStatusCreateViewModel();
var returnedReleaseViewModel = new ReleaseViewModel();
var mocks = Mocks();
mocks
.ReleaseApprovalService
.Setup(s => s.CreateReleaseStatus(_releaseId, releaseStatusViewModel))
.ReturnsAsync(Unit.Instance);
mocks
.ReleaseService
.Setup(s => s.GetRelease(_releaseId))
.ReturnsAsync(returnedReleaseViewModel);
var controller = ReleasesControllerWithMocks(mocks);
// Call the method under test
var result = await controller.CreateReleaseStatus(releaseStatusViewModel, _releaseId);
VerifyAllMocks(mocks);
result.AssertOkResult(returnedReleaseViewModel);
}
public async Task <ActionResult <ReleaseViewModel> > CreateReleaseStatus(ReleaseStatusCreateViewModel request,
Guid releaseId)
{
return(await _releaseApprovalService
.CreateReleaseStatus(releaseId, request)
.OnSuccess(_ => _releaseService.GetRelease(releaseId))
.HandleFailuresOrOk());
}
public async Task <Either <ActionResult, Unit> > CreateReleaseStatus(
Guid releaseId, ReleaseStatusCreateViewModel request)
{
return(await _persistenceHelper
.CheckEntityExists <Release>(releaseId, ReleaseChecklistService.HydrateReleaseForChecklist)
.OnSuccess(_userService.CheckCanUpdateRelease)
.OnSuccessDo(release => _userService.CheckCanUpdateReleaseStatus(release, request.ApprovalStatus))
.OnSuccess(async release =>
{
if (request.ApprovalStatus != ReleaseApprovalStatus.Approved && release.Published.HasValue)
{
return ValidationActionResult(PublishedReleaseCannotBeUnapproved);
}
if (request.ApprovalStatus == ReleaseApprovalStatus.Approved &&
request.PublishMethod == PublishMethod.Scheduled &&
!request.PublishScheduledDate.HasValue)
{
return ValidationActionResult(ApprovedReleaseMustHavePublishScheduledDate);
}
var oldStatus = release.ApprovalStatus;
release.ApprovalStatus = request.ApprovalStatus;
release.NextReleaseDate = request.NextReleaseDate;
release.PublishScheduled = request.PublishMethod == PublishMethod.Immediate &&
request.ApprovalStatus == ReleaseApprovalStatus.Approved
? DateTime.UtcNow
: request.PublishScheduledDate;
// NOTE: Subscribers should be notified if the release is approved and isn't amended,
// OR if the release is an amendment, is approved, and NotifySubscribers is true
var notifySubscribers = request.ApprovalStatus == ReleaseApprovalStatus.Approved &&
(!release.Amendment || request.NotifySubscribers.HasValue && request.NotifySubscribers.Value);
var releaseStatus = new ReleaseStatus
{
Release = release,
InternalReleaseNote = request.LatestInternalReleaseNote,
NotifySubscribers = notifySubscribers,
ApprovalStatus = request.ApprovalStatus,
Created = DateTime.UtcNow,
CreatedById = _userService.GetUserId()
};
return await ValidateReleaseWithChecklist(release)
.OnSuccessDo(() => RemoveUnusedImages(release.Id))
.OnSuccessVoid(async() =>
{
_context.Releases.Update(release);
await _context.AddAsync(releaseStatus);
await _context.SaveChangesAsync();
// Only need to inform Publisher if changing release approval status to or from Approved
if (oldStatus == ReleaseApprovalStatus.Approved ||
request.ApprovalStatus == ReleaseApprovalStatus.Approved)
{
await _publishingService.ReleaseChanged(
releaseId,
releaseStatus.Id,
request.PublishMethod == PublishMethod.Immediate
);
}
_context.Update(release);
await _context.SaveChangesAsync();
if (request.ApprovalStatus == ReleaseApprovalStatus.Approved)
{
await _preReleaseUserService.SendPreReleaseUserInviteEmails(release.Id);
}
});
}));
}
