Merge pull request #1 from AJEETX/Dev

AJEETX · web-flow · commit a4c7739b5017 · 2021-03-07T19:10:25.000+11:00
Dev
diff --git a/src/Api.Test/EndpointsTests/UnitTests/V1/Products/CreateTest.cs b/src/Api.Test/EndpointsTests/UnitTests/V1/Products/CreateTest.cs
@@ -16,12 +16,10 @@ namespace Xero.Demo.Api.Tests.EndpointTests.UnitTests.V1.Products
     [Trait("Category", "Unit")]
     public class CreateTest : IDisposable
     {
-        private Mock<ILogger<ProductsController>> moqLogger;
         private DbContextOptions<Database> options;
 
         public CreateTest()
         {
-            moqLogger = new Mock<ILogger<ProductsController>>();
             options = new DbContextOptionsBuilder<Database>().UseInMemoryDatabase(databaseName: SampleDataV1.Database).Options;
         }
 
@@ -30,7 +28,7 @@ public async Task PostAsync_Adds_Product_Successfully_With_Valid_Product_Details
         {
             //Given
             using var moqDatabase = new Database(options);
-            var sut = new ProductsController(moqLogger.Object, moqDatabase)
+            var sut = new ProductsController(moqDatabase)
             {
                 ControllerContext = new ControllerContext()
             };
@@ -52,7 +50,6 @@ public async Task PostAsync_Adds_Product_Successfully_With_Valid_Product_Details
 
         public void Dispose()
         {
-            moqLogger = null;
             options = null;
         }
     }
diff --git a/src/Api.Test/EndpointsTests/UnitTests/V1/Products/DeleteTest.cs b/src/Api.Test/EndpointsTests/UnitTests/V1/Products/DeleteTest.cs
@@ -17,11 +17,9 @@ namespace Xero.Demo.Api.Tests.EndpointTests.UnitTests.V1.Products
     public class DeleteTest : IDisposable
     {
         private Database moqDatabase;
-        private Mock<ILogger<ProductsController>> moqLogger;
 
         public DeleteTest()
         {
-            moqLogger = new Mock<ILogger<ProductsController>>();
             var options = new DbContextOptionsBuilder<Database>().UseInMemoryDatabase(databaseName: SampleDataV1.Database).Options;
             moqDatabase = new Database(options);
         }
@@ -30,7 +28,7 @@ public DeleteTest()
         public async Task DeleteAsync_Deletes_Product_Successfully_With_Valid_Product_Id()
         {
             //Given
-            var sut = new ProductsController(moqLogger.Object, moqDatabase)
+            var sut = new ProductsController(moqDatabase)
             {
                 ControllerContext = new ControllerContext()
             };
@@ -53,7 +51,6 @@ public async Task DeleteAsync_Deletes_Product_Successfully_With_Valid_Product_Id
         public void Dispose()
         {
             moqDatabase = null;
-            moqLogger = null;
         }
     }
 }
diff --git a/src/Api.Test/EndpointsTests/UnitTests/V1/Products/ReadTest.cs b/src/Api.Test/EndpointsTests/UnitTests/V1/Products/ReadTest.cs
@@ -18,15 +18,13 @@ namespace Xero.Demo.Api.Tests.EndpointTests.UnitTests.V1.Products
     public class ReadTest : IDisposable
     {
         private Database moqDatabase;
-        private Mock<ILogger<ProductsController>> moqLogger;
         private ProductsController sut;
 
         public ReadTest()
         {
-            moqLogger = new Mock<ILogger<ProductsController>>();
             var options = new DbContextOptionsBuilder<Database>().UseInMemoryDatabase(databaseName: SampleDataV1.Database).Options;
             moqDatabase = new Database(options);
-            sut = new ProductsController(moqLogger.Object, moqDatabase)
+            sut = new ProductsController(moqDatabase)
             {
                 ControllerContext = new ControllerContext()
             };
@@ -39,7 +37,6 @@ public ReadTest()
         public void Dispose()
         {
             moqDatabase = null;
-            moqLogger = null;
             sut = null;
         }
 
diff --git a/src/Api.Test/EndpointsTests/UnitTests/V1/Products/UpdateTest.cs b/src/Api.Test/EndpointsTests/UnitTests/V1/Products/UpdateTest.cs
@@ -17,11 +17,9 @@ namespace Xero.Demo.Api.Tests.EndpointTests.UnitTests.V1.Products
     public class UpdateTest : IDisposable
     {
         private Database moqDatabase;
-        private Mock<ILogger<ProductsController>> moqLogger;
 
         public UpdateTest()
         {
-            moqLogger = new Mock<ILogger<ProductsController>>();
             var options = new DbContextOptionsBuilder<Database>().UseInMemoryDatabase(databaseName: SampleDataV1.Database).Options;
             moqDatabase = new Database(options);
         }
@@ -30,7 +28,7 @@ public UpdateTest()
         public async Task PutAsync_Updates_Product_Successfully_With_Valid_Product_Id_and_Details()
         {
             //Given
-            var sut = new ProductsController(moqLogger.Object, moqDatabase)
+            var sut = new ProductsController(moqDatabase)
             {
                 ControllerContext = new ControllerContext()
             };
@@ -39,7 +37,7 @@ public async Task PutAsync_Updates_Product_Successfully_With_Valid_Product_Id_an
                 TraceIdentifier = SampleDataV1.TraceIdentifier
             };
 
-            var product = await moqDatabase.Products.AddAsync(SampleDataV1.Product);      //adding the product to be database
+            var product = await moqDatabase.Products.AddAsync(SampleDataV1.Product);            //adding the product to be database
             await moqDatabase.SaveChangesAsync();                                              //saving the product to be updated
             product.Entity.Description = SampleDataV1.NewDescription;
 
@@ -54,7 +52,6 @@ public async Task PutAsync_Updates_Product_Successfully_With_Valid_Product_Id_an
         public void Dispose()
         {
             moqDatabase = null;
-            moqLogger = null;
         }
     }
 }
diff --git a/src/Api/Endpoints/V1/Products/Create.cs b/src/Api/Endpoints/V1/Products/Create.cs
@@ -16,11 +16,9 @@ namespace Xero.Demo.Api.Endpoints.V1.Products
     public partial class ProductsController : BaseApiController
     {
         public readonly Database _db;
-        public readonly ILogger<ProductsController> _logger;
 
-        public ProductsController(ILogger<ProductsController> logger, Database db)
+        public ProductsController(Database db)
         {
-            _logger = logger;
             _db = db;
         }
 
@@ -41,13 +39,9 @@ public async Task<IActionResult> PostAsync(Product product, string culture = "en
         {
             if (!ModelState.IsValid) return BadRequest(ModelState.GetErrorMessages());
 
-            var traceIdentifier = HttpContext.TraceIdentifier;
-            _logger.LogInformation(string.Format(LogMessage.PreRequestLog, nameof(PostAsync), product.Id, traceIdentifier));
-
             var entity = await _db.Products.AddAsync(product);
             var count = await _db.SaveChangesAsync();
 
-            _logger.LogInformation(string.Format(LogMessage.PostRequestLog, nameof(PostAsync), entity.Entity.Id, traceIdentifier));
             var responseProduct = new ProductDTO
             {
                 DeliveryPrice = entity.Entity.DeliveryPrice,
diff --git a/src/Api/Endpoints/V1/Products/Delete.cs b/src/Api/Endpoints/V1/Products/Delete.cs
@@ -28,18 +28,13 @@ public async Task<IActionResult> DeleteAsync(Guid id, string culture = "en-US")
         {
             if (!ModelState.IsValid || id == Guid.Empty) return BadRequest(ModelState.GetErrorMessages());
 
-            var traceIdentifier = HttpContext.TraceIdentifier;
-            _logger.LogInformation(string.Format(LogMessage.PreRequestLog, nameof(DeleteAsync), id, traceIdentifier));
-
             var product = await _db.Products.FindAsync(id);
 
             if (product == default) return NotFound(string.Format(CustomException.NotFoundException, id));
 
             var productRemoved = _db.Products.Remove(product);
             rowCountDeleted = await _db.SaveChangesAsync();
 
-            _logger.LogInformation(string.Format(LogMessage.PostRequestLog, nameof(DeleteAsync), id, traceIdentifier));
-
             return deleted ? NoContent() : StatusCode(StatusCodes.Status500InternalServerError);
         }
     }
diff --git a/src/Api/Endpoints/V1/Products/Read.cs b/src/Api/Endpoints/V1/Products/Read.cs
@@ -3,7 +3,6 @@
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
 using Microsoft.EntityFrameworkCore;
-using Microsoft.Extensions.Logging;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -27,19 +26,15 @@ public async Task<IActionResult> GetAsync(string culture = "en-US")
             //var language = AddLocalizationExtension._e[WELCOME];
             //_logger.LogInformation(string.Format(AddLocalizationExtension._e[WELCOME].Value));
 
-            var traceIdentifier = HttpContext.TraceIdentifier;
-            _logger.LogInformation(string.Format(LogMessage.PreRequestLog, nameof(GetAsync), string.Empty, traceIdentifier));
-
             var products = await _db.Products.AsQueryable().ToListAsync();
 
-            _logger.LogInformation(string.Format(LogMessage.PostRequestLog, nameof(GetAsync), string.Empty, traceIdentifier));
-            var res = products.Select(p => new ProductDTO 
-            { 
-                Id=p.Id,
-                Name=p.Name,
-                Description=p.Description,
-                Price=p.Price,
-                DeliveryPrice=p.DeliveryPrice
+            var res = products.Select(p => new ProductDTO
+            {
+                Id = p.Id,
+                Name = p.Name,
+                Description = p.Description,
+                Price = p.Price,
+                DeliveryPrice = p.DeliveryPrice
             }).ToList();
             return Ok(res);
         }
@@ -58,20 +53,16 @@ public async Task<IActionResult> GetByIdAsync(Guid id)
         {
             if (!ModelState.IsValid || id == Guid.Empty) return BadRequest(ModelState.GetErrorMessages());
 
-            var traceIdentifier = HttpContext.TraceIdentifier;
-            _logger.LogInformation(string.Format(LogMessage.PostRequestLog, nameof(GetByIdAsync), id, traceIdentifier));
-
             var product = await _db.Products.FindAsync(id);
             if (product == default) return NotFound(string.Format(CustomException.NotFoundException, id));
 
-            _logger.LogInformation(string.Format(LogMessage.PostRequestLog, nameof(GetByIdAsync), id, traceIdentifier));
-
-            var responseProduct = new ProductDTO {
-             Id=product.Id,
-              Name=product.Name,
-              Description=product.Description,
-               DeliveryPrice=product.DeliveryPrice,
-               Price=product.DeliveryPrice
+            var responseProduct = new ProductDTO
+            {
+                Id = product.Id,
+                Name = product.Name,
+                Description = product.Description,
+                DeliveryPrice = product.DeliveryPrice,
+                Price = product.DeliveryPrice
             };
 
             return Ok(responseProduct);
diff --git a/src/Api/Endpoints/V1/Products/Update.cs b/src/Api/Endpoints/V1/Products/Update.cs
@@ -27,18 +27,13 @@ public async Task<IActionResult> PutAsync(Guid id, Product product, string cultu
         {
             if (!ModelState.IsValid) return BadRequest(ModelState.GetErrorMessages());
 
-            var traceIdentifier = HttpContext.TraceIdentifier;
-            _logger.LogInformation(string.Format(LogMessage.PostRequestLog, nameof(DeleteAsync), id, traceIdentifier));
-
             var savedProduct = await _db.Products.FindAsync(id);
 
             if (savedProduct == default) return NotFound(string.Format(CustomException.NotFoundException, id));
 
             _db.Products.Update(product);
             var count = await _db.SaveChangesAsync();
 
-            _logger.LogInformation(string.Format(LogMessage.PostRequestLog, nameof(DeleteAsync), id, traceIdentifier));
-
             return count == 1 ? NoContent() : StatusCode(StatusCodes.Status500InternalServerError);
         }
     }
diff --git a/src/Api/Xero.Demo.Api.csproj b/src/Api/Xero.Demo.Api.csproj
@@ -27,6 +27,7 @@
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
     <PackageReference Include="Microsoft.FeatureManagement.AspNetCore" Version="2.2.0" />
+    <PackageReference Include="Microsoft.IO.RecyclableMemoryStream" Version="1.4.0" />
     <PackageReference Include="Newtonsoft.Json" Version="12.0.3" />
     <PackageReference Include="Swashbuckle.AspNetCore" Version="5.6.3" />
     <DotNetCliToolReference Include="Microsoft.EntityFrameworkCore.Tools.DotNet" Version="1.0.0" />
diff --git a/src/Api/Xero.Demo.Datastore/Database.cs b/src/Api/Xero.Demo.Datastore/Database.cs
diff --git a/src/Api/Xero.Demo.Infrastructure/Extensions/AddMiddleWareExtensions.cs b/src/Api/Xero.Demo.Infrastructure/Extensions/AddMiddleWareExtensions.cs
@@ -27,8 +27,6 @@ public static void AddServices(this IServiceCollection services, IConfiguration
                 ;
             });
 
-            //services.AddScoped<IDatabase>(provider => provider.GetService<Database>());
-
             services.AddLocalizationServices();
 
             services.AddApiVersioning(options =>
@@ -47,9 +45,6 @@ public static void AddServices(this IServiceCollection services, IConfiguration
             services.AddSwaggerGen(c =>
                 {
                     c.OperationFilter<SwaggerDefaultValues>();
-
-                    //var xmlFile = $"Xero.Demo.Api.xml";
-                    //c.IncludeXmlComments(System.IO.Path.Combine(AppContext.BaseDirectory, xmlFile));
                 });
 
             services.AddFeatureManagement();
diff --git a/src/Api/Xero.Demo.Infrastructure/Extensions/RequestResponseLoggingMiddleware.cs b/src/Api/Xero.Demo.Infrastructure/Extensions/RequestResponseLoggingMiddleware.cs
@@ -0,0 +1,84 @@
+﻿using Microsoft.AspNetCore.Http;
+using Microsoft.Extensions.Logging;
+using Microsoft.IO;
+using System;
+using System.IO;
+using System.Threading.Tasks;
+
+namespace Xero.Demo.Api.Xero.Demo.Infrastructure.Extensions
+{
+    public class RequestResponseLoggingMiddleware
+    {
+        private readonly RequestDelegate _next;
+        private readonly ILogger _logger;
+        private readonly RecyclableMemoryStreamManager _recyclableMemoryStreamManager;
+
+        public RequestResponseLoggingMiddleware(RequestDelegate next, ILoggerFactory loggerFactory)
+        {
+            _next = next;
+            _logger = loggerFactory.CreateLogger<RequestResponseLoggingMiddleware>();
+            _recyclableMemoryStreamManager = new RecyclableMemoryStreamManager();
+        }
+
+        public async Task Invoke(HttpContext context)
+        {
+            await LogRequest(context);
+            await LogResponse(context);
+        }
+
+        private async Task LogRequest(HttpContext context)
+        {
+            context.Request.EnableBuffering();
+            await using var requestStream = _recyclableMemoryStreamManager.GetStream();
+            await context.Request.Body.CopyToAsync(requestStream);
+            _logger.LogInformation($"Http Request Information:{Environment.NewLine}" +
+                                   $"Schema:{context.Request.Scheme} " +
+                                   $"Host: {context.Request.Host} " +
+                                   $"Path: {context.Request.Path} " +
+                                   $"QueryString: {context.Request.QueryString} " +
+                                   $"Request Body: {ReadStreamInChunks(requestStream)}");
+            context.Request.Body.Position = 0;
+        }
+
+        private static string ReadStreamInChunks(Stream stream)
+        {
+            const int readChunkBufferLength = 4096;
+            stream.Seek(0, SeekOrigin.Begin);
+            using var textWriter = new StringWriter();
+            using var reader = new StreamReader(stream);
+            var readChunk = new char[readChunkBufferLength];
+            int readChunkLength;
+            do
+            {
+                readChunkLength = reader.ReadBlock(readChunk,
+                                                   0,
+                                                   readChunkBufferLength);
+                textWriter.Write(readChunk, 0, readChunkLength);
+            } while (readChunkLength > 0);
+            return textWriter.ToString();
+        }
+
+        private async Task LogResponse(HttpContext context)
+        {
+            var originalBodyStream = context.Response.Body;
+
+            await using var responseBody = _recyclableMemoryStreamManager.GetStream();
+            context.Response.Body = responseBody;
+
+            await _next(context);
+
+            context.Response.Body.Seek(0, SeekOrigin.Begin);
+            var text = await new StreamReader(context.Response.Body).ReadToEndAsync();
+            context.Response.Body.Seek(0, SeekOrigin.Begin);
+
+            _logger.LogInformation($"Http Response Information:{Environment.NewLine}" +
+                                   $"Schema:{context.Request.Scheme} " +
+                                   $"Host: {context.Request.Host} " +
+                                   $"Path: {context.Request.Path} " +
+                                   $"QueryString: {context.Request.QueryString} " +
+                                   $"Response Body: {text}");
+
+            await responseBody.CopyToAsync(originalBodyStream);
+        }
+    }
+}
diff --git a/src/Api/Xero.Demo.Infrastructure/Extensions/RequestResponseLoggingMiddlewareExtensions.cs b/src/Api/Xero.Demo.Infrastructure/Extensions/RequestResponseLoggingMiddlewareExtensions.cs
@@ -0,0 +1,16 @@
+﻿using Microsoft.AspNetCore.Builder;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Xero.Demo.Api.Xero.Demo.Infrastructure.Extensions
+{
+    public static class RequestResponseLoggingMiddlewareExtensions
+    {
+        public static IApplicationBuilder UseRequestResponseLogging(this IApplicationBuilder builder)
+        {
+            return builder.UseMiddleware<RequestResponseLoggingMiddleware>();
+        }
+    }
+}
diff --git a/src/Api/Xero.Demo.Infrastructure/Extensions/UseMiddleWareExtension.cs b/src/Api/Xero.Demo.Infrastructure/Extensions/UseMiddleWareExtension.cs

Original file line number	Diff line number	Diff line change
`@@ -16,12 +16,10 @@ namespace Xero.Demo.Api.Tests.EndpointTests.UnitTests.V1.Products`
`16`	`16`	`[Trait("Category", "Unit")]`
`17`	`17`	`public class CreateTest : IDisposable`
`18`	`18`	`{`
`19`		`- private Mock<ILogger<ProductsController>> moqLogger;`
`20`	`19`	`private DbContextOptions<Database> options;`
`21`	`20`
`22`	`21`	`public CreateTest()`
`23`	`22`	`{`
`24`		`- moqLogger = new Mock<ILogger<ProductsController>>();`
`25`	`23`	`options = new DbContextOptionsBuilder<Database>().UseInMemoryDatabase(databaseName: SampleDataV1.Database).Options;`
`26`	`24`	`}`
`27`	`25`
`@@ -30,7 +28,7 @@ public async Task PostAsync_Adds_Product_Successfully_With_Valid_Product_Details`
`30`	`28`	`{`
`31`	`29`	`//Given`
`32`	`30`	`using var moqDatabase = new Database(options);`
`33`		`- var sut = new ProductsController(moqLogger.Object, moqDatabase)`
	`31`	`+ var sut = new ProductsController(moqDatabase)`
`34`	`32`	`{`
`35`	`33`	`ControllerContext = new ControllerContext()`
`36`	`34`	`};`
`@@ -52,7 +50,6 @@ public async Task PostAsync_Adds_Product_Successfully_With_Valid_Product_Details`
`52`	`50`
`53`	`51`	`public void Dispose()`
`54`	`52`	`{`
`55`		`- moqLogger = null;`
`56`	`53`	`options = null;`
`57`	`54`	`}`
`58`	`55`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,11 +17,9 @@ namespace Xero.Demo.Api.Tests.EndpointTests.UnitTests.V1.Products`
`17`	`17`	`public class DeleteTest : IDisposable`
`18`	`18`	`{`
`19`	`19`	`private Database moqDatabase;`
`20`		`- private Mock<ILogger<ProductsController>> moqLogger;`
`21`	`20`
`22`	`21`	`public DeleteTest()`
`23`	`22`	`{`
`24`		`- moqLogger = new Mock<ILogger<ProductsController>>();`
`25`	`23`	`var options = new DbContextOptionsBuilder<Database>().UseInMemoryDatabase(databaseName: SampleDataV1.Database).Options;`
`26`	`24`	`moqDatabase = new Database(options);`
`27`	`25`	`}`
`@@ -30,7 +28,7 @@ public DeleteTest()`
`30`	`28`	`public async Task DeleteAsync_Deletes_Product_Successfully_With_Valid_Product_Id()`
`31`	`29`	`{`
`32`	`30`	`//Given`
`33`		`- var sut = new ProductsController(moqLogger.Object, moqDatabase)`
	`31`	`+ var sut = new ProductsController(moqDatabase)`
`34`	`32`	`{`
`35`	`33`	`ControllerContext = new ControllerContext()`
`36`	`34`	`};`
`@@ -53,7 +51,6 @@ public async Task DeleteAsync_Deletes_Product_Successfully_With_Valid_Product_Id`
`53`	`51`	`public void Dispose()`
`54`	`52`	`{`
`55`	`53`	`moqDatabase = null;`
`56`		`- moqLogger = null;`
`57`	`54`	`}`
`58`	`55`	`}`
`59`	`56`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,15 +18,13 @@ namespace Xero.Demo.Api.Tests.EndpointTests.UnitTests.V1.Products`
`18`	`18`	`public class ReadTest : IDisposable`
`19`	`19`	`{`
`20`	`20`	`private Database moqDatabase;`
`21`		`- private Mock<ILogger<ProductsController>> moqLogger;`
`22`	`21`	`private ProductsController sut;`
`23`	`22`
`24`	`23`	`public ReadTest()`
`25`	`24`	`{`
`26`		`- moqLogger = new Mock<ILogger<ProductsController>>();`
`27`	`25`	`var options = new DbContextOptionsBuilder<Database>().UseInMemoryDatabase(databaseName: SampleDataV1.Database).Options;`
`28`	`26`	`moqDatabase = new Database(options);`
`29`		`- sut = new ProductsController(moqLogger.Object, moqDatabase)`
	`27`	`+ sut = new ProductsController(moqDatabase)`
`30`	`28`	`{`
`31`	`29`	`ControllerContext = new ControllerContext()`
`32`	`30`	`};`
`@@ -39,7 +37,6 @@ public ReadTest()`
`39`	`37`	`public void Dispose()`
`40`	`38`	`{`
`41`	`39`	`moqDatabase = null;`
`42`		`- moqLogger = null;`
`43`	`40`	`sut = null;`
`44`	`41`	`}`
`45`	`42`
Original file line number	Diff line number	Diff line change
`@@ -16,11 +16,9 @@ namespace Xero.Demo.Api.Endpoints.V1.Products`
`16`	`16`	`public partial class ProductsController : BaseApiController`
`17`	`17`	`{`
`18`	`18`	`public readonly Database _db;`
`19`		`- public readonly ILogger<ProductsController> _logger;`
`20`	`19`
`21`		`- public ProductsController(ILogger<ProductsController> logger, Database db)`
	`20`	`+ public ProductsController(Database db)`
`22`	`21`	`{`
`23`		`- _logger = logger;`
`24`	`22`	`_db = db;`
`25`	`23`	`}`
`26`	`24`
`@@ -41,13 +39,9 @@ public async Task<IActionResult> PostAsync(Product product, string culture = "en`
`41`	`39`	`{`
`42`	`40`	`if (!ModelState.IsValid) return BadRequest(ModelState.GetErrorMessages());`
`43`	`41`
`44`		`- var traceIdentifier = HttpContext.TraceIdentifier;`
`45`		`- _logger.LogInformation(string.Format(LogMessage.PreRequestLog, nameof(PostAsync), product.Id, traceIdentifier));`
`46`		`-`
`47`	`42`	`var entity = await _db.Products.AddAsync(product);`
`48`	`43`	`var count = await _db.SaveChangesAsync();`
`49`	`44`
`50`		`- _logger.LogInformation(string.Format(LogMessage.PostRequestLog, nameof(PostAsync), entity.Entity.Id, traceIdentifier));`
`51`	`45`	`var responseProduct = new ProductDTO`
`52`	`46`	`{`
`53`	`47`	`DeliveryPrice = entity.Entity.DeliveryPrice,`
Original file line number	Diff line number	Diff line change
`@@ -28,18 +28,13 @@ public async Task<IActionResult> DeleteAsync(Guid id, string culture = "en-US")`
`28`	`28`	`{`
`29`	`29`	`if (!ModelState.IsValid \|\| id == Guid.Empty) return BadRequest(ModelState.GetErrorMessages());`
`30`	`30`
`31`		`- var traceIdentifier = HttpContext.TraceIdentifier;`
`32`		`- _logger.LogInformation(string.Format(LogMessage.PreRequestLog, nameof(DeleteAsync), id, traceIdentifier));`
`33`		`-`
`34`	`31`	`var product = await _db.Products.FindAsync(id);`
`35`	`32`
`36`	`33`	`if (product == default) return NotFound(string.Format(CustomException.NotFoundException, id));`
`37`	`34`
`38`	`35`	`var productRemoved = _db.Products.Remove(product);`
`39`	`36`	`rowCountDeleted = await _db.SaveChangesAsync();`
`40`	`37`
`41`		`- _logger.LogInformation(string.Format(LogMessage.PostRequestLog, nameof(DeleteAsync), id, traceIdentifier));`
`42`		`-`
`43`	`38`	`return deleted ? NoContent() : StatusCode(StatusCodes.Status500InternalServerError);`
`44`	`39`	`}`
`45`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,18 +27,13 @@ public async Task<IActionResult> PutAsync(Guid id, Product product, string cultu`
`27`	`27`	`{`
`28`	`28`	`if (!ModelState.IsValid) return BadRequest(ModelState.GetErrorMessages());`
`29`	`29`
`30`		`- var traceIdentifier = HttpContext.TraceIdentifier;`
`31`		`- _logger.LogInformation(string.Format(LogMessage.PostRequestLog, nameof(DeleteAsync), id, traceIdentifier));`
`32`		`-`
`33`	`30`	`var savedProduct = await _db.Products.FindAsync(id);`
`34`	`31`
`35`	`32`	`if (savedProduct == default) return NotFound(string.Format(CustomException.NotFoundException, id));`
`36`	`33`
`37`	`34`	`_db.Products.Update(product);`
`38`	`35`	`var count = await _db.SaveChangesAsync();`
`39`	`36`
`40`		`- _logger.LogInformation(string.Format(LogMessage.PostRequestLog, nameof(DeleteAsync), id, traceIdentifier));`
`41`		`-`
`42`	`37`	`return count == 1 ? NoContent() : StatusCode(StatusCodes.Status500InternalServerError);`
`43`	`38`	`}`
`44`	`39`	`}`