🧪 Test mapper but not concluent

src/Model2Entities/ActivityRepository.cs

@@ -14,13 +14,11 @@ public partial class DbDataManager : IDataManager
     public class ActivityRepository : IActivityRepository
     {
         private readonly DbDataManager _dataManager;
-        private readonly ILogger<ActivityRepository> _logger = new Logger<ActivityRepository>(new LoggerFactory());
+        private readonly ILogger<DbDataManager> _logger;
-        
+        public ActivityRepository(DbDataManager dbDataManager, ILogger<DbDataManager> logger)
-        // logger et tests sur tout et mapper
-        public ActivityRepository(DbDataManager dataManager)
         {
-            _dataManager = dataManager;
+            this._dataManager = dbDataManager;
-            // _logger = logger;
+            this._logger = logger;
         }
 
         public async Task<IEnumerable<Activity>> GetActivities(int index, int count, ActivityOrderCriteria criteria, bool descending = false)
@@ -38,7 +36,7 @@ public partial class DbDataManager : IDataManager
         public async Task<Activity?> GetActivityByIdAsync(int id)
         {
             _logger.LogInformation($"GetActivityByIdAsync with id {id}", id);
-            // ! By None don't pass the filter
+
             var activity = _dataManager.DbContext.ActivitiesSet.GetItemsWithFilterAndOrdering(b => b.IdActivity == id, 0, 1, ActivityOrderCriteria.None, false).First().ToModel();
 
             if (activity != null)
@@ -144,12 +142,34 @@ public partial class DbDataManager : IDataManager
 
         public Task<IEnumerable<Activity>> GetActivitiesByUser(int userId, int index, int count, ActivityOrderCriteria criteria, bool descending = false)
         {
-            throw new NotImplementedException();
+            try {
+                _logger.LogInformation($"Getting activities for user with ID {userId}");
+                var activities = _dataManager.DbContext.ActivitiesSet
+                    .Include(a => a.DataSource)
+                    .GetItemsWithFilterAndOrdering(b => b.AthleteId == userId, index, count, criteria, descending).ToModels();
+                _logger.LogInformation($"Retrieved {activities.Count()} activities for user with ID {userId}");
+                return Task.FromResult(activities);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, $"Error occurred while getting activities for user with ID {userId}");
+                throw;
+            }
         }
 
         public Task<int> GetNbActivitiesByUser(int userId)
         {
-            throw new NotImplementedException();
+            try {
+                _logger.LogInformation($"Getting the total number of activities for user with ID {userId}");
+                var count = _dataManager.DbContext.ActivitiesSet.Count(b => b.AthleteId == userId);
+                _logger.LogInformation($"Total number of activities for user with ID {userId}: {count}");
+                return Task.FromResult(count);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex, $"Error occurred while getting the total number of activities for user with ID {userId}");
+                throw;
+            }
         }
     }
 }

src/Model2Entities/DbDataManager.cs

@@ -1,6 +1,7 @@
 using DbContextLib;
 using EFMappers;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
 using Model.Manager;
 using Model.Repository;
 
@@ -12,12 +13,14 @@ public partial class DbDataManager: IDataManager
     public IUserRepository UserRepo { get; }
     protected HeartTrackContext DbContext { get; }
 
+    protected readonly ILogger<DbDataManager> _logger = new Logger<DbDataManager>(new LoggerFactory());
+
    // mettre si pb lors d'une requete si rollback ou pas 
     public DbDataManager(HeartTrackContext dbContext)
     {
         DbContext = dbContext;
-        ActivityRepo = new ActivityRepository(this);
+        ActivityRepo = new ActivityRepository(this, _logger);
-        UserRepo = new UserRepository(this);
+        UserRepo = new UserRepository(this, _logger);
         ActivityMapper.Reset();
         // Faire pour les autres reset() des autres mappers
     }
@@ -29,7 +32,7 @@ public partial class DbDataManager: IDataManager
     public DbDataManager()
     {
         DbContext = new HeartTrackContext();
-        ActivityRepo = new ActivityRepository(this);
+        ActivityRepo = new ActivityRepository(this, _logger);
-        UserRepo= new UserRepository(this);
+        UserRepo= new UserRepository(this, _logger);
     }
 }

src/Model2Entities/UserRepository.cs

@@ -1,6 +1,9 @@
+using Microsoft.Extensions.Logging;
 using Model;
 using Model.Repository;
 using Shared;
+using EFMappers;
+using Entities;
 
 namespace Model2Entities;
 
@@ -9,45 +12,132 @@ public partial class DbDataManager
     public class UserRepository : IUserRepository
     {
         private readonly DbDataManager _dataManager;
+        private readonly ILogger<DbDataManager> _logger;
 
-        public UserRepository(DbDataManager dataManager)
+        public UserRepository(DbDataManager dbDataManager, ILogger<DbDataManager> logger)
         {
-            _dataManager = dataManager;
+            this._dataManager = dbDataManager;
+            this._logger = logger;
         }
 
-        public async Task<IEnumerable<User>> GetItems(int index, int count, string? orderingProperty = null, bool descending = false)
+        public async Task<IEnumerable<User>> GetItems(int index, int count, AthleteOrderCriteria? orderingProperty = null, bool descending = false)
         {
-            throw new NotImplementedException();
+            try {
+                _logger.LogInformation($"GetItems with index {index} and count {count}", index, count);
+                _logger.LogInformation($"GetItems with orderingProperty {orderingProperty} and descending {descending}", orderingProperty, descending);
+                var users = _dataManager.DbContext.AthletesSet.GetItemsWithFilterAndOrdering(b => true, index, count, orderingProperty, descending).ToModels();
+                _logger.LogInformation($"Retrieved {users.Count()} users");
+                return await Task.FromResult(users);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex.Message, ex.InnerException, ex.StackTrace);
+                return await Task.FromResult<IEnumerable<User>>(new List<User>());
+            }
         }
 
         public async Task<User?> GetItemById(int id)
         {
-            throw new NotImplementedException();
+            try {
+                _logger.LogInformation($"GetItemById with id {id}", id);
+                var user = _dataManager.DbContext.AthletesSet.GetItemsWithFilterAndOrdering(b => b.IdAthlete == id, 0, 1, AthleteOrderCriteria.None, false).First().ToModel();
+                if (user != null)
+                    _logger.LogInformation($"Retrieved user with ID {id}");
+                else
+                    _logger.LogWarning($"No user found with ID {id}");
+                return await Task.FromResult(user);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex.Message, ex.InnerException, ex.StackTrace);
+                return await Task.FromResult<User?>(null);
+            }
         }
 
         public async Task<User?> UpdateItem(int oldItem, User newItem)
         {
+            // try {
+            //     _logger.LogInformation($"UpdateItem with id {oldItem}", oldItem);
+            //     var updatedUser = (await _dataManager.DbContext.UpdateItem<AthleteEntity, User>(oldItem, newItem, (user, entity) => user.ToEntity(entity)))?.ToModel();
+            //     if (updatedUser != null)
+            //         _logger.LogInformation($"Updated user with ID {oldItem}");
+            //     else
+            //         _logger.LogWarning($"No user found with ID {oldItem}");
+            //     return await Task.FromResult(updatedUser);
+            // }
+            // catch (Exception ex)
+            // {
+            //     _logger.LogError(ex.Message, ex.InnerException, ex.StackTrace);
+            //     return await Task.FromResult<User?>(null);
+            // }
             throw new NotImplementedException();
         }
 
         public async Task<User?> AddItem(User item)
         {
-            throw new NotImplementedException();
+            try {
+                _logger.LogInformation("Adding new user");
+                var addedUser = (await _dataManager.DbContext.AddItem(item.ToEntity()))?.ToModel();
+                if (addedUser != null)
+                    _logger.LogInformation($"Added user with ID {addedUser.Id}");
+                else
+                    _logger.LogError("Failed to add user");
+                return await Task.FromResult(addedUser);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex.Message, ex.InnerException, ex.StackTrace);
+                return await Task.FromResult<User?>(null);
+            }
         }
 
         public async Task<bool> DeleteItem(int item)
         {
-            throw new NotImplementedException();
+            try {
+                _logger.LogInformation($"DeleteItem with id {item}", item);
+                var deleted = await _dataManager.DbContext.DeleteItem<AthleteEntity>(item);
+                if (deleted)
+                    _logger.LogInformation($"Deleted user with ID {item}");
+                else
+                    _logger.LogWarning($"No user found with ID {item}");
+                return await Task.FromResult(deleted);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex.Message, ex.InnerException, ex.StackTrace);
+                return await Task.FromResult(false);
+            }
         }
 
         public async Task<int> GetNbItems()
         {
-            throw new NotImplementedException();
+            try {
+                _logger.LogInformation("GetNbItems");
+                var nbItems = _dataManager.DbContext.AthletesSet.Count();
+                _logger.LogInformation($"Retrieved {nbItems} users");
+                return await Task.FromResult(nbItems);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex.Message, ex.InnerException, ex.StackTrace);
+                return await Task.FromResult(0);
+            }
         }
 
         public async Task<IEnumerable<User>> GetUsers(int index, int count, AthleteOrderCriteria? criteria, bool descending = false)
         {
-            throw new NotImplementedException();
+            try {
+                _logger.LogInformation($"GetUsers with index {index} and count {count}", index, count);
+                _logger.LogInformation($"GetUsers with criteria {criteria} and descending {descending}", criteria, descending);
+                var users = _dataManager.DbContext.AthletesSet.GetItemsWithFilterAndOrdering(a => a.IsCoach == false, index, count, criteria, descending).ToModels();
+                _logger.LogInformation($"Retrieved {users.Count()} users");
+                return await Task.FromResult(users);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex.Message, ex.InnerException, ex.StackTrace);
+                return await Task.FromResult<IEnumerable<User>>(new List<User>());
+            }
         }
 
         public async Task<bool> AddFriend(User user, User friend)
@@ -60,12 +150,54 @@ public partial class DbDataManager
             throw new NotImplementedException();
         }
 
-        public Task<IEnumerable<User>?>? GetFriends(User user, int index, int count, AthleteOrderCriteria? criteria, bool descending = false)
+        public Task<IEnumerable<User>> GetFriends(User user, int index, int count, AthleteOrderCriteria? criteria, bool descending = false)
         {
-            throw new NotImplementedException();
+            try {
+                _logger.LogInformation($"GetFriends with index {index} and count {count}", index, count);
+                _logger.LogInformation($"GetFriends with criteria {criteria} and descending {descending}", criteria, descending);
+                var friends = _dataManager.DbContext.AthletesSet.GetItemsWithFilterAndOrdering(a => a.IdAthlete == user.Id, index, count, criteria, descending).ToModels();
+                _logger.LogInformation($"Retrieved {friends.Count()} friends");
+                return Task.FromResult(friends);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex.Message, ex.InnerException, ex.StackTrace);
+                return Task.FromResult<IEnumerable<User>>(new List<User>());
+            }
         }
 
         public Task<int> GetNbFriends(User user)
+        {
+            try {
+                _logger.LogInformation($"GetNbFriends with user {user}", user);
+                var nbFriends = _dataManager.DbContext.AthletesSet.Count(a => a.IdAthlete == user.Id);
+                _logger.LogInformation($"Retrieved {nbFriends} friends");
+                return Task.FromResult(nbFriends);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex.Message, ex.InnerException, ex.StackTrace);
+                return Task.FromResult(0);
+            }
+        }
+
+        public Task<IEnumerable<User>> GetItems(int index, int count, AthleteOrderCriteria orderingProperty, bool descending = false)
+        {
+            try {
+                _logger.LogInformation($"GetItems with index {index} and count {count}", index, count);
+                _logger.LogInformation($"GetItems with orderingProperty {orderingProperty} and descending {descending}", orderingProperty, descending);
+                var users = _dataManager.DbContext.AthletesSet.GetItemsWithFilterAndOrdering(b => true, index, count, orderingProperty, descending).ToModels();
+                _logger.LogInformation($"Retrieved {users.Count()} users");
+                return Task.FromResult(users);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogError(ex.Message, ex.InnerException, ex.StackTrace);
+                return Task.FromResult<IEnumerable<User>>(new List<User>());
+            }
+        }
+
+        public Task<IEnumerable<User>> GetItems(int index, int count, string? orderingProperty = null, bool descending = false)
         {
             throw new NotImplementedException();
         }

src/StubbedContextLib/StubbedContextLib.csproj

@@ -7,6 +7,10 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.EntityFrameworkCore" Version="8.0.2" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="8.0.2">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
   </ItemGroup>
 
   <PropertyGroup>

src/Tests/ConsoleTestEFMapper/ConsoleTestEFMapper.csproj

@@ -6,6 +6,13 @@
     <ProjectReference Include="..\..\StubbedContextLib\StubbedContextLib.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Design" Version="8.0.2">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
   <PropertyGroup>
     <OutputType>Exe</OutputType>
     <TargetFramework>net8.0</TargetFramework>

src/Tests/ConsoleTestEFMapper/Program.cs

@@ -10,14 +10,21 @@ using static Model2Entities.DbDataManager;
 
 namespace Model2Entities
 {
-    class Program
+    static class Program
     {
         static async Task Main(string[] args)
         {
             // Instanciation de DbDataManager et ActivityRepository
             var dataManager = new DbDataManager(new TrainingStubbedContext());
-            var logger = new Logger<ActivityRepository>(new LoggerFactory());
+            var logger = new Logger<DbDataManager>(new LoggerFactory());
-            var activityRepository = new ActivityRepository(dataManager);
+
+            // Test de la méthode GetActivities
+            await ActivitiesTestAsync(dataManager, logger);
+            
+        }
+        static async Task ActivitiesTestAsync(DbDataManager dataManager, ILogger<DbDataManager> logger)
+        {
+            var activityRepository = new ActivityRepository(dataManager, logger);
 
             // Test de la méthode GetActivities
             Console.WriteLine("Testing GetActivities method...");
@@ -76,18 +83,18 @@ namespace Model2Entities
             }
             Console.WriteLine();
 
-            // // Test de la méthode UpdateActivity
+            // Test de la méthode UpdateActivity
-            // Console.WriteLine("Testing UpdateActivity method...");
+            Console.WriteLine("Testing UpdateActivity method...");
-            // var updatedActivity = await activityRepository.UpdateActivity(6, new Activity { Id = 6, Name = "Updated Activity" });
+            var updatedActivity = await activityRepository.UpdateActivity(6, new Activity { Id = 6, Type = "Updated Activity", Date = new DateTime(2021, 10, 11), StartTime = new DateTime(10, 10, 10, 10, 10, 10), EndTime = new DateTime(10, 10, 10, 12, 12, 12) });
-            // if (updatedActivity != null)
+            if (updatedActivity != null)
-            // {
+            {
-            //     Console.WriteLine($"Activity updated successfully: ID: {updatedActivity.Id}, Name: {updatedActivity.Name}");
+                Console.WriteLine($"Activity updated successfully: ID: {updatedActivity.Id}, Name: {updatedActivity.Type}, Date: {updatedActivity.Date}, Start Time: {updatedActivity.StartTime}, End Time: {updatedActivity.EndTime}");
-            // }
+            }
-            // else
+            else
-            // {
+            {
-            //     Console.WriteLine("Failed to update activity.");
+                Console.WriteLine("Failed to update activity.");
-            // }
+            }
-            // Console.WriteLine();
+            Console.WriteLine();
 
             // Test de la méthode DeleteActivity
             Console.WriteLine("Testing DeleteActivity method...");
@@ -105,5 +112,7 @@ namespace Model2Entities
             var itemCount = await activityRepository.GetNbItems();
             Console.WriteLine($"Total number of activities: {itemCount}");
         }
+        static void UsersTest()
+        {}
     }
 }