Modified code to conform with testing

Author: folathecoder

.env

@@ -1,2 +1,2 @@
-DB_PASSWORD=iBpY5H8w8M4MzBP
-JWT_KEY=Thisisaverylongkey2432fgnfnd5ytrjgrg544gns
+DB_PASSWORD = "iBpY5H8w8M4MzBP"
+JWT_KEY = "Thisisaverylongkey2432fgnfnd5ytrjgrg544gns"

BookStoreApi.csproj

@@ -8,20 +8,14 @@
 
   <ItemGroup>
     <PackageReference Include="AutoMapper" Version="12.0.1" />
+    <PackageReference Include="AutoMapper.Extensions.Microsoft.DependencyInjection" Version="12.0.1" />
     <PackageReference Include="DotNetEnv" Version="2.5.0" />
+    <PackageReference Include="MailKit" Version="4.1.0" />
     <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="6.0.4" />
-    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="6.0.0" />
     <PackageReference Include="Microsoft.IdentityModel.Tokens" Version="6.32.0" />
     <PackageReference Include="MongoDB.Driver" Version="2.20.0" />
-    <PackageReference Include="Moq" Version="4.18.4" />
     <PackageReference Include="Swashbuckle.AspNetCore" Version="6.5.0" />
     <PackageReference Include="System.IdentityModel.Tokens.Jwt" Version="6.32.0" />
-    <PackageReference Include="xunit" Version="2.5.0" />
-    <PackageReference Include="xunit.assert" Version="2.5.0" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0">
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-      <PrivateAssets>all</PrivateAssets>
-    </PackageReference>
   </ItemGroup>
 
 </Project>

Controllers/AuthController.cs

@@ -1,7 +1,10 @@
 using MARKETPLACEAPI.dto;
+using MARKETPLACEAPI.Interfaces;
 using MARKETPLACEAPI.Models;
-using MARKETPLACEAPI.Services;
+using MARKETPLACEAPI.Helpers;
 using Microsoft.AspNetCore.Mvc;
+using AutoMapper;
+
 
 namespace MARKETPLACEAPI.Controllers;
 
@@ -12,13 +15,19 @@ namespace MARKETPLACEAPI.Controllers;
 [Route("api/auth/[controller]")]
 public class AuthController : ControllerBase
 {
-  private readonly UserService _userService;
-  private readonly AuthService _authService;
+  private readonly IUserService _userService;
+  private readonly IAuthService _authService;
+  
+  private readonly IConfiguration _config;
+  private readonly IMapper _mapper;
 
-  public AuthController(UserService userService, AuthService authService)
+  public AuthController(IUserService userService, IAuthService authService, IConfiguration config, IMapper mapper)
   {
     _userService = userService;
     _authService = authService;
+    _config = config;
+    _mapper = mapper;
+
   }
 
 
@@ -27,6 +36,7 @@ public AuthController(UserService userService, AuthService authService)
   public async Task<IActionResult> Register(SignInRegisterDto regDto)
   {
     var user = await _userService.GetUserByWalletAddress(regDto.walletAddress);
+    TokenHelper _tokenHelper = new TokenHelper(_config);
     if (user != null)
     {
       var res = new SignInResponseDto
@@ -37,17 +47,12 @@ public async Task<IActionResult> Register(SignInRegisterDto regDto)
         accountExists = true,
         invalidAddress = false,
         errorMessage = null,
-        token = _authService.GenerateToken(user),
+        token = _tokenHelper.GenerateToken(user),
       };
       return Ok(res);
     } 
 
-    var newUser = new User
-    {
-      userName = regDto.userName,
-      walletAddress = regDto.walletAddress,
-      socials = regDto.socials,
-    };
+    var newUser = _mapper.Map<User>(regDto);
     await _userService.CreateAsync(newUser);
 
     var response = new SignInResponseDto
@@ -58,7 +63,7 @@ public async Task<IActionResult> Register(SignInRegisterDto regDto)
       accountExists = false,
       invalidAddress = false,
       errorMessage = null,
-      token = _authService.GenerateToken(newUser),
+      token = _tokenHelper.GenerateToken(newUser),
     };
 
     return Ok(response);
@@ -83,8 +88,8 @@ public async Task<IActionResult> Login(LoginDto loginDto)
         errorMessage = "Invalid wallet address",
       });
     }
-
-    var token = _authService.GenerateToken(user);
+    TokenHelper _tokenHelper = new TokenHelper(_config);
+    var token = _tokenHelper.GenerateToken(user);
 
     return Ok(new SignInResponseDto
     {

Controllers/CategoryController.cs

@@ -1,8 +1,9 @@
 using MARKETPLACEAPI.dto;
 using MARKETPLACEAPI.Models;
-using MARKETPLACEAPI.Services;
+using MARKETPLACEAPI.Interfaces;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using AutoMapper;
 
 namespace MARKETPLACEAPI.Controllers;
 
@@ -12,39 +13,62 @@ namespace MARKETPLACEAPI.Controllers;
 [Route("api/categories/[controller]")]
 public class CategoryController : ControllerBase
 {
-    private readonly CategoryService _categoryService;
+    private readonly IDefaultService<Category> _categoryService;
+    private readonly IMapper _mapper;
 
-    public CategoryController(CategoryService categoryService) =>
+    public CategoryController(IDefaultService<Category> categoryService, IMapper mapper) {
         _categoryService = categoryService;
-
+        _mapper = mapper;
+    }
+        
     [HttpGet]
-    public async Task<List<Category>> Get() =>
-        await _categoryService.GetAsync();
+    [ProducesResponseType(200, Type = typeof(IList<Category>))]
+    public async Task<IActionResult> Get() {
+        try
+        {
+            var categories = await _categoryService.GetAsync();
+            return Ok(categories);
+        }
+        catch (Exception ex)
+        {
+            return BadRequest(ex);
+        }
+
+    }
+        
 
     [HttpGet("{id:length(24)}")]
-    public async Task<ActionResult<Category>> Get(string id, [FromHeader] string userId)
+    [ProducesResponseType(typeof(Category), 200)]
+    public async Task<IActionResult> Get(string id)
     {
         var category = await _categoryService.GetAsync(id);
 
         if (category is null)
         {
-            return NotFound();
+            return NotFound(
+                new { Message = $"Category with id: {id} does not exist." }
+            );
         }
 
-        return category;
+        return Ok(category);
     }
 
     [HttpPost]
     [Authorize]
+    [ProducesResponseType(typeof(Category), 201)]
 
     public async Task<IActionResult> Post(CategoryCreateDto newCategory)
     {
-        var category = new Category
+        var category = _mapper.Map<Category>(newCategory);
+
+        try
         {
-            categoryName = newCategory.categoryName,
-            categoryDescription = newCategory.categoryDescription,
-        };
-        await _categoryService.CreateAsync(category);
+            await _categoryService.CreateAsync(category);
+        }
+        catch (Exception ex)
+        {
+            return BadRequest(ex.Message);
+        }
 
         return CreatedAtAction(nameof(Get), new { id = category.categoryId }, category);
     }
@@ -57,14 +81,14 @@ public async Task<IActionResult> Update(string id, CategoryUpdateDto updatedCate
 
         if (category is null)
         {
-            return NotFound();
+            return NotFound(
+                new { Message = $"Category with id: {id} does not exist." }
+            );
         }
 
-        category.categoryName = updatedCategory.categoryName;
-        category.categoryDescription = updatedCategory.categoryDescription;
-        category.updatedAt = DateTime.UtcNow;
+        var updatedCat = _mapper.Map(updatedCategory, category);
 
-        await _categoryService.UpdateAsync(id, category);
+        await _categoryService.UpdateAsync(id, updatedCat);
 
         return NoContent();
     }

Controllers/NftController.cs

@@ -1,8 +1,10 @@
 using MARKETPLACEAPI.dto;
 using MARKETPLACEAPI.Models;
-using MARKETPLACEAPI.Services;
+using MARKETPLACEAPI.Interfaces;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using AutoMapper;
+
 
 namespace MARKETPLACEAPI.Controllers;
 
@@ -12,20 +14,24 @@ namespace MARKETPLACEAPI.Controllers;
 [Route("api/user/[controller]")]
 public class NftController : ControllerBase
 {
-    private readonly NftService _nftService;
-    private readonly CategoryService _categoryService;
+    private readonly INftService _nftService;
+    private readonly IDefaultService<Category> _categoryService;
+    private readonly IMapper _mapper;
 
-    public NftController(NftService nftService, CategoryService categoryService) {
+    public NftController(INftService nftService, IDefaultService<Category> categoryService, IMapper mapper) {
         _nftService = nftService;
         _categoryService = categoryService;
+        _mapper = mapper;
     }
 
     [HttpGet]
-    public async Task<List<Nft>> Get() =>
-        await _nftService.GetAsync();
+    [ProducesResponseType(typeof(IList<Nft>), 200)]
+    public async Task<IActionResult> Get() =>
+        Ok(await _nftService.GetAsync());
 
     [HttpGet("{id:length(24)}")]
-    public async Task<ActionResult<NftDto>> Get(string id)
+    [ProducesResponseType(typeof(NftDto), 200)]
+    public async Task<IActionResult> Get(string id)
     {
         var nft = await _nftService.GetAsync(id);
         if (nft is null)
@@ -35,11 +41,11 @@ public async Task<ActionResult<NftDto>> Get(string id)
 
         var nftDto = new NftDto
         {
-           nft = nft,
-           category = await _categoryService.GetAsync(nft.categoryId),
+            nft = nft,
+            category = await _categoryService.GetAsync(nft.categoryId)
         };
 
-        return nftDto;
+        return Ok(nftDto);
     }
 
     [HttpPost]
@@ -48,17 +54,11 @@ public async Task<IActionResult> Post(NftCreateDto newNft)
     {   
         var userId = HttpContext.Request.Headers["userId"].ToString();
 
-    var nft = new Nft
-    {
-      nftName = newNft.nftName,
-      nftDescription = newNft.nftDescription,
-      price = newNft.price,
-      ownerId = userId,
-      creatorId = userId,
-      categoryId = newNft.categoryId
-    };
-    
-    await _nftService.CreateAsync(nft);
+        var nft = _mapper.Map<Nft>(newNft);
+        nft.creatorId = userId;
+        nft.ownerId = userId;
+        
+        await _nftService.CreateAsync(nft);
 
         return CreatedAtAction(nameof(Get), new { id = nft.nftId }, nft);
     }
@@ -74,13 +74,10 @@ public async Task<IActionResult> Update(string id, NftUpdateDto updatedNft)
             return NotFound();
         }
 
-        nft.nftName = updatedNft.nftName ?? nft.nftName;
-        nft.nftDescription = updatedNft.nftDescription ?? nft.nftDescription;
-        nft.price = updatedNft.price ?? nft.price;
-        nft.updatedAt = DateTime.UtcNow;
+        var nftUpdate= _mapper.Map(updatedNft, nft);
 
 
-        await _nftService.UpdateAsync(id, nft);
+        await _nftService.UpdateAsync(id, nftUpdate);
 
         return NoContent();
     }
@@ -102,20 +99,24 @@ public async Task<IActionResult> Delete(string id)
     }
 
     [HttpGet("creator")]
-    public async Task<List<Nft>> GetNftsByCreatorId([FromQuery] string creatorId) =>
-        await _nftService.GetNftsByCreatorId(creatorId);
+    [ProducesResponseType(typeof(IList<Nft>), 200)]
+    public async Task<IActionResult> GetNftsByCreatorId([FromQuery] string creatorId) =>
+        Ok(await _nftService.GetNftsByCreatorId(creatorId));
 
     [HttpGet("owner")]
-    public async Task<List<Nft>> GetNftsByOwnerId([FromQuery] string ownerId) =>
-        await _nftService.GetNftsByOwnerId(ownerId);
+    [ProducesResponseType(typeof(IList<Nft>), 200)]
+    public async Task<IActionResult> GetNftsByOwnerId([FromQuery] string ownerId) =>
+        Ok(await _nftService.GetNftsByOwnerId(ownerId));
 
     [HttpGet("with-price-filter")]
-    public async Task<List<Nft>> GetNftWithPriceFilter( 
+    [ProducesResponseType(typeof(IList<Nft>), 200)]
+    public async Task<IActionResult> GetNftWithPriceFilter( 
     [FromQuery] double? priceMax, [FromQuery] double?
      priceMin, [FromQuery] bool? ascending = true) =>
-        await _nftService.GetNftWithPriceFilter(priceMax, priceMin, ascending);
+        Ok(await _nftService.GetNftWithPriceFilter(priceMax, priceMin, ascending));
 
     [HttpGet("search")]
-    public async Task<List<Nft>> SearchByNftName([FromQuery] string nftName, [FromQuery] bool ascending = true) =>
-        await _nftService.SearchByNftName(nftName, ascending);
+    [ProducesResponseType(typeof(IList<Nft>), 200)]
+    public async Task<IActionResult> SearchByNftName([FromQuery] string nftName, [FromQuery] bool ascending = true) =>
+        Ok(await _nftService.SearchByNftName(nftName, ascending));
 }