public async Task <IActionResult> CreateSpecification([FromBody] CreateSpecificationViewModel viewModel)
{
if (!ModelState.IsValid)
{
return(new BadRequestObjectResult(ModelState));
}
var fundingStreamIds = new List <string> {
viewModel.FundingStreamId
};
IEnumerable <FundingStreamPermission> fundingStreamPermissions = await _authorizationHelper.GetUserFundingStreamPermissions(User);
bool hasPermissionsOnAllTheseStreams = fundingStreamIds
.All(fundingStreamId => fundingStreamPermissions
.Any(x =>
x.FundingStreamId == fundingStreamId && x.CanCreateSpecification));
if (!hasPermissionsOnAllTheseStreams)
{
return(new ForbidResult());
}
CreateSpecificationModel specification = new CreateSpecificationModel
{
Description = viewModel.Description,
Name = viewModel.Name,
FundingPeriodId = viewModel.FundingPeriodId,
FundingStreamIds = fundingStreamIds,
ProviderVersionId = viewModel.ProviderVersionId,
AssignedTemplateIds = viewModel.AssignedTemplateIds,
ProviderSnapshotId = viewModel.ProviderSnapshotId
};
ValidatedApiResponse <SpecificationSummary> result = await _specificationsApiClient.CreateSpecification(specification);
if (result.IsBadRequest(out BadRequestObjectResult badRequest))
{
return(badRequest);
}
if (result.StatusCode.IsSuccess())
{
return(new OkObjectResult(result.Content));
}
return(new InternalServerErrorResult($"Unable to create specification - result '{result.StatusCode}'"));
}
public async Task <IActionResult> OnPostAsync(string fundingPeriodId = null)
{
if (!ModelState.IsValid)
{
await TaskHelper.WhenAllAndThrow(PopulateFundingPeriods(fundingPeriodId), PopulateFundingStreams());
IsAuthorizedToCreate = FundingStreams.Count() != 0;
return(Page());
}
CreateSpecificationModel specification = _mapper.Map <CreateSpecificationModel>(CreateSpecificationViewModel);
if (!await _authorizationHelper.DoesUserHavePermission(User, specification.FundingStreamIds, FundingStreamActionTypes.CanCreateSpecification))
{
return(new ForbidResult());
}
ValidatedApiResponse <Specification> result = await _specsClient.CreateSpecification(specification);
if (result.StatusCode.IsSuccess())
{
return(Redirect($"/specs/policies/{result.Content.Id}?operationType=SpecificationCreated&operationId={result.Content.Id}"));
}
else if (result.StatusCode == HttpStatusCode.BadRequest)
{
result.AddValidationResultErrors(ModelState);
await TaskHelper.WhenAllAndThrow(PopulateFundingPeriods(fundingPeriodId), PopulateFundingStreams());
return(Page());
}
else
{
return(new InternalServerErrorResult($"Unable to create specification - result '{result.StatusCode}'"));
}
}
private async Task <Specification> GenerateSpecification(SpecGeneratorConfiguration configuration)
{
string periodId = configuration.PeriodId;
if (string.IsNullOrWhiteSpace(periodId))
{
ApiResponse <IEnumerable <Reference> > periodResponse = await _specsClient.GetFundingPeriods();
Reference firstPeriod = periodResponse.Content.First();
periodId = firstPeriod.Id;
}
IEnumerable <string> fundingStreamIds = configuration.FundingStreamIds;
if (fundingStreamIds == null || !fundingStreamIds.Any())
{
ApiResponse <IEnumerable <FundingStream> > fundingStreamResponse = await _specsClient.GetFundingStreams();
fundingStreamIds = new string[] { fundingStreamResponse.Content.First().Id };
}
CreateSpecificationModel createModel = new CreateSpecificationModel()
{
Name = configuration.SpecificationName,
FundingPeriodId = periodId,
FundingStreamIds = fundingStreamIds,
Description = "SpecGenerator " + DateTime.Now.ToLongDateString(),
};
_logger.Information("Generating specification called '{Name}' in period '{FundingPeriodId}'", createModel.Name, createModel.FundingPeriodId);
ValidatedApiResponse <Specification> specificationResult = await _specsClient.CreateSpecification(createModel);
_logger.Information("Created Specification {Id}", specificationResult.Content.Id);
return(specificationResult.Content);
}
public Task <ValidatedApiResponse <Specification> > CreateSpecification(CreateSpecificationModel specification)
{
Guard.ArgumentNotNull(specification, nameof(specification));
return(ValidatedPostAsync <Specification, CreateSpecificationModel>("specifications", specification));
}
public async Task <ValidatedApiResponse <SpecificationVersion> > CreateSpecification(CreateSpecificationModel specification)
{
Guard.ArgumentNotNull(specification, nameof(specification));
return(await ValidatedPostAsync <SpecificationVersion, CreateSpecificationModel>($"{UrlRoot}/specifications", specification));
}
public async Task OnPostAsync_GivenViewModelIsValid_ReturnsRedirect()
{
//Arrange
const string specName = "spec name";
CreateSpecificationModel createModel = new CreateSpecificationModel
{
Name = specName,
Description = "description",
FundingStreamIds = new[] { "fs1" },
FundingPeriodId = "fp1"
};
ApiResponse <Specification> existingSpecificationResponse = new ApiResponse <Specification>(HttpStatusCode.NotFound);
ISpecsApiClient apiClient = CreateApiClient();
apiClient
.GetSpecificationByName(Arg.Is(specName))
.Returns(existingSpecificationResponse);
Specification createdSpecification = new Specification()
{
Id = "specId",
};
apiClient
.CreateSpecification(Arg.Any <CreateSpecificationModel>())
.Returns(new ValidatedApiResponse <Specification>(HttpStatusCode.OK, createdSpecification));
IMapper mapper = CreateMapper();
mapper
.Map <CreateSpecificationModel>(Arg.Any <CreateSpecificationViewModel>())
.Returns(createModel);
IAuthorizationHelper authorizationHelper = Substitute.For <IAuthorizationHelper>();
authorizationHelper
.DoesUserHavePermission(Arg.Any <ClaimsPrincipal>(), Arg.Any <IEnumerable <string> >(), Arg.Is(FundingStreamActionTypes.CanCreateSpecification))
.Returns(true);
CreateSpecificationPageModel pageModel = CreatePageModel(apiClient, mapper, authorizationHelper);
pageModel.CreateSpecificationViewModel = new CreateSpecificationViewModel
{
Name = specName,
Description = "description",
FundingStreamIds = new[] { "fs1" },
FundingPeriodId = "fp1"
};
//Act
IActionResult result = await pageModel.OnPostAsync();
//Assert
result
.Should()
.BeOfType <RedirectResult>();
RedirectResult redirectResult = result as RedirectResult;
redirectResult
.Url
.Should()
.Be("/specs/policies/specId?operationType=SpecificationCreated&operationId=specId");
}
public Task <ValidatedApiResponse <SpecificationSummary> > CreateSpecification(CreateSpecificationModel specification)
{
throw new NotImplementedException();
}
