Merge branch 'merging_EF-API' into WORK-APE

src/EFMappers/ActivityMapper.cs

@@ -7,15 +7,6 @@ namespace EFMappers;
 public static class ActivityMapper
 {
     private static GenericMapper<Activity, ActivityEntity> _mapper = new GenericMapper<Activity, ActivityEntity>();
-    public static Activity? GetModel(ActivityEntity entity) =>
-        _mapper.GetT(entity);
-    public static ActivityEntity? GetEntity(Activity model) =>
-        _mapper.GetU(model);
-    public static void Add(Activity model, ActivityEntity entity) 
-    {
-        var tuple = new Tuple<Activity, ActivityEntity>(model, entity);
-        _mapper.Add(model, entity);
-    }
     // ! RESET
     // ? Quand on fait appel au reset ?
     // * Apres des saves changing ou rollback.

src/Model2Entities/ActivityRepository.cs

@@ -53,7 +53,7 @@ public partial class DbDataManager : IDataManager
             try
             {
                 _logger.LogInformation("Adding new activity");
-                var addedActivity =  (await _dataManager.DbContext.AddItem(activity.ToEntity())).ToModel();
+                var addedActivity =  (await _dataManager.DbContext.AddItem(activity.ToEntity()))!.ToModel();
                 if (addedActivity != null)
                     _logger.LogInformation($"Added activity with ID {addedActivity.Id}");
                 else
@@ -71,14 +71,29 @@ public partial class DbDataManager : IDataManager
         {
             try
             {
-                return activity;
-                // _logger.LogInformation($"Updating activity with ID {id}");
-                // var updatedActivity = await _dataManager.DbContext.ActivitiesSet.UpdateItem<ActivityEntity>(_dataManager.DbContext,(await GetActivityByIdAsync(id)).ToEntity(), activity.ToEntity());
-                // if (updatedActivity != null)
-                //     _logger.LogInformation($"Updated activity with ID {id}");
-                // else
-                //     _logger.LogError($"Failed to update activity with ID {id}");
-                // return await Task.FromResult(updatedActivity.ToModel());
+                // return activity;
+                _logger.LogInformation($"Updating activity with ID {id}");
+                var updatedActivity = await _dataManager.DbContext.UpdateItem<Activity, ActivityEntity>(id, activity, (activity, entity) => 
+                            {
+                                entity.Type = activity.Type;
+                                entity.Date = DateOnly.FromDateTime(activity.Date);
+                                entity.StartTime = TimeOnly.FromDateTime(activity.StartTime);
+                                entity.EndTime = TimeOnly.FromDateTime(activity.EndTime);
+                                entity.EffortFelt = activity.Effort;
+                                entity.Variability = activity.Variability;
+                                entity.Variance = activity.Variance;
+                                entity.StandardDeviation = activity.StandardDeviation;
+                                entity.Average = activity.Average;
+                                entity.Maximum = activity.Maximum;
+                                entity.Minimum = activity.Minimum;
+                                entity.AverageTemperature = activity.AverageTemperature;
+                                entity.HasAutoPause = activity.HasAutoPause;
+                            });
+                if (updatedActivity != null)
+                    _logger.LogInformation($"Updated activity with ID {id}");
+                else
+                    _logger.LogError($"Failed to update activity with ID {id}");
+                return await Task.FromResult(updatedActivity!.ToModel());
             }
             catch (Exception ex)
             {

src/Model2Entities/Extension.cs

@@ -28,21 +28,52 @@ public static class Extensions
         return await Task.FromResult(true);
     }
     
-    internal static async Task<T?> UpdateItem<T>(this IList<T> collection, T? oldItem, T? newItem) where T : class
-    {
-        // if(oldItem == null || newItem == null) return default(T);
-
-        // if(!collection.Contains(oldItem))
+    // ! 1
+    // internal static async Task<T?> UpdateItem<T>(this HeartTrackContext context, int? id, T? newItem) where T : class
     // {
-        //     return default(T);
+    //             var existingT = await context.Set<T>().FindAsync(id);
+    //             if (existingT != null)
+    //             {
+    //                 context.Entry(existingT).CurrentValues.SetValues(newItem!);
+    //                 context.Update(existingT);
+    //                 // existingT = func(newItem!);
+    //                 await context.SaveChangesAsync();
+    //             }
+
+    //             return existingT;
+    //     // if(oldItem == null || newItem == null) return default(T);
+
+    //     // if(!collection.Contains(oldItem))
+    //     // {
+    //     //     return default(T);
+    //     // }
+
+    //     // collection.Remove(oldItem!);
+    //     // await collection.AddItem(newItem!);
+    //     // return newItem;
+    //     // return await Task.FromResult<T?>(default(T));
     // }
 
-        // collection.Remove(oldItem!);
-        // await collection.AddItem(newItem!);
-        // return newItem;
-        return await Task.FromResult<T?>(default(T));
+    // ! 2
+    public static async Task<U?> UpdateItem<T, U>(this HeartTrackContext context, int? id, T? newItem, Action<T, U> updateAction) where T : class where U: class
+    {
+        var existingT = await context.Set<U>().FindAsync(id);
+        if (existingT != null && newItem != null)
+        {
+            // Appliquer les mises à jour sur l'objet existant en utilisant l'action passée en paramètre
+            updateAction(newItem, existingT);
+
+            // Marquer l'objet comme modifié dans le contexte
+            context.Update(existingT);
+
+            // Enregistrer les modifications dans la base de données
+            await context.SaveChangesAsync();
         }
 
+        return existingT;
+    }
+
+    
     public static IEnumerable<T> GetItemsWithFilterAndOrdering<T>(this IEnumerable<T> list, Func<T, bool> filter, int index, int count, Enum? orderCriterium, bool descending = false ) where T : class
     {
         var filteredList = list.Where(filter);