Refactor and Enhance Data Handling and Mapping

- Replaced database mocks with actual database implementatino.
- Introduced the AutoMap utility class to facilitate simple and efficient mapping of entities with identical properties.
-- Updated business logic, repository layers, and database provider implementations.

Author: maurogioberti

Poc.TextProcessor.Business.Logic.Abstractions/ITextLogic.cs

@@ -4,6 +4,7 @@ namespace Poc.TextProcessor.Business.Logic.Abstractions
 {
     public interface ITextLogic
     {
+        Text Get(int id);
         Text GetRandom();
         Statistics GetStatistics(string textContent);
     }

Poc.TextProcessor.Business.Logic/Poc.TextProcessor.Business.Logic.csproj

@@ -6,6 +6,10 @@
     <Nullable>enable</Nullable>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="AutoFixture" Version="4.18.1" />
+  </ItemGroup>
+
   <ItemGroup>
     <ProjectReference Include="..\Poc.TextProcessor.Business.Logic.Abstractions\Poc.TextProcessor.Business.Logic.Abstractions.csproj" />
     <ProjectReference Include="..\Poc.TextProcessor.CrossCutting.Exceptions\Poc.TextProcessor.CrossCutting.Exceptions.csproj" />

Poc.TextProcessor.Business.Logic/TextLogic.cs

@@ -1,4 +1,5 @@
-using Poc.TextProcessor.Business.Logic.Abstractions;
+using AutoFixture;
+using Poc.TextProcessor.Business.Logic.Abstractions;
 using Poc.TextProcessor.Business.Logic.Base;
 using Poc.TextProcessor.CrossCutting.Utils.Constants;
 using Poc.TextProcessor.ResourceAccess.Contracts;
@@ -11,6 +12,7 @@ public class TextLogic : TextLogicBase, ITextLogic
     {
         private readonly ITextRepository _textRepository;
         private readonly ITextMapper _textMapper;
+        private readonly Fixture _fixture = new();
 
         public TextLogic(ITextRepository textRepository,
             ITextMapper textMapper)
@@ -19,13 +21,23 @@ public TextLogic(ITextRepository textRepository,
             _textMapper = textMapper;
         }
 
+        public Text Get(int id)
+        {
+            var textDomain = _textRepository.Get(id);
+            return _textMapper.Map(textDomain);
+        }
+
         public Text GetRandom()
         {
-            var random = new Random();
-            var randomInteger = random.Next(0, 100);
-            var textDomain = _textRepository.Get(randomInteger);
+            Random random = new Random();
+            var randomLength = random.Next(5, 120);
+            var longString = string.Join(TextConstants.Space, _fixture.CreateMany<string>(randomLength));
 
-            return _textMapper.Map(textDomain);
+            return _fixture
+                    .Build<Text>()
+                    .With(x => x.Id)
+                    .With(x => x.Content, longString)
+                    .Create();
         }
 
         public Statistics GetStatistics(string textContent)

Poc.TextProcessor.CrossCutting.Utils/AutoMap.cs

@@ -0,0 +1,53 @@
+using AutoMapper;
+
+namespace Poc.TextProcessor.CrossCutting.Utils
+{
+    /// <summary>
+    /// The AutoMap class provides methods for mapping objects of one type to objects of another type.
+    /// It uses AutoMapper under the hood to handle the actual mapping process. This class abstracts
+    /// away the complexities of configuring AutoMapper and provides a simple, straightforward interface
+    /// for object-to-object mapping. It supports both individual objects and collections of objects.
+    /// </summary>
+    public static class AutoMap
+    {
+        /// <summary>
+        /// Generates a simple mapping from a source to a destination.
+        /// </summary>
+        /// <typeparam name="TSource">Origin source class</typeparam>
+        /// <typeparam name="TDestination">Destination class</typeparam>
+        /// <param name="source"></param>
+        /// <returns></returns>
+        public static TDestination Map<TSource, TDestination>(TSource source)
+        {
+            var mapper = CreateMapper<TSource, TDestination>();
+            return mapper.Map<TSource, TDestination>(source);
+        }
+
+        /// <summary>
+        /// Generates a simple mapping from a source collection to a destination collection.
+        /// </summary>
+        /// <typeparam name="TSource">Origin source class</typeparam>
+        /// <typeparam name="TDestination">Destination class</typeparam>
+        /// <param name="source"></param>
+        /// <returns></returns>
+        public static IEnumerable<TDestination> Map<TSource, TDestination>(IEnumerable<TSource> source)
+        {
+            if (source == null || !source.Any())
+                return new List<TDestination>();
+
+            var mapper = CreateMapper<TSource, TDestination>();
+            var destinations = source.Select(x => mapper.Map<TSource, TDestination>(x));
+            return destinations;
+        }
+
+        private static IMapper CreateMapper<TSource, TDestination>()
+        {
+            var configuration = SetupConfiguration<TSource, TDestination>();
+            var mapper = configuration.CreateMapper();
+            return mapper;
+        }
+
+        private static MapperConfiguration SetupConfiguration<TSource, TDestination>()
+            => new(cfg => cfg.CreateMap<TSource, TDestination>());
+    }
+}

Poc.TextProcessor.CrossCutting.Utils/Poc.TextProcessor.CrossCutting.Utils.csproj

@@ -6,4 +6,8 @@
     <Nullable>enable</Nullable>
   </PropertyGroup>
 
+  <ItemGroup>
+    <PackageReference Include="AutoMapper" Version="12.0.1" />
+  </ItemGroup>
+
 </Project>

Poc.TextProcessor.ResourceAccess.Database/Abstractions/IDatabaseProvider.cs

@@ -1,9 +1,18 @@
-namespace Poc.TextProcessor.ResourceAccess.Database.Abstractions
+using System.Linq.Expressions;
+
+namespace Poc.TextProcessor.ResourceAccess.Database.Abstractions
 {
     public interface IDatabaseProvider
     {
+        IEnumerable<T> Query<T>(string sql, object parameters = null) where T : class;
         Task<IEnumerable<T>> QueryAsync<T>(string sql, object parameters = null) where T : class;
+        int Execute(string sql, object parameters = null);
         Task<int> ExecuteAsync(string sql, object parameters = null);
+        IEnumerable<T> Get<T>(Expression<Func<T, bool>> predicate) where T : class;
+        IEnumerable<T> Get<T>() where T : class;
+        Task<IEnumerable<T>> GetAsync<T>(Expression<Func<T, bool>> predicate) where T : class;
+        Task<IEnumerable<T>> GetAsync<T>() where T : class;
+        T Save<T>(T entity) where T : class;
         Task<T> SaveAsync<T>(T entity) where T : class;
     }
 }

Poc.TextProcessor.ResourceAccess.Database/Providers/EntityFramework/EntityFrameworkDatabaseProvider.cs

@@ -1,5 +1,6 @@
 using Microsoft.EntityFrameworkCore;
 using Poc.TextProcessor.ResourceAccess.Database.Abstractions;
+using System.Linq.Expressions;
 
 namespace Poc.TextProcessor.ResourceAccess.Database.Providers.EntityFramework
 {
@@ -12,39 +13,82 @@ public EntityFrameworkDatabaseProvider(PocContext context)
             _context = context;
         }
 
-        public async Task<IEnumerable<T>> QueryAsync<T>(string sql, object parameters = null)
-            where T : class
+        public IEnumerable<T> Query<T>(string sql, object parameters = null) where T : class
+        {
+            return _context.Set<T>().FromSqlRaw(sql, parameters).ToList();
+        }
+
+        public async Task<IEnumerable<T>> QueryAsync<T>(string sql, object parameters = null) where T : class
         {
             return await _context.Set<T>().FromSqlRaw(sql, parameters).ToListAsync();
         }
 
+        public int Execute(string sql, object parameters = null)
+        {
+            return _context.Database.ExecuteSqlRaw(sql, parameters);
+        }
+
         public async Task<int> ExecuteAsync(string sql, object parameters = null)
         {
-            var result = await _context.Database.ExecuteSqlRawAsync(sql, parameters);
-            return result;
+            return await _context.Database.ExecuteSqlRawAsync(sql, parameters);
+        }
+
+        public IEnumerable<T> Get<T>(Expression<Func<T, bool>> predicate) where T : class
+        {
+            return _context.Set<T>().Where(predicate);
+        }
+
+        public IEnumerable<T> Get<T>() where T : class
+        {
+            return _context.Set<T>();
+        }
+
+        public async Task<IEnumerable<T>> GetAsync<T>() where T : class
+        {
+            return await _context.Set<T>().ToListAsync();
+        }
+
+        public async Task<IEnumerable<T>> GetAsync<T>(Expression<Func<T, bool>> predicate) where T : class
+        {
+            return await _context.Set<T>().Where(predicate).ToListAsync();
+        }
+
+        public T Save<T>(T entity) where T : class
+        {
+            AddOrUpdate(entity);
+            _context.SaveChanges();
+            return entity;
         }
 
         public async Task<T> SaveAsync<T>(T entity) where T : class
         {
-            var dbSet = _context.Set<T>();
-            var entry = _context.Entry(entity);
+            await AddOrUpdateAsync(entity);
+            await _context.SaveChangesAsync();
+            return entity;
+        }
 
+        private void AddOrUpdate<T>(T entity) where T : class
+        {
+            var entry = _context.Entry(entity);
             if (entry.State == EntityState.Detached)
             {
-                dbSet.Attach(entity);
+                _context.Set<T>().Attach(entity);
             }
+            entry.State = entry.IsKeySet ? EntityState.Modified : EntityState.Added;
+        }
 
-            if (entry.IsKeySet)
+        private async Task AddOrUpdateAsync<T>(T entity) where T : class
+        {
+            var entry = _context.Entry(entity);
+            if (entry.State == EntityState.Detached)
             {
-                entry.State = EntityState.Modified;
+                _context.Set<T>().Attach(entity);
             }
-            else
+            entry.State = entry.IsKeySet ? EntityState.Modified : EntityState.Added;
+            if (entry.State == EntityState.Added)
             {
-                await dbSet.AddAsync(entity);
+                await _context.Set<T>().AddAsync(entity);
             }
-
-            await _context.SaveChangesAsync();
-            return entity;
         }
     }
-}
+}

Poc.TextProcessor.ResourceAccess.Repositories/Base/RepositoryBase.cs

@@ -0,0 +1,14 @@
+using Poc.TextProcessor.ResourceAccess.Database.Abstractions;
+
+namespace Poc.TextProcessor.ResourceAccess.Repositories.Base
+{
+    public class RepositoryBase
+    {
+        protected readonly IDatabaseProvider _databaseProvider;
+
+        public RepositoryBase(IDatabaseProvider databaseProvider)
+        {
+            _databaseProvider = databaseProvider;
+        }
+    }
+}

Poc.TextProcessor.ResourceAccess.Repositories/Poc.TextProcessor.ResourceAccess.Repositories.csproj

@@ -6,12 +6,9 @@
     <Nullable>enable</Nullable>
   </PropertyGroup>
 
-  <ItemGroup>
-    <PackageReference Include="AutoFixture" Version="4.18.1" />
-  </ItemGroup>
-
   <ItemGroup>
     <ProjectReference Include="..\Poc.TextProcessor.CrossCutting.Utils\Poc.TextProcessor.CrossCutting.Utils.csproj" />
+    <ProjectReference Include="..\Poc.TextProcessor.ResourceAccess.Database\Poc.TextProcessor.ResourceAccess.Database.csproj" />
     <ProjectReference Include="..\Poc.TextProcessor.ResourceAccess.Repositories.Abstractions\Poc.TextProcessor.ResourceAccess.Repositories.Abstractions.csproj" />
   </ItemGroup>
 

Poc.TextProcessor.ResourceAccess.Repositories/TextRepository.cs

@@ -1,32 +1,22 @@
-using AutoFixture;
-using Poc.TextProcessor.CrossCutting.Utils.Constants;
+using Poc.TextProcessor.CrossCutting.Utils;
+using Poc.TextProcessor.ResourceAccess.Database.Abstractions;
+using Poc.TextProcessor.ResourceAccess.Domains;
+using Poc.TextProcessor.ResourceAccess.Entities;
 using Poc.TextProcessor.ResourceAccess.Repositories.Abstractions;
+using Poc.TextProcessor.ResourceAccess.Repositories.Base;
 
 namespace Poc.TextProcessor.ResourceAccess.Repositories
 {
-    public class TextRepository : ITextRepository
+    public class TextRepository : RepositoryBase, ITextRepository
     {
-        // TODO: This class currently uses AutoFixture for mock data generation as a placeholder.
-        // The actual database implementation is pending. Implement TextProcessorContext for database operations.
-        // This mock setup is representative for the purposes of this exercise.
-
-        private readonly Fixture _fixture = new Fixture();
-
-        public Domains.Text Get(int id)
+        public TextRepository(IDatabaseProvider databaseProvider) : base(databaseProvider)
         {
-            // Generating random text to test the application functionality.
-            // A random number is created to represent the length of the text, ranging from 5 to 120 words.
-            // AutoFixture is then used to generate that number of random strings (words),
-            // and they are joined using a space as a separator to form a long string simulating a text.
-            Random random = new Random();
-            var randomLength = random.Next(5, 120);
-            var longString = string.Join(TextConstants.Space, _fixture.CreateMany<string>(randomLength));
+        }
 
-            return _fixture
-                    .Build<Domains.Text>()
-                    .With(x => x.Id, id)
-                    .With(x => x.Content, longString)
-                    .Create();
+        public Text Get(int id)
+        {
+            var text = _databaseProvider.Get<TextEntity>(x => x.Id == id).Single();
+            return AutoMap.Map<TextEntity, Text>(text);
         }
     }
 }

Poc.TextProcessor.ResourceAccess.Repositories/TextSortRepository.cs

@@ -1,26 +1,22 @@
-using Poc.TextProcessor.CrossCutting.Enums;
+using Poc.TextProcessor.CrossCutting.Utils;
+using Poc.TextProcessor.ResourceAccess.Database.Abstractions;
 using Poc.TextProcessor.ResourceAccess.Domains;
+using Poc.TextProcessor.ResourceAccess.Entities;
 using Poc.TextProcessor.ResourceAccess.Repositories.Abstractions;
+using Poc.TextProcessor.ResourceAccess.Repositories.Base;
 
 namespace Poc.TextProcessor.ResourceAccess.Repositories
 {
-    public class TextSortRepository : ITextSortRepository
+    public class TextSortRepository : RepositoryBase, ITextSortRepository
     {
-        // TODO: Currently, this method generates a list of sort options directly from the SortOption enum.
-        // This approach serves as a representative example for the technical exercise.
-        // In a real-world scenario, this data might come from a database or a configuration file.
+        public TextSortRepository(IDatabaseProvider databaseProvider) : base(databaseProvider)
+        {
+        }
 
         public IEnumerable<TextSort> List()
         {
-            return Enum
-                    .GetValues(typeof(SortOption))
-                    .Cast<SortOption>()
-                    .Select((option, index) => new TextSort
-                    {
-                        Id = index,
-                        Option = option
-                    })
-                    .ToList();
+            var textSorts = _databaseProvider.Get<TextSortEntity>().ToList();
+            return AutoMap.Map<TextSortEntity, TextSort>(textSorts);
         }
     }
 }