Changeset 73b69b2 for ChapterX.API

Timestamp:

03/24/26 22:13:36 (3 months ago)

Author:

kikisrbinoska <srbinoskakristina07@…>

Branches:

main

Children:

7fbb91c

Parents:

acf690c

Message:

Fixed reading lists,comments and likes

Location:

ChapterX.API/Controllers

Files:

• CommentsController.cs (modified) (2 diffs)
• LikesController.cs (modified) (3 diffs)
• NotificationsController.cs (modified) (2 diffs)
• ReadingListItemsController.cs (modified) (3 diffs)
• ReadingListsController.cs (modified) (3 diffs)

ChapterX.API/Controllers/CommentsController.cs

@@ -1 +1 @@
 using ChapterX.Application.Comment.Commands;
 using ChapterX.Application.Comment.Queries;
+using ChapterX.Domain.Repositories;
 using MediatR;
 using Microsoft.AspNetCore.Authorization;
@@ -13 +14 @@
     {
         private readonly IMediator _mediator;
+        private readonly ICommentRepository _commentRepository;
         private readonly ILogger<CommentsController> _logger;
 
-        public CommentsController(IMediator mediator, ILogger<CommentsController> logger)
+        public CommentsController(IMediator mediator, ICommentRepository commentRepository, ILogger<CommentsController> logger)
         {
             _mediator = mediator;
+            _commentRepository = commentRepository;
             _logger = logger;
+        }
+
+        [HttpGet("story/{storyId:int}")]
+        [AllowAnonymous]
+        public async Task<ActionResult> GetByStory(int storyId)
+        {
+            var comments = await _commentRepository.GetByStoryIdAsync(storyId);
+            var result = comments.Select(c => new
+            {
+                id = c.Id,
+                content = c.Content,
+                userId = c.UserId,
+                storyId = c.StoryId,
+                username = c.User?.Username ?? "",
+                createdAt = c.CreatedAt,
+            });
+            return Ok(result);
         }
 

ChapterX.API/Controllers/LikesController.cs

@@ -1 +1 @@
 using ChapterX.Application.Likes.Commands;
 using ChapterX.Application.Likes.Queries;
+using ChapterX.Domain.Repositories;
 using MediatR;
 using Microsoft.AspNetCore.Authorization;
@@ -13 +14 @@
     {
         private readonly IMediator _mediator;
+        private readonly ILikesRepository _likesRepository;
         private readonly ILogger<LikesController> _logger;
 
-        public LikesController(IMediator mediator, ILogger<LikesController> logger)
+        public LikesController(IMediator mediator, ILikesRepository likesRepository, ILogger<LikesController> logger)
         {
             _mediator = mediator;
+            _likesRepository = likesRepository;
             _logger = logger;
+        }
+
+        [HttpGet("story/{storyId:int}")]
+        [AllowAnonymous]
+        public async Task<ActionResult> GetByStory(int storyId)
+        {
+            var likes = await _likesRepository.GetByStoryIdAsync(storyId);
+            return Ok(new { count = likes.Count(), userIds = likes.Select(l => l.UserId).ToList() });
+        }
+
+        [HttpDelete("user/{userId:int}/story/{storyId:int}")]
+        [Authorize]
+        public async Task<ActionResult> DeleteByUserAndStory(int userId, int storyId)
+        {
+            var deleted = await _likesRepository.DeleteByUserAndStoryAsync(userId, storyId);
+            if (!deleted) return NotFound();
+            return Ok();
         }
 
@@ -43 +63 @@
         public async Task<ActionResult> Add([FromBody] AddRequest request)
         {
-            _logger.LogInformation("Adding a new like for ChapterId: {ChapterId}", request.ChapterId);
+            _logger.LogInformation("Adding a new like for StoryId: {StoryId}", request.StoryId);
+            var exists = await _likesRepository.ExistsAsync(request.UserId, request.StoryId);
+            if (exists) return Ok();
             var response = await _mediator.Send(request);
             return Ok(response);

ChapterX.API/Controllers/NotificationsController.cs

@@ -1 +1 @@
 using ChapterX.Application.Notification.Commands;
 using ChapterX.Application.Notification.Queries;
+using ChapterX.Domain.Repositories;
 using MediatR;
 using Microsoft.AspNetCore.Authorization;
@@ -13 +14 @@
     {
         private readonly IMediator _mediator;
+        private readonly INotificationRepository _notificationRepository;
         private readonly ILogger<NotificationsController> _logger;
 
-        public NotificationsController(IMediator mediator, ILogger<NotificationsController> logger)
+        public NotificationsController(IMediator mediator, INotificationRepository notificationRepository, ILogger<NotificationsController> logger)
         {
             _mediator = mediator;
+            _notificationRepository = notificationRepository;
             _logger = logger;
+        }
+
+        [HttpGet("user/{userId:int}")]
+        [Authorize]
+        public async Task<ActionResult> GetByUser(int userId)
+        {
+            var notifications = await _notificationRepository.GetByUserIdAsync(userId);
+            var result = notifications.Select(n => new
+            {
+                id = n.Id,
+                content = n.Content,
+                isRead = n.IsRead,
+                createdAt = n.CreatedAt,
+                type = n.Type ?? "info",
+                link = n.Link,
+            });
+            return Ok(result);
+        }
+
+        [HttpPut("{id:int}/read")]
+        [Authorize]
+        public async Task<ActionResult> MarkRead(int id)
+        {
+            var notification = await _notificationRepository.GetByIdAsync(id);
+            if (notification == null) return NotFound();
+            notification.IsRead = true;
+            await _notificationRepository.UpdateAsync(notification);
+            return Ok();
         }
 

ChapterX.API/Controllers/ReadingListItemsController.cs

@@ -1 +1 @@
 using ChapterX.Application.ReadingListItems.Commands;
 using ChapterX.Application.ReadingListItems.Queries;
+using ChapterX.Domain.Repositories;
 using MediatR;
 using Microsoft.AspNetCore.Authorization;
@@ -13 +14 @@
     {
         private readonly IMediator _mediator;
+        private readonly IReadingListItemsRepository _readingListItemsRepository;
         private readonly ILogger<ReadingListItemsController> _logger;
 
-        public ReadingListItemsController(IMediator mediator, ILogger<ReadingListItemsController> logger)
+        public ReadingListItemsController(IMediator mediator, IReadingListItemsRepository readingListItemsRepository, ILogger<ReadingListItemsController> logger)
         {
             _mediator = mediator;
+            _readingListItemsRepository = readingListItemsRepository;
             _logger = logger;
         }
@@ -70 +73 @@
             return Ok(response);
         }
+
+        [HttpDelete("{listId:int}/story/{storyId:int}")]
+        [Authorize]
+        public async Task<ActionResult> DeleteByListAndStory(int listId, int storyId)
+        {
+            _logger.LogInformation("Removing story {StoryId} from list {ListId}", storyId, listId);
+            var deleted = await _readingListItemsRepository.DeleteByListAndStoryAsync(listId, storyId);
+            return deleted ? Ok() : NotFound();
+        }
     }
 }

ChapterX.API/Controllers/ReadingListsController.cs

@@ -1 +1 @@
 using ChapterX.Application.ReadingList.Commands;
 using ChapterX.Application.ReadingList.Queries;
+using ChapterX.Domain.Repositories;
 using MediatR;
 using Microsoft.AspNetCore.Authorization;
@@ -13 +14 @@
     {
         private readonly IMediator _mediator;
+        private readonly IReadingListRepository _readingListRepository;
         private readonly ILogger<ReadingListsController> _logger;
 
-        public ReadingListsController(IMediator mediator, ILogger<ReadingListsController> logger)
+        public ReadingListsController(IMediator mediator, IReadingListRepository readingListRepository, ILogger<ReadingListsController> logger)
         {
             _mediator = mediator;
+            _readingListRepository = readingListRepository;
             _logger = logger;
+        }
+
+        [HttpGet("user/{userId:int}")]
+        [Authorize]
+        public async Task<ActionResult> GetByUser(int userId)
+        {
+            _logger.LogInformation("Fetching reading lists for user {UserId}", userId);
+            var lists = await _readingListRepository.GetByUserIdAsync(userId);
+            var result = lists.Select(l => MapList(l));
+            return Ok(result);
         }
 
@@ -26 +39 @@
         {
             _logger.LogInformation("Fetching all reading lists");
-            var response = await _mediator.Send(new GetAllRequest());
-            return Ok(response);
+            var lists = await _readingListRepository.GetAllAsync();
+            var result = lists.Select(l => MapList(l));
+            return Ok(result);
         }
+
+        private static object MapList(Domain.Entities.ReadingList l) => new
+        {
+            id = l.Id,
+            name = l.Name,
+            content = l.Content,
+            isPublic = l.IsPublic,
+            userId = l.UserId,
+            createdAt = l.CreatedAt,
+            username = l.User?.Username ?? "",
+            readingListItems = l.ReadingListItems.Select(i => new
+            {
+                listId = i.ListId,
+                storyId = i.StoryId,
+                addedAt = i.AddedAt,
+                storyTitle = i.Story?.ShortDescription ?? "",
+                authorUsername = i.Story?.Writer?.User?.Username ?? "",
+                genres = i.Story?.HasGenres.Select(hg => hg.Genre?.Name).Where(n => n != null).ToList() ?? []
+            }).ToList()
+        };
 
         [HttpGet("{id:int}")]