(#389) (#388) udpate feed generation for posts, udpate frineds service

MiniSpace.APIGateway/src/MiniSpace.APIGateway/ntrada.yml

@@ -590,7 +590,7 @@ modules:
           auth: true
 
         - upstream: /search
-          method: POST
+          method: GET
           use: downstream
           downstream: comments-service/comments/search
 
@@ -615,11 +615,21 @@ modules:
           downstream: reactions-service/reactions
           auth: true
 
+        - upstream: /{reactionId}
+          method: PUT
+          use: downstream
+          downstream: reactions-service/reactions/{reactionId}
+          auth: true
+          bind:
+            - reactionId: {reactionId}
+
         - upstream: /{reactionId}
           method: DELETE
           use: downstream
           downstream: reactions-service/reactions/{reactionId}
           auth: true
+          bind:
+            - reactionId: {reactionId}
 
         - upstream: /
           method: GET
@@ -771,6 +781,14 @@ modules:
         downstream: posts-service/posts
         auth: true
 
+      - upstream: /users/{userId}/feed
+        method: GET
+        use: downstream
+        downstream: posts-service/posts/users/{userId}/feed
+        bind:
+          - userId:{userId}
+        auth: true
+
       - upstream: /search
         method: GET
         use: downstream
@@ -798,6 +816,8 @@ modules:
         method: GET
         use: downstream
         downstream: posts-service/posts/{postId}
+        bind:
+          - postId:{postId}
 
       - upstream: /
         method: GET

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Api/MiniSpace.Services.Comments.Api.sln

@@ -0,0 +1,25 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.5.002.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MiniSpace.Services.Comments.Api", "MiniSpace.Services.Comments.Api.csproj", "{A198F9BC-F912-464E-BBCB-851CFBDD320F}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{A198F9BC-F912-464E-BBCB-851CFBDD320F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{A198F9BC-F912-464E-BBCB-851CFBDD320F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{A198F9BC-F912-464E-BBCB-851CFBDD320F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{A198F9BC-F912-464E-BBCB-851CFBDD320F}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {331542E3-F8A0-4711-AC84-18DD6B0D3896}
+	EndGlobalSection
+EndGlobal

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Api/Program.cs

@@ -17,6 +17,7 @@
 using MiniSpace.Services.Comments.Application.Queries;
 using MiniSpace.Services.Comments.Application.Services;
 using MiniSpace.Services.Comments.Infrastructure;
+using MiniSpace.Services.Comments.Core.Wrappers;
 
 namespace MiniSpace.Services.Identity.Api
 {
@@ -34,14 +35,10 @@ public static async Task Main(string[] args)
                 .Configure(app => app
                     .UseInfrastructure()
                     .UseEndpoints(endpoints => endpoints
-                        .Get("", ctx => ctx.Response.WriteAsync(ctx.RequestServices.GetService<AppOptions>().Name))
-                        .Post<SearchComments>("comments/search", async (cmd, ctx) =>
-                        {
-                            var pagedResult = await ctx.RequestServices.GetService<ICommentService>().BrowseCommentsAsync(cmd);
-                            await ctx.Response.WriteJsonAsync(pagedResult);
-                        }))
+                        .Get("", ctx => ctx.Response.WriteAsync(ctx.RequestServices.GetService<AppOptions>().Name)))
                     .UseDispatcherEndpoints(endpoints => endpoints
                         .Get<GetComment, CommentDto>("comments/{commentID}")
+                        .Get<SearchComments, PagedResponse<CommentDto>>("comments/search")
                         .Post<CreateComment>("comments")
                         .Put<UpdateComment>("comments/{commentID}")
                         .Delete<DeleteComment>("comments/{commentID}")

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Application/Commands/AddLike.cs

@@ -5,11 +5,15 @@ namespace MiniSpace.Services.Comments.Application.Commands
 {
     public class AddLike : ICommand
     {
-        public Guid CommentId { get; set; }
+        public Guid CommentId { get; }
+        public Guid UserId { get; }
+        public string CommentContext { get; }
 
-        public AddLike(Guid commentId)
+        public AddLike(Guid commentId, Guid userId, string commentContext)
         {
             CommentId = commentId;
+            UserId = userId;
+            CommentContext = commentContext;
         }
     }
 }

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Application/Commands/Handlers/AddLikeHandler.cs

@@ -1,48 +1,111 @@
 using System;
-using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Convey.CQRS.Commands;
 using MiniSpace.Services.Comments.Application.Events;
 using MiniSpace.Services.Comments.Application.Exceptions;
-using MiniSpace.Services.Comments.Application.Services;
+using MiniSpace.Services.Comments.Application.Services.Clients;
 using MiniSpace.Services.Comments.Core.Entities;
 using MiniSpace.Services.Comments.Core.Repositories;
+using MiniSpace.Services.Comments.Core.Exceptions;
+using MiniSpace.Services.Comments.Application.Services;
+using System.Text.Json;
 
 namespace MiniSpace.Services.Comments.Application.Commands.Handlers
 {
     public class AddLikeHandler : ICommandHandler<AddLike>
     {
-        private readonly ICommentRepository _commentRepository;
-        private readonly IAppContext _appContext;
+        private readonly IOrganizationEventsCommentRepository _organizationEventsCommentRepository;
+        private readonly IOrganizationPostsCommentRepository _organizationPostsCommentRepository;
+        private readonly IUserEventsCommentRepository _userEventsCommentRepository;
+        private readonly IUserPostsCommentRepository _userPostsCommentRepository;
         private readonly IMessageBroker _messageBroker;
+        private readonly IAppContext _appContext;
+        private readonly IStudentsServiceClient _userServiceClient;
 
-        public AddLikeHandler(ICommentRepository commentRepository, IAppContext appContext,
-            IMessageBroker messageBroker)
+        public AddLikeHandler(
+            IOrganizationEventsCommentRepository organizationEventsCommentRepository,
+            IOrganizationPostsCommentRepository organizationPostsCommentRepository,
+            IUserEventsCommentRepository userEventsCommentRepository,
+            IUserPostsCommentRepository userPostsCommentRepository,
+            IMessageBroker messageBroker,
+            IAppContext appContext,
+            IStudentsServiceClient userServiceClient)
         {
-            _commentRepository = commentRepository;
-            _appContext = appContext;
+            _organizationEventsCommentRepository = organizationEventsCommentRepository;
+            _organizationPostsCommentRepository = organizationPostsCommentRepository;
+            _userEventsCommentRepository = userEventsCommentRepository;
+            _userPostsCommentRepository = userPostsCommentRepository;
             _messageBroker = messageBroker;
+            _appContext = appContext;
+            _userServiceClient = userServiceClient;
         }
 
         public async Task HandleAsync(AddLike command, CancellationToken cancellationToken = default)
         {
-            var comment = await _commentRepository.GetAsync(command.CommentId);
-            if (comment is null)
+             var commandJson = JsonSerializer.Serialize(command, new JsonSerializerOptions { WriteIndented = true });
+            Console.WriteLine($"Received AddLike command: {commandJson}");
+            var identity = _appContext.Identity;
+
+            if (!identity.IsAuthenticated || identity.Id != command.UserId)
             {
-                throw new CommentNotFoundException(command.CommentId);
+                throw new UnauthorizedCommentAccessException(command.CommentId, identity.Id);
             }
 
-            var identity = _appContext.Identity;
-            if (!identity.IsAuthenticated)
+            var user = await _userServiceClient.GetAsync(command.UserId);
+            if (user == null)
             {
-                throw new UnauthorizedCommentAccessException(command.CommentId, identity.Id);
+                throw new UserNotFoundException(command.UserId);
+            }
+
+            if (!Enum.TryParse<CommentContext>(command.CommentContext, true, out var commentContext))
+            {
+                throw new InvalidCommentContextEnumException(command.CommentContext);
             }
 
-            comment.Like(identity.Id);
-            await _commentRepository.UpdateAsync(comment);
+            Comment comment = await GetCommentAsync(command.CommentId, commentContext);
+            if (comment == null)
+            {
+                throw new CommentNotFoundException(command.CommentId);
+            }
+
+            comment.Like(command.UserId);
+            await UpdateCommentAsync(comment, commentContext);
 
             await _messageBroker.PublishAsync(new CommentUpdated(command.CommentId));
         }
+
+        private async Task<Comment> GetCommentAsync(Guid commentId, CommentContext context)
+        {
+            return context switch
+            {
+                CommentContext.OrganizationEvent => await _organizationEventsCommentRepository.GetAsync(commentId),
+                CommentContext.OrganizationPost => await _organizationPostsCommentRepository.GetAsync(commentId),
+                CommentContext.UserEvent => await _userEventsCommentRepository.GetAsync(commentId),
+                CommentContext.UserPost => await _userPostsCommentRepository.GetAsync(commentId),
+                _ => null
+            };
+        }
+
+        private async Task UpdateCommentAsync(Comment comment, CommentContext context)
+        {
+            switch (context)
+            {
+                case CommentContext.OrganizationEvent:
+                    await _organizationEventsCommentRepository.UpdateAsync(comment);
+                    break;
+                case CommentContext.OrganizationPost:
+                    await _organizationPostsCommentRepository.UpdateAsync(comment);
+                    break;
+                case CommentContext.UserEvent:
+                    await _userEventsCommentRepository.UpdateAsync(comment);
+                    break;
+                case CommentContext.UserPost:
+                    await _userPostsCommentRepository.UpdateAsync(comment);
+                    break;
+                default:
+                    throw new InvalidCommentContextEnumException(context.ToString());
+            }
+        }
     }
 }

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Application/Commands/Handlers/CreateCommentHandler.cs

@@ -48,6 +48,16 @@ public CreateCommentHandler(
         public async Task HandleAsync(CreateComment command, CancellationToken cancellationToken = default)
         {
             var identity = _appContext.Identity;
+
+    if (identity.IsAuthenticated)
+    {
+        Console.WriteLine($"User is authenticated: {identity.Id}");
+        Console.WriteLine($"User command id is: {command.UserId}");
+    }
+    else
+    {
+        Console.WriteLine("User is not authenticated.");
+    }
             if (identity.IsAuthenticated && identity.Id != command.UserId)
             {
                 throw new UnauthorizedCommentAccessException(command.ContextId, identity.Id);

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Application/Queries/SearchComments.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Convey.CQRS.Queries;
+using MiniSpace.Services.Comments.Application.Dto;
+using MiniSpace.Services.Comments.Core.Wrappers;
+
+namespace MiniSpace.Services.Comments.Application.Queries
+{
+    public class SearchComments : IQuery<PagedResponse<CommentDto>>
+    {
+        public Guid ContextId { get; set; }
+        public string CommentContext { get; set; }
+        public Guid? ParentId { get; set; }
+        public int Page { get; set; }
+        public int Size { get; set; }
+        public string SortBy { get; set; }  // Changed to string to handle the incoming JSON properly
+        public string Direction { get; set; }
+
+        // This property will split the SortBy string into an array
+        public IEnumerable<string> SortByArray => 
+            string.IsNullOrEmpty(SortBy) ? new List<string> { "CreatedAt" } : SortBy.Split(',');
+    }
+}

MiniSpace.Services.Comments/src/MiniSpace.Services.Comments.Core/Entities/Comment.cs

@@ -8,8 +8,8 @@ namespace MiniSpace.Services.Comments.Core.Entities
 {
     public class Comment : AggregateRoot
     {
-        private ISet<Guid> _likes = new HashSet<Guid>();
-        private ISet<Reply> _replies = new HashSet<Reply>();
+        private readonly ISet<Guid> _likes = new HashSet<Guid>();
+        private readonly ISet<Reply> _replies = new HashSet<Reply>();
 
         public Guid ContextId { get; private set; }
         public CommentContext CommentContext { get; private set; }
@@ -22,17 +22,10 @@ public class Comment : AggregateRoot
         public int RepliesCount => _replies.Count;
         public bool IsDeleted { get; private set; }
 
-        public IEnumerable<Guid> Likes
-        {
-            get => _likes;
-            private set => _likes = new HashSet<Guid>(value);
-        }
+        // Expose the _likes set as a read-only IEnumerable
+        public IEnumerable<Guid> Likes => _likes;
 
-        public IEnumerable<Reply> Replies
-        {
-            get => _replies;
-            private set => _replies = new HashSet<Reply>(value);
-        }
+        public IEnumerable<Reply> Replies => _replies;
 
         public Comment(Guid id, Guid contextId, CommentContext commentContext, Guid userId,
             IEnumerable<Guid> likes, Guid parentId, string textContent, DateTime createdAt, DateTime lastUpdatedAt, 
@@ -42,19 +35,19 @@ public Comment(Guid id, Guid contextId, CommentContext commentContext, Guid user
             ContextId = contextId;
             CommentContext = commentContext;
             UserId = userId;
-            Likes = likes;
+            _likes = new HashSet<Guid>(likes);
             ParentId = parentId;
             TextContent = textContent;
             CreatedAt = createdAt;
             LastUpdatedAt = lastUpdatedAt;
             LastReplyAt = lastReplyAt;
-            Replies = replies;
+            _replies = new HashSet<Reply>(replies);
             IsDeleted = isDeleted;
         }
 
         public void Like(Guid userId)
         {
-            if (Likes.Any(id => id == userId))
+            if (_likes.Contains(userId))
             {
                 throw new UserAlreadyLikesCommentException(userId);
             }
@@ -65,7 +58,7 @@ public void Like(Guid userId)
 
         public void UnLike(Guid userId)
         {
-            if (Likes.All(id => id != userId))
+            if (!_likes.Contains(userId))
             {
                 throw new UserNotLikeCommentException(userId, Id);
             }