feat: create word and add some abtractions

src/Core/EnglishNote.Application/Abtractions/IDateTimeProvider.cs

@@ -0,0 +1,6 @@
+namespace EnglishNote.Application.Abtractions;
+public interface IDateTimeProvider
+{
+    DateTime UtcNow { get; }
+    DateTime Now { get; }
+}

src/Core/EnglishNote.Application/Abtractions/IGuidGenerator.cs

@@ -0,0 +1,5 @@
+namespace EnglishNote.Application.Abtractions;
+public interface IGuidGenerator
+{
+    Guid NewGuid();
+}

src/Core/EnglishNote.Application/IAssemblyMarker.cs

@@ -1,4 +1,2 @@
 namespace EnglishNote.Application;
-internal interface IAssemblyMarker
-{
-}
+internal interface IAssemblyMarker;

src/Core/EnglishNote.Application/UseCases/Tags/CreateTag/CreateTagCommandHandler.cs

@@ -1,20 +1,23 @@
-using EnglishNote.Application.Abtractions.Authentication;
+using EnglishNote.Application.Abtractions;
+using EnglishNote.Application.Abtractions.Authentication;
 using EnglishNote.Application.Abtractions.Commands;
 using EnglishNote.Domain.AggregatesModel.Tags;
 using Shared;
 
 namespace EnglishNote.Application.UseCases.Tags.CreateTag;
 internal class CreateTagCommandHandler(
     ITagRepository tagRepository,
-    IIdentityService identityService) : ICommandHandler<CreateTagCommand, Guid>
+    IIdentityService identityService,
+    IGuidGenerator guidGenerator) : ICommandHandler<CreateTagCommand, Guid>
 {
     public async Task<Result<Guid>> Handle(CreateTagCommand request, CancellationToken cancellationToken)
     {
-        var tag = Tag.CreateTag(request.Name, 
+        var tag = Tag.CreateTag(guidGenerator.NewGuid(),
+            request.Name, 
             request.Description, 
             identityService.GetUserIdentity());
 
-        await tagRepository.AddAsync(tag);        
+        await tagRepository.AddAsync(tag, cancellationToken);        
 
         return tag.Id;
     }

src/Core/EnglishNote.Application/UseCases/Words/CreateWord/CreateWordCommand.cs

@@ -0,0 +1,20 @@
+using EnglishNote.Application.Abtractions.Commands;
+using EnglishNote.Domain.AggregatesModel.Words;
+
+namespace EnglishNote.Application.UseCases.Words.CreateWord;
+public record CreateWordCommand(string WordText,
+     List<WordPhoneticRequest> Phonetics,
+     List<WordMeaningRequest> Meanings) : ICommand<Guid>;
+
+public record WordPhoneticRequest(string Text,
+    string? Audio,
+    string? CustomAudio);
+
+public record WordMeaningRequest(PartOfSpeech? PartOfSpeech,
+     CefrLevel? CefrLevel,
+     List<WorkDefinitionRequest> Definitions);
+
+public record WorkDefinitionRequest(string DefinitionText,
+     List<string> Synonyms,
+     List<string> Antonyms,
+     List<string> Examples);

src/Core/EnglishNote.Application/UseCases/Words/CreateWord/CreateWordCommandHandler.cs

@@ -0,0 +1,47 @@
+using EnglishNote.Application.Abtractions;
+using EnglishNote.Application.Abtractions.Authentication;
+using EnglishNote.Application.Abtractions.Commands;
+using EnglishNote.Domain.AggregatesModel.Words;
+using Shared;
+
+namespace EnglishNote.Application.UseCases.Words.CreateWord;
+internal sealed class CreateWordCommandHandler(IGuidGenerator guidGenerator,
+    IIdentityService identityService,
+    IWordRepository wordRepository) : ICommandHandler<CreateWordCommand, Guid>
+{
+    public async Task<Result<Guid>> Handle(CreateWordCommand request, CancellationToken cancellationToken)
+    {
+        var word = Word.Create(id: guidGenerator.NewGuid(),
+            wordText: request.WordText,
+            tagId: null,
+            vocabularySetId: null,
+            userId: identityService.GetUserIdentity(),
+            null);
+
+        foreach (var item in request.Phonetics)
+        {
+            word.AddPhonetic(item.Text, item.Audio, item.CustomAudio);
+        }
+
+        foreach (var meaning in request.Meanings)
+        {
+            if(meaning is null) continue;
+
+            var mean = word.CreateAndAddMeaning(meaning.PartOfSpeech, meaning.CefrLevel);
+
+            foreach (var definition in meaning.Definitions)
+            {
+                if(definition is null) continue;
+
+                word.AddDefinition(mean, 
+                    definition.DefinitionText, 
+                    definition.Synonyms, 
+                    definition.Antonyms, 
+                    definition.Examples);
+            }
+        }
+
+        await wordRepository.AddAsync(word, cancellationToken);
+        return word.Id;
+    }
+}

src/Core/EnglishNote.Domain/AggregatesModel/Tags/ITagRepository.cs

@@ -1,5 +1,5 @@
 namespace EnglishNote.Domain.AggregatesModel.Tags;
 public interface ITagRepository
 {
-    Task AddAsync(Tag tag);
+    Task AddAsync(Tag tag, CancellationToken cancellationToken = default);
 }

src/Core/EnglishNote.Domain/AggregatesModel/Tags/Tag.cs

@@ -19,11 +19,14 @@ public class Tag : AggregateRoot
 
     private Tag() { }
 
-    public static Tag CreateTag(string name, string? description, Guid userId)
+    public static Tag CreateTag(Guid id,
+        string name, 
+        string? description, 
+        Guid userId)
     {
         return new Tag()
         {
-            Id = Guid.CreateVersion7(),
+            Id = id,
             Name = name,
             Description = description,
             UserId = userId

src/Core/EnglishNote.Domain/AggregatesModel/Words/Antonym.cs

@@ -3,9 +3,19 @@
 namespace EnglishNote.Domain.AggregatesModel.Words;
 public class Antonym : ValueObject
 {
-    public string Value { get; private set; }
+    private Antonym() { }
+
+    public string? Value { get; private set; }
     protected override IEnumerable<object> GetEqualityComponents()
     {
         yield return Value;
     }
+
+    internal static Antonym Create(string value)
+    {
+        return new Antonym()
+        {
+            Value = value
+        };
+    }
 }

src/Core/EnglishNote.Domain/AggregatesModel/Words/CefrLevel.cs

@@ -0,0 +1,10 @@
+namespace EnglishNote.Domain.AggregatesModel.Words;
+public enum CefrLevel
+{
+    A1 = 1,
+    A2 = 2,
+    B1 = 3,
+    B2 = 4,
+    C1 = 5,
+    C2 = 6,
+}

src/Core/EnglishNote.Domain/AggregatesModel/Words/Definition.cs

@@ -3,6 +3,8 @@
 namespace EnglishNote.Domain.AggregatesModel.Words;
 public class Definition : ValueObject
 {
+    private Definition() { }
+
     public string DefinitionText { get; private set; }
     public IReadOnlyCollection<Synonym> Synonyms => _synonyms.AsReadOnly();
     public IReadOnlyCollection<Antonym> Antonyms => _antonyms.AsReadOnly();
@@ -19,4 +21,44 @@ protected override IEnumerable<object> GetEqualityComponents()
         yield return Antonyms;
         yield return Examples;
     }
+
+    internal static Definition Create(string definitionText,
+                                      List<string> synonyms,
+                                      List<string> antonyms,
+                                      List<string> examples)
+    {
+        var definition = new Definition()
+        {
+            DefinitionText = definitionText
+        };
+
+        definition.AddExample(examples);
+        definition.AddSynonyms(synonyms);
+        definition.AddAntonyms(antonyms);
+
+        return definition;
+    }
+
+    internal void AddSynonyms(List<string> synonyms) {
+        foreach (var item in synonyms)
+        {
+            _synonyms.Add(Synonym.Create(item));
+        }
+    }
+
+    internal void AddAntonyms(List<string> antonyms)
+    {
+        foreach (var item in antonyms)
+        {
+            _antonyms.Add(Antonym.Create(item));
+        }
+    }
+
+    internal void AddExample(List<string> examples)
+    {
+        foreach(var item in examples)
+        {
+            _examples.Add(Example.Create(item));
+        }
+    }
 }

src/Core/EnglishNote.Domain/AggregatesModel/Words/Example.cs

@@ -3,9 +3,19 @@
 namespace EnglishNote.Domain.AggregatesModel.Words;
 public class Example : ValueObject
 {
+    private Example() { }
+
     public string Value { get; private set; }
     protected override IEnumerable<object> GetEqualityComponents()
     {
         yield return Value;
     }
+
+    internal static Example Create(string value)
+    {
+        return new Example()
+        {
+            Value = value
+        };
+    }
 }

src/Core/EnglishNote.Domain/AggregatesModel/Words/IWordRepository.cs

@@ -0,0 +1,5 @@
+namespace EnglishNote.Domain.AggregatesModel.Words;
+public interface IWordRepository
+{
+    Task AddAsync(Word word, CancellationToken cancellationToken = default);
+}

src/Core/EnglishNote.Domain/AggregatesModel/Words/PartOfSpeech.cs

@@ -0,0 +1,12 @@
+namespace EnglishNote.Domain.AggregatesModel.Words;
+public enum PartOfSpeech
+{
+    Noun = 1,
+    Pronoun = 2,
+    Verb = 3,
+    Adjective = 4,
+    Adverb = 5,
+    Preposition = 6,
+    Conjunction = 7,
+    Interjection = 8
+}

src/Core/EnglishNote.Domain/AggregatesModel/Words/Synonym.cs

@@ -3,9 +3,16 @@
 namespace EnglishNote.Domain.AggregatesModel.Words;
 public class Synonym : ValueObject
 {
+    private Synonym() { }
+
     public string Value { get; private set; }
     protected override IEnumerable<object> GetEqualityComponents()
     {
         yield return Value;
     }
+
+    internal static Synonym Create(string value)
+    {
+        return new Synonym() { Value = value };
+    }
 }

src/Core/EnglishNote.Domain/AggregatesModel/Words/Word.cs

@@ -8,19 +8,71 @@ namespace EnglishNote.Domain.AggregatesModel.Words;
 public class Word : AggregateRoot
 {
     public string WordText { get; private set; }
-    public IReadOnlyList<Phonetic> Phonetics => _phonetics.AsReadOnly();
-    public IReadOnlyList<Meaning> Meanings => _meanings.AsReadOnly();
+    public IReadOnlyList<WordPhonetic> Phonetics => _phonetics.AsReadOnly();
+    public IReadOnlyList<WordMeaning> Meanings => _meanings.AsReadOnly();
     public MemoryLevel? MemoryLevel { get; private set; }
 
-    public Tag Tag { get; private set; }
-    public Guid TagId { get; private set; }
+    public Tag? Tag { get; private set; }
+    public Guid? TagId { get; private set; }
 
     public Guid UserId { get; private set; }
     public ApplicationUser User { get; private set; }
 
-    public VocabularySet VocabularySet { get; private set; }
-    public Guid VocabularySetId { get; private set; }
+    public VocabularySet? VocabularySet { get; private set; }
+    public Guid? VocabularySetId { get; private set; }
 
-    private readonly List<Phonetic> _phonetics = [];
-    private readonly List<Meaning> _meanings = [];
-}
+    private readonly List<WordPhonetic> _phonetics = [];
+    private readonly List<WordMeaning> _meanings = [];
+
+    public static Word Create(Guid id,
+                              string wordText,
+                              Guid? tagId,
+                              Guid? vocabularySetId,
+                              Guid userId,
+                              MemoryLevel? memoryLevel
+
+    )
+    {
+        var word = new Word()
+        {
+           Id = id,
+           WordText = wordText,
+           TagId = tagId,
+           VocabularySetId = vocabularySetId,
+           UserId = userId,
+           MemoryLevel = memoryLevel
+        }; 
+
+        return word;
+    }
+
+    public void AddPhonetic(string text, 
+        string? audio, 
+        string? customAudio)
+    {
+        var phonetic = WordPhonetic.Create(text, audio, customAudio);
+        _phonetics.Add(phonetic);
+    }
+
+    public void AddMeaning(PartOfSpeech? partOfSpeech, CefrLevel? cefrLevel)
+    {
+        var meaning = WordMeaning.Create(partOfSpeech, cefrLevel);
+        _meanings.Add(meaning);
+    }
+
+    public WordMeaning CreateAndAddMeaning(PartOfSpeech? partOfSpeech, CefrLevel? cefrLevel)
+    {
+        var meaning = WordMeaning.Create(partOfSpeech, cefrLevel);
+        _meanings.Add(meaning);
+        return meaning;
+    }
+
+    public void AddDefinition(WordMeaning meaning,
+         string definitionText,
+         List<string> synonyms,
+         List<string> antonyms,
+         List<string> examples)
+    { 
+         meaning.AddDefinition(definitionText, synonyms, antonyms, examples);
+    }
+}

src/Core/EnglishNote.Domain/AggregatesModel/Words/WordManner.cs

@@ -0,0 +1,7 @@
+using EnglishNote.Domain.SeedWork;
+
+namespace EnglishNote.Domain.AggregatesModel.Words;
+public sealed class WordManner : DomainService
+{
+
+}