public async Task <IHttpActionResult> UpdateProduct(long id, [FromBody] ProductForUpdateModel model)
{
if (model == null)
{
return(BadRequest(ExceptionMessageModelFactory.BadRequestBody()));
}
ValidateModel(new ProductForUpdateModelValidator(), model);
if (!ModelState.IsValid)
{
return(BadRequest(ExceptionMessageModelFactory
.BadRequestModelStateInvalid(ModelState.Values.SelectMany(x => x.Errors))));
}
var product = await _productRepository.GetProduct(id);
if (product == null)
{
return(Content(HttpStatusCode.BadRequest, ExceptionMessageModelFactory.ResourceNotFound()));
}
_mapper.Map(model, product);
await _productRepository.UpdateProduct(product);
return(NoContent());
}
public async Task <HttpResponseMessage> GetProducts([FromUri] ResourceParameters resourceParameters,
[FromUri] ProductFilterParameters filterParameters)
{
filterParameters = filterParameters ?? new ProductFilterParameters();
resourceParameters = resourceParameters ?? new ResourceParameters();
if (
!_propertyMappingService.ValidMappingExistsFor <ProductEntity, Data.Sqlite.Models.ProductModel>(
resourceParameters.OrderBy))
{
return(Request.CreateResponse(HttpStatusCode.BadRequest,
ExceptionMessageModelFactory.BadRequstOrderByParameters()));
}
if (!_typeHelper.TypeHasProperties <ProductForGetModel>(resourceParameters.Fields))
{
return(Request.CreateResponse(HttpStatusCode.BadRequest,
ExceptionMessageModelFactory.BadRequstFieldsParameters()));
}
var products = await _productRepository.GetProducts(resourceParameters, filterParameters);
// UrlHelper requires the Request to get
var pagedListHelper = new PagedListHelper(new UrlHelper(Request));
var modelResults = _mapper.Map <IEnumerable <ProductForGetModel> >(products);
var response = Request.CreateResponse(HttpStatusCode.OK, modelResults.ShapeData(resourceParameters.Fields));
response.Headers.Add("X-Pagination",
pagedListHelper.AddPaginationMetadataToResponseHeader(products, resourceParameters, filterParameters,
"GetProducts"));
return(response);
}
public async Task <IActionResult> GetProducts(ResourceParameters resourceParameters,
ProductFilterParameters filterParameters)
{
if (!_propertyMappingService.ValidMappingExistsFor <ProductEntity, Data.Sqlite.Models.ProductModel>(resourceParameters.OrderBy))
{
return(BadRequest(ExceptionMessageModelFactory.BadRequstOrderByParameters()));
}
if (!_typeHelper.TypeHasProperties <ProductForGetModel>(resourceParameters.Fields))
{
return(BadRequest(ExceptionMessageModelFactory.BadRequstFieldsParameters()));
}
var products = await _productRepository.GetProducts(resourceParameters, filterParameters);
AddHeaders();
var modelResults = _mapper.Map <IEnumerable <ProductForGetModel> >(products);
return(Ok(modelResults.ShapeData(resourceParameters.Fields)));
// Local method to get create headers. Is this overkill? Probably.
void AddHeaders() => Response.Headers.Add("X-Pagination",
_pagedListHelper.AddPaginationMetadataToResponseHeader(products, resourceParameters, filterParameters,
"GetProducts"));
}
public async Task <IActionResult> PartiallyUpdateProduct(long id,
[FromBody] JsonPatchDocument <ProductForUpdateModel> patchDoc)
{
if (patchDoc == null)
{
return(BadRequest(ExceptionMessageModelFactory.BadRequestBody()));
}
var product = await _productRepository.GetProduct(id);
if (product == null)
{
return(BadRequest(ExceptionMessageModelFactory.ResourceNotFound()));
}
var productToPatch = _mapper.Map <ProductForUpdateModel>(product);
patchDoc.ApplyTo(productToPatch, ModelState);
TryValidateModel(productToPatch);
if (!ModelState.IsValid)
{
return(BadRequest(ExceptionMessageModelFactory
.BadRequestModelStateInvalid(new SerializableError(ModelState))));
}
var updatedProduct = _mapper.Map <ProductEntity>(product);
_mapper.Map(productToPatch, updatedProduct);
await _productRepository.UpdateProduct(updatedProduct);
return(NoContent());
}
public async Task <IActionResult> UpdateProduct(long id, [FromBody] ProductForUpdateModel model)
{
if (model == null)
{
return(BadRequest(ExceptionMessageModelFactory.BadRequestBody()));
}
if (!ModelState.IsValid)
{
return(BadRequest(ExceptionMessageModelFactory
.BadRequestModelStateInvalid(new SerializableError(ModelState))));
}
var product = await _productRepository.GetProduct(id);
if (product == null)
{
return(BadRequest(ExceptionMessageModelFactory.ResourceNotFound()));
}
_mapper.Map(model, product);
await _productRepository.UpdateProduct(product);
return(NoContent());
}
public async Task <IActionResult> CreateSellerForProduct(long productId,
[FromBody] SellerForCreationModel model)
{
if (model == null)
{
return(BadRequest(ExceptionMessageModelFactory.BadRequestBody()));
}
if (!ModelState.IsValid)
{
return(BadRequest(ExceptionMessageModelFactory
.BadRequestModelStateInvalid(new SerializableError(ModelState))));
}
if (!await _productRepository.DoesProductExist(productId))
{
return(NotFound(ExceptionMessageModelFactory.ParentToResourceNotFound()));
}
var seller = _mapper.Map <SellerEntity>(model);
await _sellerRepository.CreateSeller(productId, seller);
var modelResult = _mapper.Map <SellerForGetModel>(seller);
return(CreatedAtRoute("GetSellerForProduct", new { productId, id = modelResult.Id }, modelResult));
}
public async Task <IHttpActionResult> CreateProductCollections([FromBody] IEnumerable <ProductForCreationModel> models)
{
if (models == null)
{
return(BadRequest(ExceptionMessageModelFactory.BadRequestBody()));
}
var validator = new ProductForCreationModelValidator();
foreach (var model in models)
{
ValidateModel(validator, model);
}
//todo: error message does not sure exactly which model caused the error.
if (!ModelState.IsValid)
{
return(BadRequest(ExceptionMessageModelFactory
.BadRequestModelStateInvalid(ModelState.Values.SelectMany(x => x.Errors))));
}
var products = _mapper.Map <IEnumerable <ProductEntity> >(models);
var tasks = products.Select(product => _productRepository.CreateProduct(product));
await Task.WhenAll(tasks);
var modelResults = _mapper.Map <IEnumerable <ProductForGetModel> >(products).ToList();
var ids = string.Join(",", modelResults.Select(model => model.Id));
return(CreatedAtRoute("GetProductCollection", new { ids }, modelResults));
}
public async Task <IActionResult> PartiallyUpdateSeller(long productId, long id,
[FromBody] JsonPatchDocument <SellerForUpdateModel> patchDoc)
{
if (patchDoc == null)
{
return(BadRequest(ExceptionMessageModelFactory.BadRequestBody()));
}
if (!await _productRepository.DoesProductExist(productId))
{
return(NotFound(ExceptionMessageModelFactory.ParentToResourceNotFound()));
}
var sellerFromRepo = await _sellerRepository.GetSellerForProduct(productId, id);
if (sellerFromRepo == null) // New Seller
{
var sellerForUpdate = new SellerForUpdateModel();
patchDoc.ApplyTo(sellerForUpdate, ModelState);
TryValidateModel(sellerForUpdate);
if (!ModelState.IsValid)
{
return(BadRequest(ExceptionMessageModelFactory
.BadRequestModelStateInvalid(new SerializableError(ModelState))));
}
var sellerToAdd = _mapper.Map <SellerEntity>(sellerForUpdate);
sellerToAdd.Id = id;
await _sellerRepository.CreateSeller(productId, sellerToAdd);
var modelResult = _mapper.Map <SellerForGetModel>(sellerToAdd);
return(CreatedAtRoute("GetSellerForProduct", new { productId, id = modelResult.Id }, modelResult));
}
var sellerToPatch = _mapper.Map <SellerForUpdateModel>(sellerFromRepo);
patchDoc.ApplyTo(sellerToPatch, ModelState);
TryValidateModel(sellerToPatch);
if (!ModelState.IsValid)
{
return(BadRequest(ExceptionMessageModelFactory
.BadRequestModelStateInvalid(new SerializableError(ModelState))));
}
var updatedSeller = _mapper.Map <SellerEntity>(sellerFromRepo);
_mapper.Map(sellerToPatch, updatedSeller);
await _sellerRepository.UpdateSeller(updatedSeller);
return(NoContent());
}
public async Task <IActionResult> RemoveSeller(long productId, long id)
{
var seller = await _sellerRepository.GetSellerForProduct(productId, id);
if (seller == null)
{
return(BadRequest(ExceptionMessageModelFactory.ResourceNotFound()));
}
await _sellerRepository.RemoveSeller(seller);
return(NoContent());
}
public async Task <IHttpActionResult> DeleteProduct(long id)
{
var product = await _productRepository.GetProduct(id);
if (product == null)
{
return(BadRequest(ExceptionMessageModelFactory.ResourceNotFound()));
}
await _productRepository.RemoveProduct(product);
return(NoContent());
}
public async Task <IActionResult> GetSellersForProduct(long productId)
{
if (!await _productRepository.DoesProductExist(productId))
{
return(NotFound(ExceptionMessageModelFactory.ParentToResourceNotFound()));
}
var sellers = await _sellerRepository.GetSellersForProduct(productId);
var modelResults = _mapper.Map <IEnumerable <SellerForGetModel> >(sellers);
return(Ok(modelResults));
}
public async Task <IActionResult> AddScene([FromBody] SceneToAddModel model)
{
if (model == null)
{
return(BadRequest(ExceptionMessageModelFactory.BadRequestBody()));
}
if (!ModelState.IsValid)
{
return(BadRequest(ExceptionMessageModelFactory
.BadRequestModelStateInvalid(new SerializableError(ModelState))));
}
var result = await _mediator.Send(model);
return(Ok(result));
}
public async Task <IActionResult> GetSellerForProduct(long productId, long id)
{
if (!await _productRepository.DoesProductExist(productId))
{
return(NotFound(ExceptionMessageModelFactory.ParentToResourceNotFound()));
}
var seller = await _sellerRepository.GetSellerForProduct(productId, id);
if (seller == null)
{
return(NotFound(ExceptionMessageModelFactory.ResourceNotFound()));
}
var result = _mapper.Map <SellerForGetModel>(seller);
return(Ok(result));
}
public async Task <IHttpActionResult> GetProduct(long id, [FromUri] string fields = null)
{
if (!_typeHelper.TypeHasProperties <ProductForGetModel>(fields))
{
return(BadRequest(ExceptionMessageModelFactory.BadRequstFieldsParameters()));
}
var product = await _productRepository.GetProduct(id);
if (product == null)
{
return(NotFound(ExceptionMessageModelFactory.ResourceNotFound()));
}
var model = _mapper.Map <ProductForGetModel>(product);
return(Ok(model.ShapeData(fields)));
}
public async Task <IHttpActionResult> UpsertSeller(long productId, long id,
[FromBody] SellerForUpdateModel model)
{
if (model == null)
{
return(BadRequest(ExceptionMessageModelFactory.BadRequestBody()));
}
ValidateModel(new SellerForUpdateModelValidator(), model);
if (!ModelState.IsValid)
{
return(BadRequest(ExceptionMessageModelFactory
.BadRequestModelStateInvalid(ModelState.Values.SelectMany(x => x.Errors))));
}
if (!await _productRepository.DoesProductExist(productId))
{
return(NotFound(ExceptionMessageModelFactory.ParentToResourceNotFound()));
}
var sellerFromRepo = await _sellerRepository.GetSellerForProduct(productId, id);
if (sellerFromRepo == null) // New Seller
{
if (await _sellerRepository.DoesSellerExist(id))
{
return
(BadRequest(
ExceptionMessageModelFactory.BadRequestParentMismatch("Seller id exist under another product")));
}
var sellerToAdd = _mapper.Map <SellerEntity>(model);
sellerToAdd.Id = id;
await _sellerRepository.CreateSeller(productId, sellerToAdd);
var modelResult = _mapper.Map <SellerForGetModel>(sellerToAdd);
return(CreatedAtRoute("GetSellerForProduct", new { productId, id = modelResult.Id }, modelResult));
}
_mapper.Map(model, sellerFromRepo);
await _sellerRepository.UpdateSeller(sellerFromRepo);
return(NoContent());
}
public async Task <IActionResult> CreateProduct([FromBody] ProductForCreationModel model)
{
if (model == null)
{
return(BadRequest(ExceptionMessageModelFactory.BadRequestBody()));
}
if (!ModelState.IsValid)
{
return(BadRequest(ExceptionMessageModelFactory
.BadRequestModelStateInvalid(new SerializableError(ModelState))));
}
var product = _mapper.Map <ProductEntity>(model);
await _productRepository.CreateProduct(product);
var modelResult = _mapper.Map <ProductForGetModel>(product);
return(CreatedAtRoute("GetProduct", new { id = product.Id }, modelResult));
}
public async Task <IHttpActionResult> PartiallyUpdateProduct(long id,
[FromBody] JsonPatchDocument <ProductForUpdateModel> patchDoc)
{
if (patchDoc == null)
{
return(BadRequest(ExceptionMessageModelFactory.BadRequestBody()));
}
var product = await _productRepository.GetProduct(id);
if (product == null)
{
return(BadRequest(ExceptionMessageModelFactory.ResourceNotFound()));
}
var productToPatch = _mapper.Map <ProductForUpdateModel>(product);
try
{
patchDoc.ApplyTo(productToPatch);
}
catch (Exception ex)
{
ModelState.AddModelError("ApplyPatch", ex.Message);
}
ValidateModel(new ProductForUpdateModelValidator(), productToPatch);
if (!ModelState.IsValid)
{
return(BadRequest(ExceptionMessageModelFactory
.BadRequestModelStateInvalid(ModelState.Values.SelectMany(x => x.Errors))));
}
var updatedProduct = _mapper.Map <ProductEntity>(product);
_mapper.Map(productToPatch, updatedProduct);
await _productRepository.UpdateProduct(updatedProduct);
return(NoContent());
}
public async Task <IActionResult> GetProductCollection(
[ModelBinder(BinderType = typeof(ArrayModelBinder))] IEnumerable <long> ids)
{
if (ids == null)
{
return(BadRequest(ExceptionMessageModelFactory.BadRequestBody()));
}
ids = ids.ToList();
var tasks = ids.Select(id => _productRepository.GetProduct(id));
var products = (await Task.WhenAll(tasks)).Where(x => x != null).ToList();
if (ids.Count() != products.Count)
{
return(NotFound(ExceptionMessageModelFactory.ResourceNotFound(
$"Expected to retrieve {ids.Count()} but only able to retrieve {products.Count}")));
}
var models = _mapper.Map <IEnumerable <ProductForGetModel> >(products);
return(Ok(models));
}
public async Task <IActionResult> CreateProductCollections([FromBody] IEnumerable <ProductForCreationModel> models)
{
if (models == null)
{
return(BadRequest(ExceptionMessageModelFactory.BadRequestBody()));
}
if (!ModelState.IsValid)
{
return(BadRequest(ExceptionMessageModelFactory
.BadRequestModelStateInvalid(new SerializableError(ModelState))));
}
var products = _mapper.Map <IEnumerable <ProductEntity> >(models);
var tasks = products.Select(product => _productRepository.CreateProduct(product));
await Task.WhenAll(tasks);
var modelResults = _mapper.Map <IEnumerable <ProductForGetModel> >(products);
var ids = string.Join(",", modelResults.Select(model => model.Id));
return(CreatedAtRoute("GetProductCollection", new { ids }, modelResults));
}
public async Task <IHttpActionResult> CreateProduct([FromBody] ProductForCreationModel model)
{
if (model == null)
{
return(BadRequest(ExceptionMessageModelFactory.BadRequestBody()));
}
ValidateModel(new ProductForCreationModelValidator(), model);
if (!ModelState.IsValid)
{
return(BadRequest(ExceptionMessageModelFactory
.BadRequestModelStateInvalid(ModelState.Values.SelectMany(x => x.Errors))));
}
var product = _mapper.Map <ProductEntity>(model);
await _productRepository.CreateProduct(product);
var modelResult = _mapper.Map <ProductForGetModel>(product);
return(CreatedAtRoute("GetProduct", new { id = product.Id }, modelResult));
}
