public async Task <IActionResult> Create([FromBody] ContentPageModel upsertContentPageModel)
{
logger.LogInformation($"{nameof(Create)} has been called");
if (upsertContentPageModel == null)
{
return(BadRequest());
}
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var existingDocument = await contentPageService.GetByIdAsync(upsertContentPageModel.DocumentId).ConfigureAwait(false);
if (existingDocument != null)
{
return(new StatusCodeResult((int)HttpStatusCode.AlreadyReported));
}
var response = await contentPageService.UpsertAsync(upsertContentPageModel).ConfigureAwait(false);
logger.LogInformation($"{nameof(Create)} has upserted content for: {upsertContentPageModel.Category}/{upsertContentPageModel.CanonicalName} with response code {response}");
return(new StatusCodeResult((int)response));
}
public async Task <HttpStatusCode> ProcessContentAsync(Uri url, Guid contentId)
{
if (url == null)
{
throw new ArgumentNullException(nameof(url));
}
url = Combine(url.ToString(), "true?checkAncestryById=true"); // This enables the multiDirectional support needed for page locations
var apiDataModel = await cmsApiService.GetItemAsync <CmsApiDataModel>(url).ConfigureAwait(false);
var contentPageModel = mapper.Map <ContentPageModel>(apiDataModel);
if (contentPageModel == null)
{
return(HttpStatusCode.NoContent);
}
if (!TryValidateModel(contentPageModel))
{
return(HttpStatusCode.BadRequest);
}
var existingContentPageModel = await contentPageService.GetByIdAsync(contentId).ConfigureAwait(false);
var contentResult = await eventMessageService.UpdateAsync(contentPageModel).ConfigureAwait(false);
if (contentResult == HttpStatusCode.NotFound)
{
contentResult = await eventMessageService.CreateAsync(contentPageModel).ConfigureAwait(false);
}
if (contentResult == HttpStatusCode.OK || contentResult == HttpStatusCode.Created)
{
await eventGridService.CompareAndSendEventAsync(existingContentPageModel, contentPageModel).ConfigureAwait(false);
var contentItemIds = contentPageModel.AllContentItemIds;
contentItemIds.AddRange(contentPageModel.AllPageLocationIds);
contentCacheService.AddOrReplace(contentId, contentItemIds);
}
return(contentResult);
}
public async Task <HttpStatusCode> CreateAsync(TModel?upsertDocumentModel)
{
if (upsertDocumentModel == null)
{
return(HttpStatusCode.BadRequest);
}
var existingDocument = await contentPageService.GetByIdAsync(upsertDocumentModel.Id).ConfigureAwait(false);
if (existingDocument != null)
{
return(HttpStatusCode.AlreadyReported);
}
upsertDocumentModel.PageLocation = ExtractPageLocation(upsertDocumentModel);
var response = await contentPageService.UpsertAsync(upsertDocumentModel).ConfigureAwait(false);
logger.LogInformation($"{nameof(CreateAsync)} has upserted content for: {upsertDocumentModel.CanonicalName} with response code {response}");
return(response);
}
public async Task <HttpStatusCode> ProcessContentAsync(Uri url, Guid contentId)
{
var apiDataModel = await cmsApiService.GetItemAsync <CmsApiDataModel>(url).ConfigureAwait(false);
var contentPageModel = mapper.Map <ContentPageModel>(apiDataModel);
if (contentPageModel == null)
{
return(HttpStatusCode.NoContent);
}
if (!TryValidateModel(contentPageModel))
{
return(HttpStatusCode.BadRequest);
}
var existingContentPageModel = await contentPageService.GetByIdAsync(contentId).ConfigureAwait(false);
var contentResult = await eventMessageService.UpdateAsync(contentPageModel).ConfigureAwait(false);
if (contentResult == HttpStatusCode.NotFound)
{
contentResult = await eventMessageService.CreateAsync(contentPageModel).ConfigureAwait(false);
}
if (contentResult == HttpStatusCode.OK || contentResult == HttpStatusCode.Created)
{
await eventGridService.CompareAndSendEventAsync(existingContentPageModel, contentPageModel).ConfigureAwait(false);
var contentItemIds = contentPageModel.AllContentItemIds;
contentItemIds.AddRange(contentPageModel.AllPageLocationIds);
contentCacheService.AddOrReplace(contentId, contentItemIds);
}
return(contentResult);
}
public async Task ApiControllerDocuemntReturnsSuccess()
{
// arrange
const HttpStatusCode expectedStatusCode = HttpStatusCode.OK;
var expectedContentPageModel = new ContentPageModel
{
Id = Guid.NewGuid(),
CanonicalName = "test-test",
RedirectLocations = new List <string>
{
"/test/test",
},
Url = new Uri("http://www.test.com"),
};
var expectedGetIndexModel = new GetIndexModel
{
Locations = expectedContentPageModel.RedirectLocations,
};
A.CallTo(() => fakeContentPageService.GetByIdAsync(A <Guid> .Ignored, A <string> .Ignored)).Returns(expectedContentPageModel);
A.CallTo(() => fakeMapper.Map <GetIndexModel>(expectedContentPageModel)).Returns(expectedGetIndexModel);
using var controller = new ApiController(logger, fakeContentPageService, fakeMapper);
// act
var result = await controller.Document(expectedContentPageModel.Id).ConfigureAwait(false);
// assert
A.CallTo(() => fakeContentPageService.GetByIdAsync(A <Guid> .Ignored, A <string> .Ignored)).MustHaveHappenedOnceExactly();
A.CallTo(() => fakeMapper.Map <GetIndexModel>(expectedContentPageModel)).MustHaveHappenedOnceExactly();
var jsonResult = Assert.IsType <OkObjectResult>(result);
var modelResult = Assert.IsAssignableFrom <GetIndexModel>(jsonResult.Value);
Assert.Equal((int)expectedStatusCode, jsonResult.StatusCode);
Assert.Equal(expectedGetIndexModel, modelResult);
}
public async Task <HttpStatusCode> CreateAsync(TModel?upsertDocumentModel)
{
if (upsertDocumentModel == null)
{
return(HttpStatusCode.BadRequest);
}
var existingDocument = await contentPageService.GetByIdAsync(upsertDocumentModel.Id).ConfigureAwait(false);
if (existingDocument != null)
{
return(HttpStatusCode.AlreadyReported);
}
var beforePageLocationUpdate = JsonConvert.SerializeObject(upsertDocumentModel);
upsertDocumentModel.PageLocation = ExtractPageLocation(upsertDocumentModel);
if (string.IsNullOrEmpty(upsertDocumentModel.PageLocation))
{
logger.LogError(
"PageLocation ({PageLocation}) and/or PartitionKey ({PartitionKey}) is empty or null. Document before = {SerialisedDocumentBefore}. Document = {SerialisedDocument}",
upsertDocumentModel.PageLocation,
upsertDocumentModel.PartitionKey,
beforePageLocationUpdate,
JsonConvert.SerializeObject(upsertDocumentModel));
return(HttpStatusCode.BadRequest);
}
var response = await contentPageService.UpsertAsync(upsertDocumentModel).ConfigureAwait(false);
logger.LogInformation($"{nameof(CreateAsync)} has upserted content for: {upsertDocumentModel.CanonicalName} with response code {response}");
return(response);
}
public async Task <IActionResult> Document(Guid id)
{
var contentPageModel = await contentPageService.GetByIdAsync(id).ConfigureAwait(false);
if (contentPageModel != null)
{
var getIndexModel = mapper.Map <GetIndexModel>(contentPageModel);
logger.LogInformation($"{nameof(Document)} has succeeded");
return(Ok(getIndexModel));
}
logger.LogWarning($"{nameof(Document)} has returned with no content");
return(NoContent());
}
public async Task EventMessageServiceCreateAsyncReturnsSuccess()
{
// arrange
ContentPageModel?existingContentPageModel = null;
var contentPageModel = A.Fake <ContentPageModel>();
contentPageModel.PageLocations = new List <PageLocationModel>
{
new PageLocationModel(),
};
var expectedResult = HttpStatusCode.OK;
A.CallTo(() => fakeContentPageService.GetByIdAsync(A <Guid> .Ignored, A <string> .Ignored)).Returns(existingContentPageModel);
A.CallTo(() => fakeContentPageService.UpsertAsync(A <ContentPageModel> .Ignored)).Returns(expectedResult);
var eventMessageService = new EventMessageService <ContentPageModel>(fakeLogger, fakeContentPageService);
// act
var result = await eventMessageService.CreateAsync(contentPageModel).ConfigureAwait(false);
// assert
A.CallTo(() => fakeContentPageService.GetByIdAsync(A <Guid> .Ignored, A <string> .Ignored)).MustHaveHappenedOnceExactly();
A.CallTo(() => fakeContentPageService.UpsertAsync(A <ContentPageModel> .Ignored)).MustHaveHappenedOnceExactly();
A.Equals(result, expectedResult);
}
public async Task <IDictionary <string, ContentPage> > LookupByIdAsync(IEnumerable <string> ids)
{
var result = await _contentPageService.GetByIdAsync(ids.ToList());
return(result.ToDictionary(x => x.Id));
}
