all working (friendship not tested)

src/DbContextLib/HeartTrackContext.cs

@@ -206,19 +206,22 @@ namespace DbContextLib
                 .HasMany(at => at.Statistics)
                 .WithOne(s => s.Athlete)
                 .HasForeignKey(s => s.AthleteId)
-                .IsRequired(false);
+                .IsRequired(false)
+                .OnDelete(DeleteBehavior.Cascade);
 
             modelBuilder.Entity<AthleteEntity>()
                 .HasMany(at => at.Activities)
                 .WithOne(a => a.Athlete)
                 .HasForeignKey(a => a.AthleteId)
-                .IsRequired(false);
+                .IsRequired(false)
+                .OnDelete(DeleteBehavior.Cascade);
 
             modelBuilder.Entity<ActivityEntity>()
                 .HasMany(a => a.HeartRates)
                 .WithOne(h => h.Activity)
                 .HasForeignKey(h => h.ActivityId)
-                .IsRequired();
+                .IsRequired()
+                .OnDelete(DeleteBehavior.Cascade);
 
             modelBuilder.Entity<DataSourceEntity>()
                 .HasMany(d => d.Activities)

src/EFMappers/AthleteMappeur.cs

@@ -30,8 +30,8 @@ public static class UserMappeur
         Action<AthleteEntity, User> link = (athleteEntity, model) =>
         {
             model.Role = athleteEntity.IsCoach ?  new Coach() : new Athlete();
-            model.DataSources.Add(athleteEntity.DataSource.ToModel());
-            model.Activities.AddRange(athleteEntity.Activities.ToModels());
+            if (athleteEntity.DataSource != null) model.DataSources.Add(athleteEntity.DataSource.ToModel());
+            if (athleteEntity.Activities != null) model.Activities.AddRange(athleteEntity.Activities.ToModels());
             //model.Image = athleteEntity.Image.ToModel();
         };
         

src/HeartTrackAPI/Controllers/ActivityController.cs

@@ -121,13 +121,25 @@ public class ActivityController : Controller
     [HttpGet("{id}")]
     public async Task<ActionResult<ActivityDto>> GetActivity(int id)
     {
+        try
+        {
+            _logger.LogInformation("Executing {Action} with parameters: {Parameters}", nameof(GetActivity), id);
+
             var activity = await _activityService.GetActivityByIdAsync(id);
             if (activity == null)
             {
-            return NotFound();
+                _logger.LogError("Activity with id {id} not found", id);
+
+                return NotFound($"Activity with id {id} not found");
             }
             return Ok(activity.ToDto());
         }
+        catch (Exception e)
+        {
+            _logger.LogError(e, "Error while getting activity by id {id}", id);
+            return Problem();
+        }
+    }
 
     [HttpPut("{id}")]
     public async Task<IActionResult> PutActivity(int id, ActivityDto activityDto)
@@ -145,15 +157,44 @@ public class ActivityController : Controller
         return NoContent();
     }
 
+    /// <summary>
+    /// Supprime une activity spécifique.
+    /// </summary>
+    /// <param name="id">L'identifiant de l'activity à supprimer.</param>
+    /// <returns>Action result.</returns>
+    /// <response code="200">Activity supprimé avec succès.</response>
+    /// <response code="404">Activity non trouvé.</response>
+        /// <response code="500">Erreur interne du serveur.</response>
     [HttpDelete("{id}")]
+    [ProducesResponseType(200)]
+    [ProducesResponseType(404)]
+    [ProducesResponseType(500)]
     public async Task<IActionResult> DeleteActivity(int id)
     {
-        var result = await _activityService.DeleteActivity(id);
-        if (!result)
+        try
         {
-            return NotFound();
+            _logger.LogInformation("Executing {Action} with parameters: {Parameters} for {Id}", nameof(DeleteActivity), null,id);
+            
+            
+            var activity = await _activityService.GetActivityByIdAsync(id);
+            if (activity == null)
+            {
+                _logger.LogError("Activity with id {id} not found", id);
+                return NotFound($"Activity with id {id} not found");
+            }
+            var isDeleted = await _activityService.DeleteActivity(id);
+            if(!isDeleted)
+            {
+                _logger.LogError("Error while deleting activity with id {id}", id);
+                return Problem("Error while deleting activity");
+            }
+            return Ok();
+        }
+        catch (Exception e)
+        {
+            _logger.LogError(e, "Error while deleting activity");
+            return Problem();
         }
-        return NoContent();
     }
     
 /*

src/HeartTrackAPI/Controllers/UsersController.cs

@@ -398,7 +398,7 @@ public class UsersController : Controller
                 return BadRequest("To many object is asked the max is : " + totalCount);
             }
             _logger.LogInformation("Executing {Action} with parameters: {Parameters}", nameof(GetActivitiesByUser), pageRequest);
-            var activities = await _activityService.GetActivitiesByUser(userId, pageRequest.Index, pageRequest.Count, ActivityOrderCriteria.None, pageRequest.Descending ?? false);
+            var activities = await _activityService.GetActivitiesByUser(userId, pageRequest.Index, pageRequest.Count, Enum.TryParse(pageRequest.OrderingPropertyName, out ActivityOrderCriteria result) ? result : ActivityOrderCriteria.None, pageRequest.Descending ?? false);
             if(activities == null)
             {
                 return NotFound("No activities found");

src/Model2Entities/ActivityRepository.cs

@@ -37,7 +37,8 @@ public partial class DbDataManager : IDataManager
         {
             _logger.LogInformation($"GetActivityByIdAsync with id {id}", id);
 
-            var activity = _dataManager.DbContext.ActivitiesSet.IncludeStandardProperties().GetItemsWithFilterAndOrdering(b => b.IdActivity == id, 0, 1, ActivityOrderCriteria.None, false).First().ToModel();
+            var activityEntity =  await _dataManager.DbContext.ActivitiesSet.IncludeStandardProperties().SingleOrDefaultAsync(a => a.IdActivity == id);
+            var activity = activityEntity != null ? activityEntity.ToModel() : null;
 
             if (activity != null)
                 _logger.LogInformation($"Retrieved activity with ID {id}");

src/Model2Entities/Extension.cs

@@ -102,7 +102,7 @@ public static class Extensions
     public static IQueryable<AthleteEntity> IncludeStandardProperties(this IQueryable<AthleteEntity> query)
     {
         return query.Include(a => a.DataSource)
-            .Include(a => a.Activities)
+            .Include(a => a.Activities).ThenInclude(ac => ac.HeartRates).Include(ac => ac.Activities).ThenInclude(ac => ac.DataSource)
             .Include(a => a.Image);
     }
     // public static Activity ToModel(this ActivityEntity entity)

src/Model2Entities/UserRepository.cs

@@ -109,10 +109,9 @@ public partial class DbDataManager
         {
    
                 _logger.LogInformation("GetNbItems");
-                var nbItems = _dataManager.DbContext.AthletesSet.Count();
+                var nbItems = await _dataManager.DbContext.AthletesSet.CountAsync();
                 _logger.LogInformation($"Retrieved {nbItems} users");
                 return await Task.FromResult(nbItems);
-        
         }
         
         public async Task<IEnumerable<User>> GetAllAthletes(int index, int count, AthleteOrderCriteria? criteria,