Final Commit

.vscode/launch.json

@@ -0,0 +1,35 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+        {
+            // Use IntelliSense to find out which attributes exist for C# debugging
+            // Use hover for the description of the existing attributes
+            // For further information visit https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md
+            "name": ".NET Core Launch (web)",
+            "type": "coreclr",
+            "request": "launch",
+            "preLaunchTask": "build",
+            // If you have changed target frameworks, make sure to update the program path.
+            "program": "${workspaceFolder}/bin/Debug/net6.0/VocabularyVault.dll",
+            "args": [],
+            "cwd": "${workspaceFolder}",
+            "stopAtEntry": false,
+            // Enable launching a web browser when ASP.NET Core starts. For more information: https://aka.ms/VSCode-CS-LaunchJson-WebBrowser
+            "serverReadyAction": {
+                "action": "openExternally",
+                "pattern": "\\bNow listening on:\\s+(https?://\\S+)"
+            },
+            "env": {
+                "ASPNETCORE_ENVIRONMENT": "Development"
+            },
+            "sourceFileMap": {
+                "/Views": "${workspaceFolder}/Views"
+            }
+        },
+        {
+            "name": ".NET Core Attach",
+            "type": "coreclr",
+            "request": "attach"
+        }
+    ]
+}

.vscode/tasks.json

@@ -0,0 +1,41 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "build",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "build",
+                "${workspaceFolder}/VocabularyVault.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "publish",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "publish",
+                "${workspaceFolder}/VocabularyVault.csproj",
+                "/property:GenerateFullPaths=true",
+                "/consoleloggerparameters:NoSummary"
+            ],
+            "problemMatcher": "$msCompile"
+        },
+        {
+            "label": "watch",
+            "command": "dotnet",
+            "type": "process",
+            "args": [
+                "watch",
+                "run",
+                "--project",
+                "${workspaceFolder}/VocabularyVault.csproj"
+            ],
+            "problemMatcher": "$msCompile"
+        }
+    ]
+}

Controllers/VocabularyController.cs

@@ -0,0 +1,83 @@
+using Microsoft.AspNetCore.Mvc;
+using VocabularyVault.Data;
+using VocabularyVault.Dtos;
+using VocabularyVault.Models;
+using VocabularyVault.Services;
+using VocabularyVault.VaultManager;
+
+namespace VocabularyVault;
+
+[Route("api/vault")]
+[ApiController]
+public class VocabularyController : ControllerBase
+{
+    private readonly ISeacrhDictionary _searchDictionary;
+    private readonly IVaultOperation _vaultOperation;
+    private readonly IVaultRepo _repo;
+
+    public VocabularyController(ISeacrhDictionary seacrhDictionary, IVaultOperation vaultOperation, IVaultRepo repo)
+    {
+        _searchDictionary = seacrhDictionary;
+        _vaultOperation = vaultOperation;
+        _repo = repo;
+    }
+    [HttpGet("search/{word}")]
+    public async Task<ActionResult<WordDetails>> SearchWordInDictionary(string word)
+    {
+        if (string.IsNullOrWhiteSpace(word))
+        {
+            return BadRequest("Invalid word.");
+        }
+        var data = await _searchDictionary.SearchWordInDictionary(word);
+        if (data == null)
+        {
+            return NotFound("Word not found in the dictionary.");
+        }
+        return Ok(data);
+    }
+
+    [HttpPost("add")]
+    public async Task<ActionResult<string>> AddVocabulryToVault(AddFavouriteWordRequestDto addFavouriteWordRequestDto)
+    {
+        var data = await _vaultOperation.AddFavouriteInVault(addFavouriteWordRequestDto);
+        if (data == null)
+        {
+            return NotFound("Failed to add the word to the vault.");
+        }
+        return Ok(data);
+    }
+
+    [HttpPost("add-detail")]
+    public async Task<ActionResult<string>> AddMoreWordDetails(AddMoreWordDetailsRequestDto addMoreWordDetailsRequestDto)
+    {
+        var data = await _vaultOperation.AddMoreWordDetailsInVault(addMoreWordDetailsRequestDto);
+        if (data == null)
+        {
+            return NotFound("Failed to add details of word to the vault.");
+        }
+        return Ok(data);
+    }
+
+    [HttpGet("get")]
+    public async Task<ActionResult<IEnumerable<FavouriteWords>>> GetVaultData()
+    {
+        var favourites = await _vaultOperation.GetAllFromVault();
+        return Ok(favourites);
+
+    }
+
+    [HttpDelete("remove/{word}")]
+    public async Task<ActionResult<string>> RemoveDataFromVault(string word)
+    {
+        var removed = await _vaultOperation.RemoveWordFromVault(word);
+        if (removed)
+        {
+            return Ok($"{word} removed !!!");
+        }
+        else
+        {
+            return NotFound("Word not found in the vault.");
+        }
+    }
+
+}

Data/AppDbContext.cs

@@ -0,0 +1,15 @@
+using Microsoft.EntityFrameworkCore;
+using VocabularyVault.Models;
+
+namespace VocabularyVault.Data;
+
+public class AppDbContext : DbContext
+{
+    public AppDbContext(DbContextOptions<AppDbContext> options) : base(options)
+    {
+
+    }
+
+    public DbSet<FavouriteWords> FavouriteWords => Set<FavouriteWords>();
+    public DbSet<FavouriteWordDetails> FavouriteWordsDetails => Set<FavouriteWordDetails>();
+}

Data/IVaultRepo.cs

@@ -0,0 +1,14 @@
+using VocabularyVault.Dtos;
+using VocabularyVault.Models;
+
+namespace VocabularyVault.Data;
+
+public interface IVaultRepo
+{
+    Task SaveChangesAysnc();
+    Task<IEnumerable<FavouriteWords>> GetAllFavouritesInVaultAsync();
+    Task<bool> RemoveFavouritesInVaultAsync(string word);
+    Task AddFavouritesInVaultAsync(AddFavouriteWordRequestDto addFavouriteWord);
+    Task AddMoreWordDetailsInVaultAsync(AddMoreWordDetailsRequestDto addMoreWordDetails);
+    Task<FavouriteWords?> SearchWordAsync(string word);
+}

Data/VaultRepo.cs

@@ -0,0 +1,73 @@
+using Microsoft.EntityFrameworkCore;
+using VocabularyVault.Dtos;
+using VocabularyVault.Models;
+
+namespace VocabularyVault.Data;
+
+public class VaultRepo : IVaultRepo
+{
+    private readonly AppDbContext _context;
+
+    public VaultRepo(AppDbContext context)
+    {
+        _context = context;
+    }
+    public async Task AddFavouritesInVaultAsync(AddFavouriteWordRequestDto addFavouriteWord)
+    {
+        var favouriteWordToAdd = FavouriteWords.Parse(addFavouriteWord);
+        await _context.FavouriteWords.AddAsync(favouriteWordToAdd);
+        await _context.SaveChangesAsync();
+    }
+
+    public async Task AddMoreWordDetailsInVaultAsync(AddMoreWordDetailsRequestDto addMoreWordDetails)
+    {
+        var wordToUpdate = await _context.FavouriteWords.SingleOrDefaultAsync(x => x.Word == addMoreWordDetails.Word);
+
+        if (wordToUpdate == null)
+        {
+            throw new Exception("The word does not exist in the vault.");
+        }
+
+        var newDetails = new FavouriteWordDetails
+        {
+            Defination = addMoreWordDetails.Defination,
+            UsageType = addMoreWordDetails.UsageType,
+            Synonyms = addMoreWordDetails.Synonyms,
+            Antonyms = addMoreWordDetails.Antonyms
+        };
+
+        wordToUpdate.Details.Add(newDetails);
+        await _context.SaveChangesAsync();
+    }
+
+    public async Task<IEnumerable<FavouriteWords>> GetAllFavouritesInVaultAsync()
+    {
+        return await _context.FavouriteWords.Include(x => x.Details).ToListAsync();
+    }
+
+    public async Task<bool> RemoveFavouritesInVaultAsync(string word)
+    {
+        var wordToRemove = await _context.FavouriteWords.FirstOrDefaultAsync(x => x.Word == word);
+        if (wordToRemove != null)
+        {
+            _context.FavouriteWords.Remove(wordToRemove);
+            await _context.SaveChangesAsync();
+            return true;
+        }
+        return false;
+    }
+
+    public async Task SaveChangesAysnc()
+    {
+        await _context.SaveChangesAsync();
+    }
+
+    public async Task<FavouriteWords?> SearchWordAsync(string word)
+    {
+        if (string.IsNullOrEmpty(word))
+        {
+            return null;
+        }
+        return await _context.FavouriteWords.FirstOrDefaultAsync(x => x.Word == word);
+    }
+}

Dtos/AddFavouriteWordRequestDto.cs

@@ -0,0 +1,11 @@
+namespace VocabularyVault.Dtos;
+
+public class AddFavouriteWordRequestDto
+{
+    public string? Word { get; set; }
+    public string? Phonetic { get; set; }
+    public string? UsageType { get; set; }
+    public string? Defination { get; set; }
+    public string? Synonyms { get; set; }
+    public string? Antonyms { get; set; }
+}

Dtos/AddMoreWordDetailsRequestDto.cs

@@ -0,0 +1,10 @@
+namespace VocabularyVault.Dtos;
+
+public class AddMoreWordDetailsRequestDto
+{
+    public string? Word { get; set; }
+    public string? UsageType { get; set; }
+    public string? Defination { get; set; }
+    public string? Synonyms { get; set; }
+    public string? Antonyms { get; set; }
+}

Dtos/GetAllWordsInVaultResponseDto.cs

@@ -0,0 +1,28 @@
+using VocabularyVault.Models;
+
+namespace VocabularyVault.Dtos;
+
+public class GetAllWordsInVaultResponseDto
+{
+    public string? word { get; set; }
+    public string? Phonetic { get; set; }
+    public List<CustomWordDetails>? RealExamples { get; set; }
+
+    public static List<GetAllWordsInVaultResponseDto> Parse(IEnumerable<FavouriteWords> favourites)
+    {
+        var dataToReturn = new List<GetAllWordsInVaultResponseDto>();
+
+        foreach (var favourite in favourites)
+        {
+            var temp = new GetAllWordsInVaultResponseDto
+            {
+                word = favourite.Word,
+                Phonetic = favourite.Phonetic,
+                RealExamples = new List<CustomWordDetails>()
+            };
+            temp.RealExamples = CustomWordDetails.Parse(favourite.Details);
+            dataToReturn.Add(temp);
+        }
+        return dataToReturn;
+    }
+}

Models/CustomWordDetails.cs

@@ -0,0 +1,28 @@
+namespace VocabularyVault.Models
+{
+    public class CustomWordDetails
+    {
+        public string? UsageType { get; set; }
+        public string? Defination { get; set; }
+        public string? Synonyms { get; set; }
+        public string? Antonyms { get; set; }
+
+        public static List<CustomWordDetails> Parse(ICollection<FavouriteWordDetails> favouriteWordDetails)
+        {
+            var dataToReturn = new List<CustomWordDetails>();
+
+            foreach (var detail in favouriteWordDetails)
+            {
+                var temp = new CustomWordDetails
+                {
+                    UsageType = detail.UsageType,
+                    Defination = detail.Defination,
+                    Synonyms = detail.Synonyms,
+                    Antonyms = detail.Antonyms
+                };
+                dataToReturn.Add(temp);
+            }
+            return dataToReturn;
+        }
+    }
+}

Models/FavouriteWordDetails.cs

@@ -0,0 +1,26 @@
+using System.ComponentModel.DataAnnotations;
+using VocabularyVault.Dtos;
+
+namespace VocabularyVault.Models;
+
+public class FavouriteWordDetails
+{
+    [Key]
+    public int Id { get; set; }
+    public string? UsageType { get; set; }
+    public string? Defination { get; set; }
+    public string? Synonyms { get; set; }
+    public string? Antonyms { get; set; }
+    public virtual FavouriteWords? FavouriteWords { get; set; }
+
+    public static FavouriteWordDetails Parse(AddFavouriteWordRequestDto addFavouriteWordRequest)
+    {
+        return new FavouriteWordDetails
+        {
+            UsageType = addFavouriteWordRequest.UsageType,
+            Defination = addFavouriteWordRequest.Defination,
+            Antonyms = addFavouriteWordRequest.Antonyms,
+            Synonyms = addFavouriteWordRequest.Synonyms
+        };
+    }
+}