Deployed backend with mongoDB

Author: folathecoder

Controllers/AuthController.cs

@@ -0,0 +1,101 @@
+using MARKETPLACEAPI.dto;
+using MARKETPLACEAPI.Models;
+using MARKETPLACEAPI.Services;
+using Microsoft.AspNetCore.Mvc;
+
+namespace MARKETPLACEAPI.Controllers;
+
+
+[ApiController]
+[Produces("application/json")]
+[Consumes("application/json")]
+[Route("api/auth/[controller]")]
+public class AuthController : ControllerBase
+{
+  private readonly UserService _userService;
+  private readonly AuthService _authService;
+
+  public AuthController(UserService userService, AuthService authService)
+  {
+    _userService = userService;
+    _authService = authService;
+  }
+  
+
+  [HttpPost("register")]
+  [ProducesResponseType(typeof(SignInResponseDto), 201)]
+  public async Task<IActionResult> Register(SignInRegisterDto regDto)
+  {
+    var user = await _userService.GetUserByWalletAddress(regDto.walletAddress);
+    if (user != null)
+    {
+      var res = new SignInResponseDto
+      {
+        walletAddress = user.walletAddress,
+        accountCreated = false,
+        accountSignedIn = true,
+        accountExists = true,
+        invalidAddress = false,
+        errorMessage = null,
+        token = _authService.GenerateToken(user),
+      };
+      return Ok(res);
+    } 
+    
+    var newUser = new User
+    {
+      userName = regDto.userName,
+      walletAddress = regDto.walletAddress,
+      socials = regDto.socials,
+    };
+    await _userService.CreateAsync(newUser);
+
+    var response = new SignInResponseDto
+    {
+      walletAddress = newUser.walletAddress,
+      accountCreated = true,
+      accountSignedIn = true,
+      accountExists = false,
+      invalidAddress = false,
+      errorMessage = null,
+      token = _authService.GenerateToken(newUser),
+    };
+
+    return Ok(response);
+  }
+
+
+  [HttpPost("login")]
+  [ProducesResponseType(typeof(SignInResponseDto), StatusCodes.Status200OK)]
+  public async Task<IActionResult> Login(LoginDto loginDto)
+  {
+    var user = await _userService.GetUserByWalletAddress(loginDto.walletAddress!);
+
+    if (user is null)
+    {
+      return Unauthorized(new SignInResponseDto
+      {
+        walletAddress = null,
+        accountCreated = false,
+        accountSignedIn = false,
+        accountExists = false,
+        invalidAddress = true,
+        errorMessage = "Invalid wallet address",
+      });
+    }
+
+    var token = _authService.GenerateToken(user);
+
+    return Ok(new SignInResponseDto
+    {
+      walletAddress = user.walletAddress,
+      accountCreated = false,
+      accountSignedIn = true,
+      accountExists = true,
+      invalidAddress = false,
+      errorMessage = null,
+      token = token,
+    });
+  }
+}
+

Controllers/CategoryController.cs

@@ -0,0 +1,85 @@
+using MARKETPLACEAPI.dto;
+using MARKETPLACEAPI.Models;
+using MARKETPLACEAPI.Services;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace MARKETPLACEAPI.Controllers;
+
+[ApiController]
+[Produces("application/json")]
+[Consumes("application/json")]
+[Authorize]
+[Route("api/categories/[controller]")]
+public class CategoryController : ControllerBase
+{
+    private readonly CategoryService _categoryService;
+
+    public CategoryController(CategoryService categoryService) =>
+        _categoryService = categoryService;
+
+    [HttpGet]
+    public async Task<List<Category>> Get() =>
+        await _categoryService.GetAsync();
+
+    [HttpGet("{id:length(24)}")]
+    public async Task<ActionResult<Category>> Get(string id, [FromHeader] string userId)
+    {
+        var category = await _categoryService.GetAsync(id);
+
+        if (category is null)
+        {
+            return NotFound();
+        }
+
+        return category;
+    }
+
+    [HttpPost]
+
+    public async Task<IActionResult> Post(CategoryCreateDto newCategory)
+    {
+        var category = new Category
+        {
+            categoryName = newCategory.categoryName,
+            categoryDescription = newCategory.categoryDescription,
+        };
+        await _categoryService.CreateAsync(category);
+
+        return CreatedAtAction(nameof(Get), new { id = category.categoryId }, category);
+    }
+
+    [HttpPatch("{id:length(24)}")]
+    public async Task<IActionResult> Update(string id, CategoryUpdateDto updatedCategory)
+    {
+        var category = await _categoryService.GetAsync(id);
+
+        if (category is null)
+        {
+            return NotFound();
+        }
+
+        category.categoryName = updatedCategory.categoryName;
+        category.categoryDescription = updatedCategory.categoryDescription;
+        category.updatedAt = DateTime.UtcNow;
+
+        await _categoryService.UpdateAsync(id, category);
+
+        return NoContent();
+    }
+
+    [HttpDelete("{id:length(24)}")]
+    public async Task<IActionResult> Delete(string id)
+    {
+        var category = await _categoryService.GetAsync(id);
+
+        if (category is null)
+        {
+            return NotFound();
+        }
+
+        await _categoryService.RemoveAsync(id);
+
+        return NoContent();
+    }
+}

Controllers/NftController.cs

@@ -0,0 +1,119 @@
+using MARKETPLACEAPI.dto;
+using MARKETPLACEAPI.Models;
+using MARKETPLACEAPI.Services;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace MARKETPLACEAPI.Controllers;
+
+[ApiController]
+[Produces("application/json")]
+[Consumes("application/json")]
+[Authorize]
+[Route("api/user/[controller]")]
+public class NftController : ControllerBase
+{
+    private readonly NftService _nftService;
+    private readonly CategoryService _categoryService;
+
+    public NftController(NftService nftService, CategoryService categoryService) {
+        _nftService = nftService;
+        _categoryService = categoryService;
+    }
+
+    [HttpGet]
+    public async Task<List<Nft>> Get() =>
+        await _nftService.GetAsync();
+
+    [HttpGet("{id:length(24)}")]
+    public async Task<ActionResult<NftDto>> Get(string id)
+    {
+        var nft = await _nftService.GetAsync(id);
+        if (nft is null)
+        {
+            return NotFound();
+        }
+
+        var nftDto = new NftDto
+        {
+           nft = nft,
+           category = await _categoryService.GetAsync(nft.categoryId),
+        };
+        
+        return nftDto;
+    }
+
+    [HttpPost]
+    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);
+
+        return CreatedAtAction(nameof(Get), new { id = nft.nftId }, nft);
+    }
+
+    [HttpPatch("{id:length(24)}")]
+    public async Task<IActionResult> Update(string id, NftUpdateDto updatedNft)
+    {
+        var nft = await _nftService.GetAsync(id);
+
+        if (nft is null)
+        {
+            return NotFound();
+        }
+
+        nft.nftName = updatedNft.nftName ?? nft.nftName;
+        nft.nftDescription = updatedNft.nftDescription ?? nft.nftDescription;
+        nft.price = updatedNft.price ?? nft.price;
+        nft.updatedAt = DateTime.UtcNow;
+
+
+        await _nftService.UpdateAsync(id, nft);
+
+        return NoContent();
+    }
+
+    [HttpDelete("{id:length(24)}")]
+    public async Task<IActionResult> Delete(string id)
+    {
+        var nft = await _nftService.GetAsync(id);
+
+        if (nft is null)
+        {
+            return NotFound();
+        }
+
+        await _nftService.RemoveAsync(id);
+
+        return NoContent();
+    }
+
+    [HttpGet("creator")]
+    public async Task<List<Nft>> GetNftsByCreatorId([FromQuery] string creatorId) =>
+        await _nftService.GetNftsByCreatorId(creatorId);
+
+    [HttpGet("owner")]
+    public async Task<List<Nft>> GetNftsByOwnerId([FromQuery] string ownerId) =>
+        await _nftService.GetNftsByOwnerId(ownerId);
+
+    [HttpGet("with-price-filter")]
+    public async Task<List<Nft>> GetNftWithPriceFilter( 
+    [FromQuery] double? priceMax, [FromQuery] double?
+     priceMin, [FromQuery] bool? ascending = true) =>
+        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);
+}