🐛 Test new mappers

src/APIMappers/ActivityMapper.cs

@@ -26,7 +26,7 @@ public static class ActivityMapper
             Minimum = activity.Minimum,
             AverageTemperature = activity.AverageTemperature,
             HasAutoPause = activity.HasAutoPause
-        });
+        }, (activityDto, activity) => activityDto.heartRates = activity.);
     }
     
     public static Activity ToModel(this ActivityDto activityDto)

src/APIMappers/UserMappeur.cs

@@ -24,7 +24,8 @@ public static class UserMappeur
             Weight = user.Weight,
             DateOfBirth = user.DateOfBirth,
             IsCoach = user.Role is Coach
-        });
+        },
+        (userDto, user) => userDto.Id = user.Id);
      
     }
     
@@ -45,7 +46,8 @@ public static class UserMappeur
             DateOfBirth = userDto.DateOfBirth,
             Role = userDto.IsCoach ? new Coach() : new Athlete()
 
-        });
+        },
+        (user, userDto) => user.Id = userDto.Id);
     }
 
 }

src/DbContextLib/HeartTrackContext.cs

@@ -211,8 +211,7 @@ namespace DbContextLib
             modelBuilder.Entity<ActivityEntity>()
                 .HasMany(a => a.HeartRates)
                 .WithOne(h => h.Activity)
-                .HasForeignKey(h => h.ActivityId)
+                .HasForeignKey(h => h.ActivityId);
-                .IsRequired();
 
             modelBuilder.Entity<DataSourceEntity>()
                 .HasMany(d => d.Activities)
@@ -221,10 +220,10 @@ namespace DbContextLib
                 .IsRequired();
             
             modelBuilder.Entity<DataSourceEntity>()
-                .HasMany(ds => ds.Activities)
+                .HasMany(ds => ds.Athletes)
                 .WithOne(at => at.DataSource)
                 .HasForeignKey(at => at.DataSourceId)
-                .IsRequired(false);
+                .IsRequired();
 
             // modelBuilder.Entity<AthleteEntity>()
             //         .HasMany(fer => fer.Followers)

src/EFMappers/ActivityMapper.cs

@@ -31,9 +31,9 @@ public static class ActivityMapper
             entity.Maximum,
             entity.Minimum,
             entity.AverageTemperature,
-            entity.HasAutoPause));
+            entity.HasAutoPause)
             // ! regarder a ce que le model est bien les relation comme l'EF
-        // ), (activity, entity) => activity.Id = entity.IdActivity);
+        , (activity, entity) => activity.heartRates = entity.HeartRates.Select(hr => hr.ToModel()).ToList());
 
     }
     // dictionnaire;
@@ -41,8 +41,8 @@ public static class ActivityMapper
 
     public static ActivityEntity? ToEntity(this Activity model)
     {
-        // return model.ToEntity();
+
-        return model.ToU(_mapper, activityEntity => new ActivityEntity
+        Func<Activity,ActivityEntity> create = activity => new ActivityEntity
         {
             IdActivity = model.Id,
             Type = model.Type,
@@ -58,14 +58,51 @@ public static class ActivityMapper
             Minimum = model.Minimum,
             AverageTemperature = model.AverageTemperature,
             HasAutoPause = model.HasAutoPause
-        }
+        };
+
+        Action<Activity,ActivityEntity> link = (activity, entity) =>
+ {
+entity.HeartRates = 
+// Juste faire un mappeur pour les heartRate et du coup du fait cette appel 
+// activity.heartRates.Select(hr => hr.ToEntity()).ToList(); 
+activity.heartRates.Select(hr => new HeartRateEntity
+            {
+                
+                IdHeartRate = hr.Id,
+                Altitude = hr.Altitude,
+                Time = hr.Time,
+                Temperature = hr.Temperature,
+                Bpm = hr.Bpm,
+                Longitude = hr.Longitude,
+                Latitude = hr.Latitude,
+                ActivityId = entity.IdActivity
+            }).ToList<HeartRateEntity>();
+            entity.DataSource = activity.DataSource 
+            // entity.DataSource = activity.DataSource.ToEntity();
+            // entity.Athlete = activity.Athlete.ToEntity();
+ };       
+        
+
+        // return model.ToEntity();
+        return model.ToU(_mapper, create,  );
             // ! regarder a ce que le model est bien les relation comme l'EF
-        );
+
+        /*(activity, entity) => entity.HeartRates = activity.heartRates.Select(hr => new HeartRateEntity
+            {
+                IdHeartRate = hr.Id,
+                Altitude = hr.Altitude,
+                Time = hr.Time,
+                Temperature = hr.Temperature,
+                Bpm = hr.Bpm,
+                Longitude = hr.Longitude,
+                Latitude = hr.Latitude,
+                ActivityId = entity.IdActivity
+            }).ToList<HeartRateEntity>()*/
     }
 
-    public static IEnumerable<Activity> ToModels(this IEnumerable<ActivityEntity> entities)
+    public static IEnumerable<Activity?> ToModels(this IEnumerable<ActivityEntity> entities)
         => entities.Select(a => a.ToModel());
 
-    public static IEnumerable<ActivityEntity> ToEntities(this IEnumerable<Activity> models)
+    public static IEnumerable<ActivityEntity?> ToEntities(this IEnumerable<Activity> models)
         => models.Select(a => a.ToEntity());
 }

src/EFMappers/HeartRateMapper.cs

@@ -0,0 +1,61 @@
+using Entities;
+using Model;
+using Shared;
+
+namespace EFMappers;
+
+public static class HeartRateMapper
+{
+    private static GenericMapper<HeartRate, HeartRateEntity> _mapper = new GenericMapper<HeartRate, HeartRateEntity>();
+    // ! RESET
+    // ? Quand on fait appel au reset ?
+    // * Apres des saves changing ou rollback.
+    public static void Reset()
+    {
+        _mapper.Reset();
+    }
+    public static HeartRate ToModel(this HeartRateEntity entity)
+    {
+        // return entity.ToModel();
+        return entity.ToT(_mapper, heartRate => new HeartRate (
+            entity.IdHeartRate,
+            entity.Altitude,
+            entity.Time,
+            entity.Temperature,
+            entity.Bpm,
+            entity.Longitude,
+            entity.Latitude,
+            entity.ActivityId
+        )
+            // ! regarder a ce que le model est bien les relation comme l'EF
+        , (heartRate, entity) => heartRate.ActivityId = entity.ActivityId);
+
+    }
+    // dictionnaire;
+
+
+    public static HeartRateEntity? ToEntity(this HeartRate model)
+    {
+        // return model.ToEntity();
+        return model.ToU(_mapper, heartRateEntity => new HeartRateEntity
+        {
+            IdHeartRate = model.Id,
+            Altitude = model.Altitude,
+            Time = model.Time,
+            Temperature = model.Temperature,
+            Bpm = model.Bpm,
+            Longitude = model.Longitude,
+            Latitude = model.Latitude,
+            ActivityId = model.ActivityId
+        }
+        , (heartRate, entity) => entity.ActivityId = heartRate.ActivityId
+            // ! regarder a ce que le model est bien les relation comme l'EF
+        );
+    }
+
+    public static IEnumerable<HeartRate?> ToModels(this IEnumerable<HeartRateEntity> entities)
+        => entities.Select(hr => hr.ToModel());
+
+    public static IEnumerable<HeartRateEntity?> ToEntities(this IEnumerable<HeartRate> models)
+        => models.Select(hr => hr.ToEntity());
+}

src/Model/Activity.cs

@@ -32,7 +32,34 @@ public class Activity
         public float AverageTemperature { get; set; }
         public bool HasAutoPause { get; set; }
         
-        public HashSet<User> Users { get; private set; } = new HashSet<User>();
+        // ! pk ??! pas dans le model
+        // public HashSet<User> Users { get; private set; } = new HashSet<User>();
+        public List<HeartRate> heartRates { get; set; } = new List<HeartRate>();
+        public User User { get; set; }
+        public DataSource DataSource { get; set; }
+        
+        public Activity(int idActivity ,string? type, DateTime date, DateTime startTime, DateTime endTime,
+                        int effort, float variability, float variance, float standardDeviation,
+                        float average, int maximum, int minimum, float averageTemperature, bool hasAutoPause, List<HeartRate> heartRates, User user, DataSource dataSource)
+        {
+            Id = idActivity;
+            Type = type;
+            Date = date;
+            StartTime = startTime;
+            EndTime = endTime;
+            Effort = effort;
+            Variability = variability;
+            Variance = variance;
+            StandardDeviation = standardDeviation;
+            Average = average;
+            Maximum = maximum;
+            Minimum = minimum;
+            AverageTemperature = averageTemperature;
+            HasAutoPause = hasAutoPause;
+            this.heartRates = heartRates;
+            User = user;
+            DataSource = dataSource;
+        }
         public Activity(int idActivity ,string? type, DateTime date, DateTime startTime, DateTime endTime,
                         int effort, float variability, float variance, float standardDeviation,
                         float average, int maximum, int minimum, float averageTemperature, bool hasAutoPause)
@@ -51,6 +78,7 @@ public class Activity
             Minimum = minimum;
             AverageTemperature = averageTemperature;
             HasAutoPause = hasAutoPause;
+            this.heartRates = heartRates;
         }
         public Activity(){}
         

src/Model/DataSource.cs

@@ -0,0 +1,34 @@
+using Model;
+
+public class DataSource
+{
+    public int Id { get; set; }
+    public string Type { get; set; }
+    public string Model { get; set; }
+    public float Precision { get; set; }
+    public ICollection<Activity> Activities { get; set; } = new List<Activity>();
+    public ICollection<Athlete> Athletes { get; set; } = new List<Athlete>();
+    public DataSource(int id, string type, string model, float precision, ICollection<Activity> activities, ICollection<Athlete> athletes)
+    {
+        Id = id;
+        Type = type;
+        Model = model;
+        Precision = precision;
+        Activities = activities;
+        Athletes = athletes;
+    }
+    public DataSource(){}
+
+    public DataSource(int id, string type, string model, float precision)
+    {
+        Id = id;
+        Type = type;
+        Model = model;
+        Precision = precision;
+    }
+
+    public override string ToString()
+    {
+        return $"DataSource #{Id}: {Type} {Model} with a precision of {Precision}";
+    }
+}

src/Model/HeartRate.cs

@@ -0,0 +1,30 @@
+namespace Model;
+
+public class HeartRate {
+    public int Id { get; set; }
+    public double Altitude { get; set; }
+    public TimeOnly Time { get; set; }
+    public float Temperature { get; set; }
+    public int Bpm { get; set; }
+    public float Longitude { get; set; }
+    public float Latitude { get; set; }
+    public int ActivityId { get; set; }
+    public HeartRate(int id, double altitude, TimeOnly time, float temperature, int bpm, float longitude, float latitude, int activityId)
+    {
+        Id = id;
+        Altitude = altitude;
+        Time = time;
+        Temperature = temperature;
+        Bpm = bpm;
+        Longitude = longitude;
+        Latitude = latitude;
+        ActivityId = activityId;
+    }
+    public HeartRate(){}
+
+    public override string ToString()
+    {
+        return $"HeartRate #{Id}: {Bpm} bpm at {Time:HH:mm:ss} with a temperature of {Temperature}°C" +
+               $" and an altitude of {Altitude}m at {Longitude}°E and {Latitude}°N";
+    }
+}

src/Model/User.cs

@@ -17,6 +17,8 @@ public class User
     
     protected List<Notification> Notifications { get; set; } = new List<Notification>();
 
+    protected List<Activity> Activities { get; set; } = new List<Activity>();
+    
     public List<User> Users { get; set; } = new List<User>();
     
     public User( string username, string profilePicture, string nom, string prenom, string email, string motDePasse, string sexe, float taille, float poids, DateTime dateNaissance, Role role)

src/Model2Entities/Extension.cs

@@ -7,24 +7,71 @@ namespace Model2Entities;
 
 public static class Extensions
 {
-    internal static async Task<T?> AddItem<T>(this HeartTrackContext context, T? item) where T :class
+    // internal static async Task<T?> AddItem<T>(this HeartTrackContext context, T? item) where T :class
+    // {
+    //     if(item == null || context.Set<T>().Contains(item))
+    //     {
+    //         return await Task.FromResult<T?>(null);
+    //     }
+    //     var entry = context.Set<T>().Add(item);
+    //     try {
+    //         await context.SaveChangesAsync();
+    //     } 
+    //     catch (Exception ex)
+    //     {
+    //         Console.WriteLine($"{ex.Message}, {ex.InnerException}, {ex.StackTrace}");
+    //     }
+
+    //     return await Task.FromResult<T?>(entry.Entity);
+    // }
+
+    internal static async Task<T?> AddItem<T>(this HeartTrackContext context, T? item) where T : class
     {
         if(item == null || context.Set<T>().Contains(item))
         {
             return await Task.FromResult<T?>(null);
         }
         var entry = context.Set<T>().Add(item);
+        // Si l'élément est une activité, nous devons gérer les fréquences cardiaques associées
+        if (item is Activity activity)
+        {
+            foreach (var heartRate in activity.heartRates)
+            {
+                // Ajouter chaque fréquence cardiaque associée à l'activité
+                context.Set<HeartRate>().Add(heartRate);
+            }
+        }
+
         try {
             await context.SaveChangesAsync();
         } 
         catch (Exception ex)
         {
-            Console.WriteLine(ex.Message, ex.InnerException, ex.StackTrace);
+            Console.WriteLine($"{ex.Message}, {ex.InnerException}, {ex.StackTrace}");
         }
 
         return await Task.FromResult<T?>(entry.Entity);
     }
 
+
+    // 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;
+    //     }
+    //     return default(U);
+    // }
+
     internal static async Task<bool> DeleteItem<T>(this HeartTrackContext context, int? id) where T:class
     {
         var item = await context.Set<T>().FindAsync(id);

src/Shared/Extension.cs

@@ -2,7 +2,7 @@ namespace Shared;
 
 public static class Extensions
 {
-    public static U ToU<T, U>(this T t, GenericMapper<T, U> mapper, Func<T, U> func) where U :class where  T :class
+    public static U ToU<T, U>(this T t, GenericMapper<T, U> mapper, Func<T, U> func, Action<T, U> action) where U :class where  T :class
     {
         var u = mapper.GetU(t);
         if (u != null) {
@@ -10,11 +10,11 @@ public static class Extensions
         }
         u = func(t);
         mapper.Add(t, u);
-        // action(t, u);
+        action(t, u);
         return u;
     }
 // , Action<T, U> action
-    public static T ToT<T,U>(this U u, GenericMapper<T, U> mapper, Func<U, T> func) where U :class where  T :class
+    public static T ToT<T,U>(this U u, GenericMapper<T, U> mapper, Func<U, T> func, Action<T, U> action) where U :class where  T :class
     {
         var t = mapper.GetT(u);
         if (t != null) {
@@ -22,7 +22,7 @@ public static class Extensions
         }
         t = func(u);
         mapper.Add(t, u);
-        // action(t, u);
+        action(t, u);
         return t;
     }
 }

src/Tests/ConsoleTestEFMapper/Program.cs

@@ -41,23 +41,23 @@ namespace Model2Entities
             }
             Console.WriteLine();
 
-            // // Test de la méthode AddActivity
+            // Test de la méthode AddActivity
-            // Console.WriteLine("Testing AddActivity method...");
+            Console.WriteLine("Testing AddActivity method...");
-            // var newActivity = new Activity(10, "New Activity", new DateTime(2021, 10, 10), new DateTime(10, 10, 10, 10, 10, 10), new DateTime(10, 10, 10, 12, 12, 12), 5, 5, 5, 5, 5, 5, 5, 5, false);
+            var newActivity = new Activity(10, "New Activity", new DateTime(2021, 10, 10), new DateTime(10, 10, 10, 10, 10, 10), new DateTime(10, 10, 10, 12, 12, 12), 5, 5, 5, 5, 5, 5, 5, 5, false, new List<HeartRate>(new HeartRate[] { new HeartRate(10, 10D, new TimeOnly(10, 10, 10), 10f, 10, 10f, 10f, 10) }));
-            // var addedActivity = await activityRepository.AddActivity(newActivity);
+            var addedActivity = await activityRepository.AddActivity(newActivity);
-            // if (addedActivity != null)
+            if (addedActivity != null)
-            // {
+            {
-            //     Console.WriteLine($"New activity added successfully: ID: {addedActivity.Id}, Name: {addedActivity.Type}, Date: {addedActivity.Date}, Start Time: {addedActivity.StartTime}, End Time: {addedActivity.EndTime}");
+                Console.WriteLine($"New activity added successfully: ID: {addedActivity.Id}, Name: {addedActivity.Type}, Date: {addedActivity.Date}, Start Time: {addedActivity.StartTime}, End Time: {addedActivity.EndTime}");
-            // }
+            }
-            // else
+            else
-            // {
+            {
-            //     Console.WriteLine("Failed to add new activity.");
+                Console.WriteLine("Failed to add new activity.");
-            // }
+            }
-            // Console.WriteLine();
+            Console.WriteLine();
 
             // Test de la méthode UpdateActivity
             Console.WriteLine("Testing UpdateActivity method...");
-            var updatedActivity = await activityRepository.UpdateActivity(10, new Activity(10, "Updated Activity", new DateTime(2021, 10, 10), new DateTime(10, 10, 10, 10, 10, 10), new DateTime(10, 10, 10, 12, 12, 12), 5, 5, 5, 5, 5, 5, 5, 5, false));
+            var updatedActivity = await activityRepository.UpdateActivity(11, new Activity(10, "Updated Activity", new DateTime(2021, 10, 10), new DateTime(10, 10, 10, 10, 10, 10), new DateTime(10, 10, 10, 12, 12, 12), 5, 5, 5, 5, 5, 5, 5, 5, false, new List<HeartRate>(new HeartRate[] { new HeartRate(10, 10D, new TimeOnly(10, 10, 10), 10f, 10, 10f, 10f, 10) })));
             if (updatedActivity != null)
             {
                 Console.WriteLine($"Activity updated successfully: ID: {updatedActivity.Id}, Name: {updatedActivity.Type}, Date: {updatedActivity.Date}, Start Time: {updatedActivity.StartTime}, End Time: {updatedActivity.EndTime}");