✨ Add functionality for managing user favorite activities

TaleEngine/TaleEngine.Application.Contracts/IActivityService.cs

@@ -11,6 +11,9 @@ public interface IActivityService
         List<ActivityEntity> GetPendingActivities(int editionId);
         List<ActivityEntity> GetLastThreeActivities(int editionId);
         IEnumerable<ActivityEntity> GetActiveActivitiesFiltered(int typeId, int editionId, List<int> timeframes, string title, int skipByPagination, int activitiesPerPage, int userFav = default);
+        List<ActivityEntity> GetFavouriteActivitiesByUser(int userId, int editionId);
+        bool AddFavouriteActivity(int activityId, int userId);
+        bool RemoveFavouriteActivity(int activityId, int userId);
 
         int ChangeActivityStatus(int activityId, int statusId);
         int DeleteActivity(int activityId);

TaleEngine/TaleEngine.Application/ActivityService.cs

@@ -67,6 +67,98 @@ public IEnumerable<ActivityEntity> GetActiveActivitiesFiltered(int typeId, int e
             return query;
         }
 
+        public List<ActivityEntity> GetFavouriteActivitiesByUser(int userId, int editionId)
+        {
+            if (userId == default || editionId == default)
+            {
+                return new List<ActivityEntity>();
+            }
+
+            return GetFavActivitiesFiltered(0, editionId, null, null, userId).ToList();
+        }
+
+        public bool AddFavouriteActivity(int activityId, int userId)
+        {
+            try
+            {
+                var user = _unitOfWork.UserRepository.GetById(userId);
+                var activity = _unitOfWork.ActivityRepository.GetById(activityId);
+
+                if (user == null || activity == null)
+                {
+                    return false;
+                }
+
+                activity = _unitOfWork.ActivityRepository.GetAllIncludeFavs(activity.EditionId)
+                    .FirstOrDefault(a => a.Id == activityId);
+
+                if (activity == null)
+                {
+                    return false;
+                }
+
+                if (activity.UsersFav == null)
+                {
+                    activity.UsersFav = new List<UserEntity>();
+                }
+
+                if (activity.UsersFav.Any(u => u.Id == userId))
+                {
+                    return false;
+                }
+
+                activity.UsersFav.Add(user);
+
+                _unitOfWork.ActivityRepository.Update(activity);
+                _unitOfWork.ActivityRepository.Save();
+
+                return true;
+            }
+            catch (Exception)
+            {
+                return false;
+            }
+        }
+
+        public bool RemoveFavouriteActivity(int activityId, int userId)
+        {
+            try
+            {
+                var activity = _unitOfWork.ActivityRepository.GetById(activityId);
+
+                if (activity == null)
+                {
+                    return false;
+                }
+
+                activity = _unitOfWork.ActivityRepository.GetAllIncludeFavs(activity.EditionId)
+                    .FirstOrDefault(a => a.Id == activityId);
+
+                if (activity?.UsersFav == null)
+                {
+                    return false;
+                }
+
+                var userToRemove = activity.UsersFav.FirstOrDefault(u => u.Id == userId);
+
+                if (userToRemove == null)
+                {
+                    return false;
+                }
+
+                activity.UsersFav.Remove(userToRemove);
+
+                _unitOfWork.ActivityRepository.Update(activity);
+                _unitOfWork.ActivityRepository.Save();
+
+                return true;
+            }
+            catch (Exception)
+            {
+                return false;
+            }
+        }
+
         public int DeleteActivity(int activityId)
         {
             try
@@ -195,13 +287,14 @@ private IEnumerable<ActivityEntity> GetActiveActivitiesWithFilter(int type, List
 
         private IEnumerable<ActivityEntity> GetFavActivitiesFiltered(int type, int editionId, List<int> timeframes, string title, int userFav)
         {
-            var user = _unitOfWork.UserRepository.GetById(userFav);
-
             var activeStatus = _activityStatusService
                 .GetById((int)ActivityStatusEnum.ACT);
 
             var query = _unitOfWork.ActivityRepository.GetAllIncludeFavs(editionId)
-                .Where(a => a.UsersFav.Contains(user) && a.StatusId == activeStatus.Id);
+                .Where(a => a.EditionId == editionId
+                    && a.StatusId == activeStatus.Id
+                    && a.UsersFav != null
+                    && a.UsersFav.Any(u => u.Id == userFav));
 
             return ApplyActivityFilters(query, type, timeframes, title);
         }

TaleEngine/TaleEngine.Bussiness/Commands/ActivityCommands.cs

@@ -140,5 +140,15 @@ public bool LeaveActivityCommand(ActivityEnrollmentRequest request)
         {
             return _activityService.RemoveUserFromActivity(request.ActivityId, request.UserId);
         }
+
+        public bool AddFavouriteActivityCommand(ActivityEnrollmentRequest request)
+        {
+            return _activityService.AddFavouriteActivity(request.ActivityId, request.UserId);
+        }
+
+        public bool RemoveFavouriteActivityCommand(ActivityEnrollmentRequest request)
+        {
+            return _activityService.RemoveFavouriteActivity(request.ActivityId, request.UserId);
+        }
     }
 }

TaleEngine/TaleEngine.Bussiness/Contracts/IActivityCommands.cs

@@ -12,5 +12,7 @@ public interface IActivityCommands
         void ChangeActivityStatusCommand(int activityId, int statusId);
         ActivityEnrollmentResult EnrollInActivityCommand(ActivityEnrollmentRequest request);
         bool LeaveActivityCommand(ActivityEnrollmentRequest request);
+        bool AddFavouriteActivityCommand(ActivityEnrollmentRequest request);
+        bool RemoveFavouriteActivityCommand(ActivityEnrollmentRequest request);
     }
 }

TaleEngine/TaleEngine.Bussiness/Contracts/IActivityQueries.cs

@@ -10,6 +10,7 @@ public interface IActivityQueries
         List<ActivityDto> ActiveActivitiesQuery(int editionId);
         List<ActivityDto> PendingActivitiesQuery(int editionId);
         ActivityFilteredResult ActiveActivitiesFilteredQuery(ActivityFilterRequest activityFilterRequest, int userId = default);
+        List<ActivityDto> FavouriteActivitiesByUserQuery(int userId, int editionId);
         List<ActivityDto> LastThreeActivitiesQuery(int editionId);
         WaitingListResult GetWaitingListQuery(int activityId);
         int? GetUserPositionInWaitingListQuery(int activityId, int userId);

TaleEngine/TaleEngine.Bussiness/Queries/ActivityQueries.cs

@@ -84,6 +84,15 @@ public List<ActivityDto> LastThreeActivitiesQuery(int edition)
             return result;
         }
 
+        public List<ActivityDto> FavouriteActivitiesByUserQuery(int userId, int editionId)
+        {
+            var activities = _activityService.GetFavouriteActivitiesByUser(userId, editionId);
+
+            var models = ActivityMapper.MapEntityToDto(activities);
+
+            return models;
+        }
+
         public WaitingListResult GetWaitingListQuery(int activityId)
         {
             var activity = _activityService.GetById(activityId);

TaleEngine/TaleEngine.Data.Contracts/Repositories/IActivityRepository.cs

@@ -5,7 +5,7 @@ namespace TaleEngine.Data.Contracts.Repositories
 {
     public interface IActivityRepository : IGenericRepository<ActivityEntity>
     {
-        List<ActivityEntity> GetAllIncludeFavs(int eventId);
+        List<ActivityEntity> GetAllIncludeFavs(int editionId);
         List<ActivityEntity> GetEventActivities(int eventId);
         List<ActivityEntity> GetActivitiesByStatus(int edition, int status);
         List<ActivityEntity> GetActiveActivitiesFiltered(int status, int type, int edition, string title, int skip, int activitiesPerPage);

TaleEngine/TaleEngine.Data/Repositories/ActivityRepository.cs

@@ -93,12 +93,18 @@ public int GetTotalActivities(int status, int type, int edition, string title)
             throw new System.NotImplementedException();
         }
 
-        public List<ActivityEntity> GetAllIncludeFavs(int eventId)
+        public List<ActivityEntity> GetAllIncludeFavs(int editionId)
         {
-            return _context.Activities
+            var query = _context.Activities
                 .Include(a => a.UsersFav)
-                .Where(a => !a.IsDeleted)
-                .ToList();
+                .Where(a => !a.IsDeleted);
+
+            if (editionId != default)
+            {
+                query = query.Where(a => a.EditionId == editionId);
+            }
+
+            return query.ToList();
         }
 
         public List<ActivityEntity> GetAllIncludeEnrollments(int activityId)

TaleEngine/TaleEngine.Testing/Controllers/V1/ActivityControllerTests.cs

@@ -365,6 +365,179 @@ public void ChangeActivityStatus_Success()
             commands.Verify(x => x.ChangeActivityStatusCommand(dto.StatusId, dto.ActivityId), Times.Once);
         }
 
+        [Fact]
+        public void GetFavouriteActivitiesByUser_Success()
+        {
+            // Arrange
+            int userId = 1;
+            int editionId = 2;
+            Mock<IActivityCommands> commands = new();
+            Mock<IActivityQueries> queries = new();
+            List<ActivityDto> dto = new()
+            {
+                new ActivityDto()
+            };
+
+            queries.Setup(x => x.FavouriteActivitiesByUserQuery(userId, editionId))
+                .Returns(dto);
+
+            ActivityController target = new(commands.Object, queries.Object);
+
+            // Act
+            IActionResult result = target.GetFavouriteActivitiesByUser(userId, editionId);
+
+            // Assert
+            var resultAsObjResult = result as ObjectResult;
+
+            result.Should().NotBeNull();
+            resultAsObjResult.StatusCode.Should().Be(StatusCodes.Status200OK);
+
+            queries.Verify(x => x.FavouriteActivitiesByUserQuery(userId, editionId), Times.Once);
+        }
+
+        [Fact]
+        public void GetFavouriteActivitiesByUser_EmptyResult_Success()
+        {
+            // Arrange
+            int userId = 1;
+            int editionId = 2;
+            Mock<IActivityCommands> commands = new();
+            Mock<IActivityQueries> queries = new();
+            List<ActivityDto> dto = new();
+
+            queries.Setup(x => x.FavouriteActivitiesByUserQuery(userId, editionId))
+                .Returns(dto);
+
+            ActivityController target = new(commands.Object, queries.Object);
+
+            // Act
+            IActionResult result = target.GetFavouriteActivitiesByUser(userId, editionId);
+
+            // Assert
+            var resultAsObjResult = result as StatusCodeResult;
+
+            result.Should().NotBeNull();
+            resultAsObjResult.StatusCode.Should().Be(StatusCodes.Status204NoContent);
+
+            queries.Verify(x => x.FavouriteActivitiesByUserQuery(userId, editionId), Times.Once);
+        }
+
+        [Fact]
+        public void AddFavouriteActivity_Success()
+        {
+            // Arrange
+            Mock<IActivityCommands> commands = new();
+            Mock<IActivityQueries> queries = new();
+            ActivityEnrollmentRequest request = new()
+            {
+                ActivityId = 1,
+                UserId = 1
+            };
+
+            commands.Setup(x => x.AddFavouriteActivityCommand(request))
+                .Returns(true);
+
+            ActivityController target = new(commands.Object, queries.Object);
+
+            // Act
+            IActionResult result = target.AddFavouriteActivity(request);
+
+            // Assert
+            var resultAsObjResult = result as ObjectResult;
+
+            result.Should().NotBeNull();
+            resultAsObjResult.StatusCode.Should().Be(StatusCodes.Status200OK);
+
+            commands.Verify(x => x.AddFavouriteActivityCommand(request), Times.Once);
+        }
+
+        [Fact]
+        public void AddFavouriteActivity_Fail_Success()
+        {
+            // Arrange
+            Mock<IActivityCommands> commands = new();
+            Mock<IActivityQueries> queries = new();
+            ActivityEnrollmentRequest request = new()
+            {
+                ActivityId = 1,
+                UserId = 1
+            };
+
+            commands.Setup(x => x.AddFavouriteActivityCommand(request))
+                .Returns(false);
+
+            ActivityController target = new(commands.Object, queries.Object);
+
+            // Act
+            IActionResult result = target.AddFavouriteActivity(request);
+
+            // Assert
+            var resultAsObjResult = result as ObjectResult;
+
+            result.Should().NotBeNull();
+            resultAsObjResult.StatusCode.Should().Be(StatusCodes.Status400BadRequest);
+
+            commands.Verify(x => x.AddFavouriteActivityCommand(request), Times.Once);
+        }
+
+        [Fact]
+        public void RemoveFavouriteActivity_Success()
+        {
+            // Arrange
+            Mock<IActivityCommands> commands = new();
+            Mock<IActivityQueries> queries = new();
+            ActivityEnrollmentRequest request = new()
+            {
+                ActivityId = 1,
+                UserId = 1
+            };
+
+            commands.Setup(x => x.RemoveFavouriteActivityCommand(request))
+                .Returns(true);
+
+            ActivityController target = new(commands.Object, queries.Object);
+
+            // Act
+            IActionResult result = target.RemoveFavouriteActivity(request);
+
+            // Assert
+            var resultAsObjResult = result as ObjectResult;
+
+            result.Should().NotBeNull();
+            resultAsObjResult.StatusCode.Should().Be(StatusCodes.Status200OK);
+
+            commands.Verify(x => x.RemoveFavouriteActivityCommand(request), Times.Once);
+        }
+
+        [Fact]
+        public void RemoveFavouriteActivity_Fail_Success()
+        {
+            // Arrange
+            Mock<IActivityCommands> commands = new();
+            Mock<IActivityQueries> queries = new();
+            ActivityEnrollmentRequest request = new()
+            {
+                ActivityId = 1,
+                UserId = 1
+            };
+
+            commands.Setup(x => x.RemoveFavouriteActivityCommand(request))
+                .Returns(false);
+
+            ActivityController target = new(commands.Object, queries.Object);
+
+            // Act
+            IActionResult result = target.RemoveFavouriteActivity(request);
+
+            // Assert
+            var resultAsObjResult = result as ObjectResult;
+
+            result.Should().NotBeNull();
+            resultAsObjResult.StatusCode.Should().Be(StatusCodes.Status400BadRequest);
+
+            commands.Verify(x => x.RemoveFavouriteActivityCommand(request), Times.Once);
+        }
+
         [Fact]
         public void GetActivitiesFiltered_Success()
         {