✨ Implements API V1

Application/AnnotationOperations/Queries/FetchAnnotationFromEncyclopediaId/FetchAnnotationFromEncyclopediaIdQuery.cs

@@ -0,0 +1,6 @@
+using Application.Common.Abstractions.Messaging;
+using Domain.Entities;
+
+namespace Application.AnnotationOperations.Queries.FetchAnnotationFromEncyclopediaId;
+
+public sealed record FetchAnnotationFromEncyclopediaIdQuery(int EncyclopediaId): IQuery<AnnotationList>;

Application/AnnotationOperations/Queries/FetchAnnotationFromEncyclopediaId/FetchAnnotationFromEncyclopediaIdQueryHandler.cs

@@ -0,0 +1,18 @@
+using Application.Common.Abstractions.Messaging;
+using Application.Common.Databases;
+using Domain.Entities;
+using Domain.Shared;
+using Microsoft.Extensions.Logging;
+
+namespace Application.AnnotationOperations.Queries.FetchAnnotationFromEncyclopediaId;
+
+public sealed class FetchAnnotationFromEncyclopediaIdQueryHandler(
+    IAnnotationRepository annotationRepository,
+    IEncyclopediaRepository encyclopediaRepository,
+    ILogger<FetchAnnotationFromEncyclopediaIdQueryHandler> logger) : IQueryHandler<FetchAnnotationFromEncyclopediaIdQuery, AnnotationList>
+{
+    public async Task<Result<AnnotationList>> Handle(FetchAnnotationFromEncyclopediaIdQuery request, CancellationToken cancellationToken)
+    {
+        return await annotationRepository.FetchAnnotationFromEncyclopedia(request.EncyclopediaId, cancellationToken);
+    }
+}

Application/AnnotationOperations/Queries/FetchAnnotationFromId/FetchAnnotationFromIdQuery.cs

@@ -0,0 +1,6 @@
+using Application.Common.Abstractions.Messaging;
+using Domain.Entities;
+
+namespace Application.AnnotationOperations.Queries.FetchAnnotationFromId;
+
+public sealed record FetchAnnotationFromIdQuery(int id): IQuery<Annotation>;

Application/AnnotationOperations/Queries/FetchAnnotationFromId/FetchAnnotationFromIdQueryHandler.cs

@@ -0,0 +1,17 @@
+using Application.Common.Abstractions.Messaging;
+using Application.Common.Databases;
+using Domain.Entities;
+using Domain.Shared;
+
+namespace Application.AnnotationOperations.Queries.FetchAnnotationFromId;
+
+public class FetchAnnotationFromIdQueryHandler(
+    IAnnotationRepository repository
+    ): IQueryHandler<FetchAnnotationFromIdQuery, Annotation>
+{
+    public async Task<Result<Annotation>> Handle(FetchAnnotationFromIdQuery request,
+        CancellationToken cancellationToken)
+    {
+        return await repository.FetchAnnotationFromId(request.id, cancellationToken);
+    }
+}

Application/Common/Databases/IAnnotationRepository.cs

@@ -0,0 +1,10 @@
+using Domain.Entities;
+using Domain.Shared;
+
+namespace Application.Common.Databases;
+
+public interface IAnnotationRepository
+{
+    Task<Result<AnnotationList>> FetchAnnotationFromEncyclopedia(int encyclopediaId, CancellationToken cancellationToken);
+    Task<Result<Annotation>> FetchAnnotationFromId(int id, CancellationToken cancellationToken);
+}

Application/Common/Databases/IEncyclopediaRepository.cs

@@ -0,0 +1,9 @@
+using Domain.Entities;
+using Domain.Shared;
+
+namespace Application.Common.Databases;
+
+public interface IEncyclopediaRepository
+{
+    Task<Result<EncyclopediaList>> FetchEncyclopedia(CancellationToken cancellationToken);
+}

Application/Common/Databases/IThemeRepository.cs

@@ -0,0 +1,6 @@
+namespace Application.Common.Databases;
+
+public class IThemeRepository
+{
+
+}

Application/Common/Mappers/AnnotationToDtoMapper.cs

@@ -0,0 +1,24 @@
+using Application.DTO;
+using Domain.Entities;
+
+namespace Application.Common.Mappers;
+
+public class AnnotationToDtoMapper
+{
+    public AnnotationDto Map(Annotation annotation)
+    {
+        AnnotationDto annotationDto = new AnnotationDto(
+            annotation.Id,
+            annotation.Title,
+            annotation.StartPage,
+            annotation.EndPage,
+            annotation.ContentUrl,
+            annotation.Tags,
+            annotation.Date,
+            annotation.Theme.Id,
+            annotation.Encyclopedia.Id
+        );
+
+        return annotationDto;
+    }
+}

Application/Common/Mappers/ContentTableToDtoMapper.cs

@@ -0,0 +1,25 @@
+using Application.DTO;
+using Domain.Entities;
+using Domain.Shared;
+
+namespace Application.Common.Mappers;
+
+public class ContentTableToDtoMapper
+{
+    public List<IDto> Map(ContentTable contentTable)
+    {
+        List<IDto> contentTableDto = new List<IDto>();
+
+        foreach (ContentTableEntry entry in contentTable.Entries)
+        {
+            List<NoteIdDto> notesDto = new List<NoteIdDto>();
+            foreach (Annotation note in entry.Notes)
+            {
+                notesDto.Add(new NoteIdDto(note.Id, note.Title));
+            }
+            contentTableDto.Add(new ContentTableEntryDto(entry.Id, entry.ThemeName, notesDto));
+        }
+
+        return contentTableDto;
+    }
+}

Application/Common/Mappers/EncyclopediaListAnswerListDtoMapper.cs

@@ -0,0 +1,21 @@
+using Application.DTO;
+using Domain.Entities;
+using Domain.Shared;
+
+namespace Application.Common.Mappers;
+
+public class EncyclopediaListAnswerListDtoMapper
+{
+    public AnswerListDto Map(EncyclopediaList list)
+    {
+        List<IDto> encyclopediaDtos = new List<IDto>();
+        EncyclopediaToDtoMapper mapper = new EncyclopediaToDtoMapper();
+
+        foreach (Encyclopedia encyclopedia in list.List)
+        {
+            encyclopediaDtos.Add(mapper.Map(encyclopedia));
+        }
+
+        return new AnswerListDto(true,  encyclopediaDtos, Error.Empty());
+    }
+}

Application/Common/Mappers/EncyclopediaToDtoMapper.cs

@@ -0,0 +1,19 @@
+using Application.DTO;
+using Domain.Entities;
+
+namespace Application.Common.Mappers;
+
+public class EncyclopediaToDtoMapper
+{
+    public EncyclopediaDto Map(Encyclopedia encyclopedia)
+    {
+        EncyclopediaDto encyclopediaDto = new EncyclopediaDto(
+            encyclopedia.Id,
+            encyclopedia.Title,
+            encyclopedia.Scribe.Id,
+            encyclopedia.Scribe.Name
+        );
+
+        return encyclopediaDto;
+    }
+}

Application/DTO/AnnotationDto.cs

@@ -1,13 +1,13 @@
 namespace Application.DTO;
 
 public record AnnotationDto(
-    Guid Id,
+    int Id,
     string Title,
     int StartPage,
     int LastPage,
     string ContentUrl,
     string Tags,
     DateOnly Date,
-    Guid ThemeId,
-    Guid EncyclopediaId
+    int ThemeId,
+    int EncyclopediaId
 ): IDto;

Application/DTO/AnswerDto.cs

@@ -0,0 +1,5 @@
+using Domain.Shared;
+
+namespace Application.DTO;
+
+public record AnswerDto(bool Success, IDto Value, Error error);

Application/DTO/AnswerListDto.cs

@@ -0,0 +1,5 @@
+using Domain.Shared;
+
+namespace Application.DTO;
+
+public record AnswerListDto(bool Success, List<IDto> Value, Error error);

Application/DTO/ContentTableEntryDto.cs

@@ -0,0 +1,3 @@
+namespace Application.DTO;
+
+public sealed record ContentTableEntryDto(int Id, string ThemeName, List<NoteIdDto> notes): IDto;

Application/DTO/EncyclopediaDto.cs

@@ -1,7 +1,8 @@
 namespace Application.DTO;
 
 public record EncyclopediaDto(
-    Guid Id,
+    int Id,
     string Title,
-    Guid ScribeId
+    Guid ScribeId,
+    string ScribeName
 ): IDto;

Application/DTO/IDto.cs

@@ -1,5 +1,10 @@
+using System.Text.Json.Serialization;
+
 namespace Application.DTO;
 
+[JsonDerivedType(typeof(EncyclopediaDto), typeDiscriminator: "encyclopedia")]
+[JsonDerivedType(typeof(ContentTableEntryDto), typeDiscriminator: "contentTableEntry")]
+
 public interface IDto
 {
 

Application/DTO/NoteIdDto.cs

@@ -0,0 +1,3 @@
+namespace Application.DTO;
+
+public sealed record NoteIdDto(int Id, string Title): IDto;

Application/DTO/NoteInformationsDto.cs

@@ -0,0 +1,3 @@
+namespace Application.DTO;
+
+public sealed record NoteInformationsDto(int Id, string ContentUrl, int StartPage, int EndPage, string Tags, DateOnly Date): IDto;

Application/EncyclopediaOperations/Queries/FetchEncyclopedia/FetchEncyclopediaQuery.cs

@@ -0,0 +1,6 @@
+using Application.Common.Abstractions.Messaging;
+using Domain.Entities;
+
+namespace Application.EncyclopediaOperations.Queries.FetchEncyclopedia;
+
+public sealed record FetchEncyclopediaQuery(): IQuery<EncyclopediaList>;

Application/EncyclopediaOperations/Queries/FetchEncyclopedia/FetchEncyclopediaQueryHandler.cs

@@ -0,0 +1,19 @@
+using Application.Common.Abstractions.Messaging;
+using Application.Common.Databases;
+using Domain.Entities;
+using Domain.Shared;
+using Microsoft.Extensions.Logging;
+
+namespace Application.EncyclopediaOperations.Queries.FetchEncyclopedia;
+
+public sealed class FetchEncyclopediaQueryHandler(
+    IEncyclopediaRepository repository,
+    ILogger<FetchEncyclopediaQueryHandler> logger) : IQueryHandler<FetchEncyclopediaQuery, EncyclopediaList>
+{
+    public async Task<Result<EncyclopediaList>> Handle(FetchEncyclopediaQuery request, CancellationToken cancellationToken)
+    {
+        Result<EncyclopediaList> result = await repository.FetchEncyclopedia(cancellationToken);
+
+        return new Result<EncyclopediaList>(result.Value, result.Error, result.Succeeded);
+    }
+}

Application/Services/AnnotationInformation/AnnotationInformationService.cs

@@ -0,0 +1,26 @@
+using Application.AnnotationOperations.Queries.FetchAnnotationFromId;
+using Application.Common.Mappers;
+using Application.DTO;
+using Domain.Entities;
+using Domain.Errors;
+using Domain.Shared;
+using MediatR;
+using Microsoft.Extensions.Logging;
+
+namespace Application.Services.AnnotationInformation;
+
+public class AnnotationInformationService(ISender sender, ILogger<AnnotationInformationService> logger): IAnnotationInformationService
+{
+    public async Task<AnswerDto> HandleAnnotationInformationAsync(int id, CancellationToken cancellationToken)
+    {
+        AnswerDto result;
+        AnnotationToDtoMapper mapper = new AnnotationToDtoMapper();
+        AnnotationInformationServiceErrors errors = new AnnotationInformationServiceErrors();
+
+        Result<Annotation> annotation = await sender.Send(new FetchAnnotationFromIdQuery(id), cancellationToken);
+
+        return annotation.Succeeded
+            ? new AnswerDto(true, mapper.Map(annotation.Value), Error.Empty())
+            : new AnswerDto(false, mapper.Map(Annotation.Empty()), annotation.Error);
+    }
+}

Application/Services/AnnotationInformation/IAnnotationInformationService.cs

@@ -0,0 +1,8 @@
+using Application.DTO;
+
+namespace Application.Services.AnnotationInformation;
+
+public interface IAnnotationInformationService
+{
+    Task<AnswerDto> HandleAnnotationInformationAsync(int annotationId, CancellationToken cancellationToken);
+}

Application/Services/ContentTableSearch/ContentTableService.cs

@@ -0,0 +1,62 @@
+using Application.AnnotationOperations.Queries.FetchAnnotationFromEncyclopediaId;
+using Application.Common.Mappers;
+using Application.DTO;
+using Domain.Entities;
+using Domain.Errors;
+using Domain.Shared;
+using MediatR;
+using Microsoft.Extensions.Logging;
+
+namespace Application.Services.ContentTableSearch;
+
+public class ContentTableService (ISender sender, ILogger<ContentTableService> logger): IContentTableService
+{
+    private readonly ContentTableServiceErrors _errors = new();
+    private readonly ContentTableToDtoMapper _mapper = new();
+
+    public async Task<AnswerListDto> HandleContentTableAsync(int encyclopediaId, CancellationToken cancellationToken)
+    {
+        Result<AnnotationList> annotationsList = await sender.Send(new FetchAnnotationFromEncyclopediaIdQuery(encyclopediaId), cancellationToken);
+
+        return annotationsList.Succeeded 
+            ? BuildContentTable(annotationsList.Value) 
+            : new AnswerListDto(false, new List<IDto>(), annotationsList.Error);
+    }
+
+    private AnswerListDto BuildContentTable(AnnotationList annotationsList)
+    {
+        List<ContentTableEntry> contentTableEntries = [];
+        List<Annotation> annotations = annotationsList.Annotations;
+        List<Theme> themes = annotations
+            .Select(a => a.Theme)
+            .Distinct()
+            .ToList();
+
+        foreach (Annotation annotation in annotations)
+        {
+            Theme theme = annotation.Theme;
+
+            List<Annotation> tmpNotes = annotations
+                .Where(a => a.Theme.Id == theme.Id)
+                .ToList();
+
+            Result<ContentTableEntry> tmpContentTableEntry =
+                ContentTableEntry.Create(theme.Id, theme.Name, tmpNotes);
+
+            if (tmpContentTableEntry.Failed)
+            {
+                return new AnswerListDto(false, new List<IDto>(), _errors.ContentTableEntryCreationError(tmpContentTableEntry.Error));
+            }
+
+            contentTableEntries.Add(tmpContentTableEntry.Value);
+        }
+
+        Result<ContentTable> tmpContentTable = ContentTable.Create(contentTableEntries);
+
+        AnswerListDto result = tmpContentTable.Succeeded
+            ? new AnswerListDto(true, _mapper.Map(tmpContentTable.Value), Error.Empty())
+            : new AnswerListDto(false, new List<IDto>(), _errors.ContentTableCreationError(tmpContentTable.Error));
+
+        return result;
+    }
+}

Application/Services/ContentTableSearch/IContentTableService.cs

@@ -0,0 +1,8 @@
+using Application.DTO;
+
+namespace Application.Services.ContentTableSearch;
+
+public interface IContentTableService
+{
+    Task<AnswerListDto> HandleContentTableAsync(int encyclopediaId, CancellationToken cancellationToken);
+}