Refactor Put methods to simplify update logic

Author: KrzysztofPajak

src/Modules/Grand.Module.Api/Controllers/BrandController.cs

@@ -70,18 +70,14 @@ public async Task<IActionResult> Post([FromBody] BrandDto model)
 
     [EndpointDescription("Update entity in Brand")]
     [EndpointName("UpdateBrand")]
-    [HttpPut("{key}")]
+    [HttpPut]
     [ProducesResponseType((int)HttpStatusCode.Forbidden)]
     [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(BrandDto))]
     [ProducesResponseType((int)HttpStatusCode.BadRequest)]
-    [ProducesResponseType((int)HttpStatusCode.NotFound)]
-    public async Task<IActionResult> Put([FromRoute] string key, [FromBody] BrandDto model)
+    public async Task<IActionResult> Put([FromBody] BrandDto model)
     {
         if (!await _permissionService.Authorize(PermissionSystemName.Brands)) return Forbid();
 
-        var brand = await _mediator.Send(new GetGenericQuery<BrandDto, Brand>(key));
-        if (!brand.Any()) return NotFound();
-
         model = await _mediator.Send(new UpdateBrandCommand { Model = model });
         return Ok(model);
     }

src/Modules/Grand.Module.Api/Controllers/CategoryController.cs

@@ -72,18 +72,14 @@ public async Task<IActionResult> Post([FromBody] CategoryDto model)
 
     [EndpointDescription("Update entity in Category")]
     [EndpointName("UpdateCategory")]
-    [HttpPut("{key}")]
+    [HttpPut]
     [ProducesResponseType((int)HttpStatusCode.Forbidden)]
     [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(CategoryDto))]
     [ProducesResponseType((int)HttpStatusCode.BadRequest)]
-    [ProducesResponseType((int)HttpStatusCode.NotFound)]
-    public async Task<IActionResult> Put([FromRoute] string key, [FromBody] CategoryDto model)
+    public async Task<IActionResult> Put([FromBody] CategoryDto model)
     {
         if (!await _permissionService.Authorize(PermissionSystemName.Categories)) return Forbid();
 
-        var category = await _mediator.Send(new GetGenericQuery<CategoryDto, Category>(key));
-        if (!category.Any()) return NotFound();
-
         model = await _mediator.Send(new UpdateCategoryCommand { Model = model });
         return Ok(model);
     }

src/Modules/Grand.Module.Api/Controllers/CollectionController.cs

@@ -70,18 +70,14 @@ public async Task<IActionResult> Post([FromBody] CollectionDto model)
 
     [EndpointDescription("Update entity in Collection")]
     [EndpointName("UpdateCollection")]
-    [HttpPut("{key}")]
+    [HttpPut]
     [ProducesResponseType((int)HttpStatusCode.Forbidden)]
     [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(CollectionDto))]
     [ProducesResponseType((int)HttpStatusCode.BadRequest)]
-    [ProducesResponseType((int)HttpStatusCode.NotFound)]
-    public async Task<IActionResult> Put([FromRoute] string key, [FromBody] CollectionDto model)
+    public async Task<IActionResult> Put([FromBody] CollectionDto model)
     {
         if (!await _permissionService.Authorize(PermissionSystemName.Collections)) return Forbid();
 
-        var collection = await _mediator.Send(new GetGenericQuery<CollectionDto, Collection>(key));
-        if (!collection.Any()) return NotFound();
-
         model = await _mediator.Send(new UpdateCollectionCommand { Model = model });
         return Ok(model);
     }

src/Modules/Grand.Module.Api/Controllers/CustomerController.cs

@@ -66,18 +66,14 @@ public async Task<IActionResult> Post([FromBody] CustomerDto model)
 
     [EndpointDescription("Update entity in Customer")]
     [EndpointName("UpdateCustomer")]
-    [HttpPut("{email}")]
+    [HttpPut]
     [ProducesResponseType((int)HttpStatusCode.Forbidden)]
     [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(CustomerDto))]
     [ProducesResponseType((int)HttpStatusCode.BadRequest)]
-    [ProducesResponseType((int)HttpStatusCode.NotFound)]
-    public async Task<IActionResult> Put([FromRoute] string email, [FromBody] CustomerDto model)
+    public async Task<IActionResult> Put([FromBody] CustomerDto model)
     {
         if (!await _permissionService.Authorize(PermissionSystemName.Customers)) return Forbid();
 
-        var customer = await _mediator.Send(new GetCustomerQuery { Email = email });
-        if (customer == null) return NotFound();
-
         model = await _mediator.Send(new UpdateCustomerCommand { Model = model });
         return Ok(model);
     }

src/Modules/Grand.Module.Api/Controllers/CustomerGroupController.cs

@@ -70,18 +70,14 @@ public async Task<IActionResult> Post([FromBody] CustomerGroupDto model)
 
     [EndpointDescription("Update entity in CustomerGroup")]
     [EndpointName("UpdateCustomerGroup")]
-    [HttpPut("{key}")]
+    [HttpPut]
     [ProducesResponseType((int)HttpStatusCode.Forbidden)]
     [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(CustomerGroupDto))]
     [ProducesResponseType((int)HttpStatusCode.BadRequest)]
-    [ProducesResponseType((int)HttpStatusCode.NotFound)]
-    public async Task<IActionResult> Put([FromRoute] string key, [FromBody] CustomerGroupDto model)
+    public async Task<IActionResult> Put([FromBody] CustomerGroupDto model)
     {
         if (!await _permissionService.Authorize(PermissionSystemName.Customers)) return Forbid();
 
-        var customerGroup = await _mediator.Send(new GetGenericQuery<CustomerGroupDto, CustomerGroup>(key));
-        if (!customerGroup.Any()) return NotFound();
-
         if (!model.IsSystem)
         {
             model = await _mediator.Send(new UpdateCustomerGroupCommand { Model = model });

src/Modules/Grand.Module.Api/Controllers/PictureController.cs

@@ -55,18 +55,14 @@ public async Task<IActionResult> Post([FromBody] PictureDto model)
 
     [EndpointDescription("Update entity in Picture")]
     [EndpointName("UpdatePicture")]
-    [HttpPut("{key}")]
+    [HttpPut]
     [ProducesResponseType((int)HttpStatusCode.Forbidden)]
     [ProducesResponseType((int)HttpStatusCode.OK)]
     [ProducesResponseType((int)HttpStatusCode.BadRequest)]
-    [ProducesResponseType((int)HttpStatusCode.NotFound)]
-    public async Task<IActionResult> Put([FromRoute] string key, [FromBody] PictureDto model)
+    public async Task<IActionResult> Put([FromBody] PictureDto model)
     {
         if (!await _permissionService.Authorize(PermissionSystemName.Pictures)) return Forbid();
 
-        var picture = await _mediator.Send(new GetGenericQuery<PictureDto, Picture>(key));
-        if (picture == null || !picture.Any()) return NotFound();
-
         var result = await _mediator.Send(new UpdatePictureCommand { Model = model });
         return Ok(result);
     }

src/Modules/Grand.Module.Api/Controllers/ProductAttributeController.cs

@@ -72,18 +72,14 @@ public async Task<IActionResult> Post([FromBody] ProductAttributeDto model)
 
     [EndpointDescription("Update entity in ProductAttribute")]
     [EndpointName("UpdateProductAttribute")]
-    [HttpPut("{key}")]
+    [HttpPut]
     [ProducesResponseType((int)HttpStatusCode.Forbidden)]
     [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(ProductAttributeDto))]
     [ProducesResponseType((int)HttpStatusCode.BadRequest)]
-    [ProducesResponseType((int)HttpStatusCode.NotFound)]
-    public async Task<IActionResult> Put([FromRoute] string key, [FromBody] ProductAttributeDto model)
+    public async Task<IActionResult> Put([FromBody] ProductAttributeDto model)
     {
         if (!await _permissionService.Authorize(PermissionSystemName.ProductAttributes)) return Forbid();
 
-        var productAttribute = await _mediator.Send(new GetGenericQuery<ProductAttributeDto, ProductAttribute>(key));
-        if (!productAttribute.Any()) return NotFound();
-
         model = await _mediator.Send(new UpdateProductAttributeCommand { Model = model });
         return Ok(model);
     }

src/Modules/Grand.Module.Api/Controllers/ProductController.cs

@@ -72,18 +72,14 @@ public async Task<IActionResult> Post([FromBody] ProductDto model)
 
     [EndpointDescription("Update entity in Product")]
     [EndpointName("UpdateProduct")]
-    [HttpPut("{key}")]
+    [HttpPut]
     [ProducesResponseType((int)HttpStatusCode.Forbidden)]
     [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(ProductDto))]
-    [ProducesResponseType((int)HttpStatusCode.NotFound)]
     [ProducesResponseType((int)HttpStatusCode.BadRequest)]
-    public async Task<IActionResult> Put([FromRoute] string key, [FromBody] ProductDto model)
+    public async Task<IActionResult> Put([FromBody] ProductDto model)
     {
         if (!await _permissionService.Authorize(PermissionSystemName.Products)) return Forbid();
 
-        var product = await _mediator.Send(new GetGenericQuery<ProductDto, Product>(key));
-        if (!product.Any()) return NotFound();
-
         await _mediator.Send(new UpdateProductCommand { Model = model });
         return Ok();
     }

src/Modules/Grand.Module.Api/Controllers/SpecificationAttributeController.cs

@@ -70,15 +70,13 @@ public async Task<IActionResult> Post([FromBody] SpecificationAttributeDto model
 
     [EndpointDescription("Update entity in SpecificationAttribute")]
     [EndpointName("UpdateSpecificationAttribute")]
-    [HttpPut("{key}")]
+    [HttpPut]
     [ProducesResponseType((int)HttpStatusCode.Forbidden)]
     [ProducesResponseType(StatusCodes.Status200OK, Type = typeof(SpecificationAttributeDto))]
     [ProducesResponseType((int)HttpStatusCode.BadRequest)]
-    public async Task<IActionResult> Put([FromRoute] string key, [FromBody] SpecificationAttributeDto model)
+    public async Task<IActionResult> Put([FromBody] SpecificationAttributeDto model)
     {
         if (!await _permissionService.Authorize(PermissionSystemName.SpecificationAttributes)) return Forbid();
-        var specification = await _mediator.Send(new GetGenericQuery<SpecificationAttributeDto, SpecificationAttribute>(key));
-        if (!specification.Any()) return NotFound();
 
         model = await _mediator.Send(new UpdateSpecificationAttributeCommand { Model = model });
         return Ok(model);