✨ Add functionality for managing user favorite activities

TaleEngine/TaleEngine.Application.Contracts/IActivityService.cs

@@ -10,7 +10,10 @@ public interface IActivityService
         List<ActivityEntity> GetActiveActivities(int editionId);
         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);
+        IEnumerable<ActivityEntity> GetActiveActivitiesFiltered(int typeId, int editionId, List<int> timeframes, string title, 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

@@ -51,7 +51,7 @@ public List<ActivityEntity> GetPendingActivities(int editionId)
         }
 
         public IEnumerable<ActivityEntity> GetActiveActivitiesFiltered(int typeId, int editionId,
-                List<int> timeFrames, string title, int skipByPagination, int activitiesPerPage, int userFav = default)
+                List<int> timeFrames, string title, int userFav = default)
         {
             IEnumerable<ActivityEntity> query;
 
@@ -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.Business.Testing/ActivityQueriesPaginationTests.cs

@@ -0,0 +1,69 @@
+using FluentAssertions;
+using Moq;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using TaleEngine.API.Contracts.Dtos.Requests;
+using TaleEngine.CQRS.Queries;
+using TaleEngine.Data.Contracts.Entities;
+using TaleEngine.Services.Contracts;
+using Xunit;
+
+namespace TaleEngine.CQRS.Testing
+{
+    [ExcludeFromCodeCoverage]
+    public class ActivityQueriesPaginationTests
+    {
+        [Fact]
+        public void ActiveActivitiesFilteredQuery_ShouldApplyPaginationAndCalculateTotalPages()
+        {
+            // Arrange
+            const int editionId = 1;
+            const int userId = 10;
+
+            var request = new ActivityFilterRequest
+            {
+                EditionId = editionId,
+                Page = 1,
+                Title = string.Empty,
+                TimeFrames = new List<int>()
+            };
+
+            var editionServiceMock = new Mock<IEditionService>();
+            var activityServiceMock = new Mock<IActivityService>();
+
+            var allFilteredActivities = Enumerable.Range(1, 7)
+                .Select(i => new ActivityEntity
+                {
+                    Id = i,
+                    Title = $"Activity {i}",
+                    EditionId = editionId
+                })
+                .ToList();
+
+            editionServiceMock.Setup(x => x.GetById(editionId))
+                .Returns(new EditionEntity { Id = editionId });
+
+            activityServiceMock.Setup(x => x.GetActiveActivitiesFiltered(
+                    request.TypeId,
+                    editionId,
+                    request.TimeFrames,
+                    request.Title,
+                    userId))
+                .Returns(allFilteredActivities);
+
+            var target = new ActivityQueries(activityServiceMock.Object, editionServiceMock.Object);
+
+            // Act
+            var result = target.ActiveActivitiesFilteredQuery(request, userId);
+
+            // Assert
+            result.Should().NotBeNull();
+            result.CurrentPage.Should().Be(1);
+            result.TotalPages.Should().Be(3);
+            result.Activities.Should().NotBeNull();
+            result.Activities.Should().HaveCount(3);
+            result.Activities.Select(a => a.Id).Should().Equal(new[] { 4, 5, 6 });
+        }
+    }
+}

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

@@ -55,10 +55,15 @@ public ActivityFilteredResult ActiveActivitiesFilteredQuery(ActivityFilterReques
             int skipByPagination = request.Page * ACTIVITIESPERPAGE;
 
             var activitiesQueried = _activityService.GetActiveActivitiesFiltered(request.TypeId, currentEdition.Id,
-                request.TimeFrames, request.Title, skipByPagination, ACTIVITIESPERPAGE, userId);
+                request.TimeFrames, request.Title, userId);
 
-            var totalActivities = activitiesQueried.Count();
-            var activities = activitiesQueried.ToList();
+            var filteredActivities = activitiesQueried.ToList();
+            var totalActivities = filteredActivities.Count;
+
+            var activities = filteredActivities
+                .Skip(skipByPagination)
+                .Take(ACTIVITIESPERPAGE)
+                .ToList();
 
             var models = ActivityMapper.MapEntityToDto(activities);
 
@@ -84,6 +89,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)