Add an option to bookmark reports and vulnerabilities (#39)

* Add an option to bookmark reports and vulnerabilities

Author: 0xGeorgii

Backend/SorobanSecurityPortalApi/Common/Data/Db.cs

@@ -2,7 +2,6 @@
 using SorobanSecurityPortalApi.Models.DbModels;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Diagnostics;
-using Pgvector;
 
 namespace SorobanSecurityPortalApi.Common.Data
 {
@@ -20,6 +19,7 @@ public class Db : DbContext
         public DbSet<CategoryModel> Category { get; set; }
         public DbSet<FileModel> File { get; set; }
         public DbSet<CompanyModel> Company { get; set; }
+        public DbSet<BookmarkModel> Bookmark { get; set; }
 
 
         private readonly IDbQuery _dbQuery;

Backend/SorobanSecurityPortalApi/Controllers/BookmarkController.cs

@@ -0,0 +1,59 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using SorobanSecurityPortalApi.Authorization.Attributes;
+using SorobanSecurityPortalApi.Common;
+using SorobanSecurityPortalApi.Models.DbModels;
+using SorobanSecurityPortalApi.Services.ControllersServices;
+
+namespace SorobanSecurityPortalApi.Controllers
+{
+    [ApiController]
+    [Authorize]
+    [Route("api/v1/bookmarks")]
+    public class BookmarkController : ControllerBase
+    {
+        private readonly IBookmarkService _bookmarkService;
+
+        public BookmarkController(IBookmarkService bookmarkService)
+        {
+            _bookmarkService = bookmarkService;
+        }
+
+        [HttpPost]
+        [Authorize]
+        public async Task<IActionResult> Add(BookmarkModel bookmarkModel)
+        {
+            var result = await _bookmarkService.Add(bookmarkModel);
+            return Ok(result);
+        }
+
+        [HttpDelete("{id}")]
+        [Authorize]
+        public async Task<IActionResult> Delete(int id)
+        {
+            await _bookmarkService.Delete(id);
+            return Ok();
+        }
+
+        [HttpGet]
+        [Authorize]
+        public async Task<IActionResult> List()
+        {
+            var result = await _bookmarkService.List();
+            return Ok(result);
+        }
+
+        [HttpGet]
+        [Route("{id}")]
+        public async Task<IActionResult> Get(int id)
+        {
+            var bookmarks = await _bookmarkService.List();
+            var bookmark = bookmarks.FirstOrDefault(a => a.Id == id);
+            if (bookmark == null)
+            {
+                return NotFound($"Bookmark with ID {id} not found.");
+            }
+            return Ok(bookmark);
+        }
+    }
+}

Backend/SorobanSecurityPortalApi/Data/Processors/BookmarkProcessor.cs

@@ -0,0 +1,135 @@
+using Microsoft.EntityFrameworkCore;
+using SorobanSecurityPortalApi.Common.Data;
+using SorobanSecurityPortalApi.Models.DbModels;
+using SorobanSecurityPortalApi.Models.ViewModels;
+
+namespace SorobanSecurityPortalApi.Data.Processors
+{
+    public class BookmarkProcessor : IBookmarkProcessor
+    {
+        private readonly IDbContextFactory<Db> _dbFactory;
+
+        public BookmarkProcessor(IDbContextFactory<Db> dbFactory)
+        {
+            _dbFactory = dbFactory;
+        }
+
+        public async Task<BookmarkModel> Get(int bookmarkModelId)
+        {
+            await using var db = await _dbFactory.CreateDbContextAsync();
+            var bookmark = await db.Bookmark.FindAsync(bookmarkModelId);
+            if (bookmark == null)
+            {
+                throw new KeyNotFoundException($"Bookmark with ID {bookmarkModelId} not found");
+            }
+            return bookmark;
+        }
+
+        public async Task<BookmarkViewModel> Add(BookmarkModel bookmarkModel)
+        {
+            await using var db = await _dbFactory.CreateDbContextAsync();
+            if (bookmarkModel == null)
+            {
+                throw new ArgumentNullException(nameof(bookmarkModel), "Bookmark model cannot be null");
+            }
+            var title = "";
+            var description = "";
+            if (bookmarkModel.BookmarkType == BookmarkTypeEnum.Report)
+            {
+                var report = await db.Report.FindAsync(bookmarkModel.ItemId);
+                if (report == null)
+                {
+                    throw new KeyNotFoundException($"Report with ID {bookmarkModel.ItemId} not found");
+                }
+                title = report.Name;
+            } 
+            else if (bookmarkModel.BookmarkType == BookmarkTypeEnum.Vulnerability)
+            {
+                var vulnerability = await db.Vulnerability.FindAsync(bookmarkModel.ItemId);
+                if (vulnerability == null)
+                {
+                    throw new KeyNotFoundException($"Vulnerability with ID {bookmarkModel.ItemId} not found");
+                }
+                title = vulnerability.Title;
+                description = vulnerability.Description;
+            }
+            else
+            {
+                throw new ArgumentException($"Invalid BookmarkType: {bookmarkModel.BookmarkType}");
+            }
+            db.Bookmark.Add(bookmarkModel);
+            await db.SaveChangesAsync();
+            return new BookmarkViewModel
+            {
+                Id = bookmarkModel.Id,
+                ItemId = bookmarkModel.ItemId,
+                BookmarkType = bookmarkModel.BookmarkType,
+                Title = title,
+                Description = description
+            };
+        }
+
+        public async Task Delete(int bookmarkModelId)
+        {
+            await using var db = await _dbFactory.CreateDbContextAsync();
+            var bookmark = await db.Bookmark.FindAsync(bookmarkModelId);
+            if (bookmark == null)
+            {
+                throw new KeyNotFoundException($"Bookmark with ID {bookmarkModelId} not found");
+            }
+            db.Bookmark.Remove(bookmark);
+            await db.SaveChangesAsync();
+        }
+
+        public async Task<List<BookmarkViewModel>> List()
+        {
+            await using var db = await _dbFactory.CreateDbContextAsync();
+            var bookmarks = await db.Bookmark.OrderByDescending(x => x.Id).ToListAsync();
+            var res = new List<BookmarkViewModel>();
+            foreach (var bookmark in bookmarks)
+            {
+                if (bookmark.BookmarkType == BookmarkTypeEnum.Report)
+                {
+                    var report = await db.Report.FindAsync(bookmark.ItemId);
+                    if (report == null)
+                    {
+                        throw new Exception($"Report with ID {bookmark.ItemId} not found for bookmark ID {bookmark.Id}");
+                    }
+                    res.Add(new BookmarkViewModel
+                    {
+                        Id = bookmark.Id,
+                        ItemId = report.Id,
+                        BookmarkType = bookmark.BookmarkType,
+                        Title = report.Name,
+                        Description = ""
+                    });
+                } else
+                {
+                    var vulnerability = await db.Vulnerability.FindAsync(bookmark.ItemId);
+                    if (vulnerability == null)
+                    {
+                        throw new Exception($"Vulnerability with ID {bookmark.ItemId} not found for bookmark ID {bookmark.Id}");
+                    }
+                    res.Add(new BookmarkViewModel
+                    {
+                        Id = bookmark.Id,
+                        ItemId = vulnerability.Id,
+                        BookmarkType = bookmark.BookmarkType,
+                        Title = vulnerability.Title,
+                        Description = vulnerability.Description
+                    });
+                }
+            }
+            return res;
+        }
+
+    }
+
+    public interface IBookmarkProcessor
+    {
+        Task<BookmarkModel> Get(int bookmarkModelId);
+        Task<BookmarkViewModel> Add(BookmarkModel bookmarkModel);
+        Task Delete(int bookmarkModelId);
+        Task<List<BookmarkViewModel>> List();
+    }
+}