src/app/main/component/events/services/events.service.ts (1)

267-269: 🛠️ Refactor suggestion

Consider removing redundant method.

The postToggleLike method appears to be redundant with the new likeEvent method. Consider removing it or refactoring to use one consistent implementation.

src/app/main/component/events/models/events.interface.ts (1)

172-173: Consider making the dislikes property optional for backward compatibility.

The dislikes property should be marked as optional to maintain backward compatibility with existing event responses that may not include this field.

-  dislikes: number;
+  dislikes?: number;

src/app/main/component/events/services/events.service.ts (1)

46-48: Define a specific return type for the API response.

Using Observable<any> reduces type safety. Consider defining an interface for the API response.

-  likeEvent(eventId: number): Observable<any> {
+  interface LikeResponse {
+    success: boolean;
+    message?: string;
+  }
+  likeEvent(eventId: number): Observable<LikeResponse> {

src/app/main/component/shared/components/events-list-item/events-list-item.component.ts (1)

383-383: Standardize method naming convention.

The methods use inconsistent naming: likePost vs dislikePost. Consider renaming to likeEvent and dislikeEvent to match the service method names.

-  likePost() {
+  likeEvent() {
-  dislikePost() {
+  dislikeEvent() {

Also applies to: 396-396

src/app/main/component/events/components/events-list/events-list.component.ts (2)

142-164: Simplify reaction update logic.

The updateEventReaction method has complex nested conditions that could be simplified for better readability.

   private updateEventReaction(event: EventListResponse, reactionType: 'like' | 'dislike'): void {
     const i = this.eventsList.findIndex((e) => e.id === event.id);
     if (i !== -1) {
       const current = this.eventsList[i];
-      if (reactionType === 'like') {
-        if (!current.isLiked) {
-          current.likes++;
-          current.isLiked = true;
-          current.isDisliked = false;
-        }
-      } else {
-        if (current.isDisliked) {
-          current.isDisliked = false;
-        } else {
-          if (current.isLiked && current.likes > 0) {
-            current.likes--;
-            current.isLiked = false;
-          }
-          current.isDisliked = true;
-        }
-      }
+      switch (reactionType) {
+        case 'like':
+          if (!current.isLiked) {
+            current.likes++;
+            current.isLiked = true;
+            current.isDisliked = false;
+          }
+          break;
+        case 'dislike':
+          if (current.isLiked && current.likes > 0) {
+            current.likes--;
+            current.isLiked = false;
+          }
+          current.isDisliked = !current.isDisliked;
+          break;
+      }
     }
   }

---

114-119: Handle event not found case.

The refreshEventInList method should handle the case when the event is not found in the list.

   private refreshEventInList(updatedEvent: EventListResponse): void {
     const index = this.eventsList.findIndex((e) => e.id === updatedEvent.id);
-    if (index !== -1) {
-      this.eventsList[index] = updatedEvent;
-    }
+    if (index === -1) {
+      console.warn(`Event with ID ${updatedEvent.id} not found in the list`);
+      return;
+    }
+    this.eventsList[index] = updatedEvent;
   }

src/app/main/component/shared/components/events-list-item/events-list-item.component.scss (1)

18-20: Optimize icon rotation animation performance.

The rotation transform could benefit from hardware acceleration and smooth transitions.

Apply this diff to enhance the animation:

 .rotate-icon {
-  transform: rotate(180deg);
+  transform: rotate(180deg);
+  transform-style: preserve-3d;
+  backface-visibility: hidden;
+  transition: transform 0.2s ease;
+  will-change: transform;
 }

src/app/main/component/comments/components/comments-list/comments-list.component.scss (1)

163-173: Add interactive states and fix linting.

1. Add empty line before nested rule
2. Add hover and focus states for better user experience

 .comment-likes {
   display: flex;
   gap: 10px;
   align-items: center;
+
+  button {
+    padding: 8px;
+    border: none;
+    background: none;
+    cursor: pointer;
+
+    &:hover {
+      background-color: var(--quaternary-light-grey);
+      border-radius: 50%;
+    }
+
+    &:focus-visible {
+      outline: 2px solid var(--primary-color);
+      border-radius: 50%;
+    }
+
+    &.active {
+      color: var(--primary-color);
+    }
+  }
+
   .like-amount {
     font-family: var(--primary-font);
     font-size: 12px;

🧰 Tools

🪛 GitHub Actions: CI/CD GreenCityClient

[error] 167-167: Expected empty line before rule

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

src/app/main/component/events/services/events.service.ts (2)

50-60: 🛠️ Refactor suggestion

Remove debug logging and standardize error handling.

1. Remove console.log statements from production code.
2. Standardize error handling to match the likeEvent method.

Apply this diff:

-  dislikeEvent(eventId: number): Observable<any> {
-    return this.http.post<any>(`${this.backEnd}events/${eventId}/dislike`, {}).pipe(
-      tap((response: any) => {
-        console.log(`DISLIKE request successful. Response:`, response);
-      }),
-      catchError((error) => {
-        console.error(`DISLIKE request failed for event ID: ${eventId}`, error);
-        return throwError(error);
-      })
-    );
+  dislikeEvent(eventId: number): Observable<LikeResponse> {
+    return this.http.post<LikeResponse>(`${this.backEnd}events/${eventId}/dislike`, {}).pipe(
+      catchError((error) => throwError(error))
+    );

---

241-241: 🛠️ Refactor suggestion

Remove debug logging statement.

Remove the console.log statement from production code.

Apply this diff:

-    console.log(requestParams);

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

src/app/main/component/events/services/events.service.ts (2)

58-60: 🛠️ Refactor suggestion

Improve type safety and standardize error handling.

1. The response type any should be replaced with LikeResponse.
2. Error handling should be consistent with other methods.

Apply this diff:

-  dislikeEvent(eventId: number): Observable<any> {
-    return this.http.post<any>(`${this.backEnd}events/${eventId}/dislike`, {}).pipe(catchError((error) => throwError(error)));
+  dislikeEvent(eventId: number): Observable<LikeResponse> {
+    return this.http.post<LikeResponse>(`${this.backEnd}events/${eventId}/dislike`, {}).pipe(
+      catchError((error) => throwError(() => error))
+    );
   }

---

49-56: 🛠️ Refactor suggestion

Remove duplicate functionality and improve error handling.

1. This method duplicates the functionality of the existing postToggleLike method at line 265.
2. Error handling could be simplified by removing the console.error statement.

Apply this diff:

-  likeEvent(eventId: number): Observable<LikeResponse> {
-    return this.http.post<LikeResponse>(`${this.backEnd}events/${eventId}/like`, {}).pipe(
-      catchError((error) => {
-        console.error('Error liking event:', error);
-        return throwError(() => error);
-      })
-    );
-  }

And update the postToggleLike method to use the LikeResponse interface:

-  postToggleLike(eventId: number): Observable<any> {
+  postToggleLike(eventId: number): Observable<LikeResponse> {
-    return this.http.post(`${this.backEnd}events/${eventId}/like`, {});
+    return this.http.post<LikeResponse>(`${this.backEnd}events/${eventId}/like`, {}).pipe(
+      catchError((error) => throwError(() => error))
+    );
   }

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

src/app/main/component/eco-news/services/eco-news-comments.service.ts (1)

63-65: 🛠️ Refactor suggestion

Add error handling to postLike method for consistency.

The new postDislike method includes proper error handling, but it's missing in the postLike method. Let's maintain consistency across similar operations.

Apply this diff to add error handling:

   postLike(parentCommentId: number): Observable<void> {
-    return this.http.post<void>(`${this.backEnd}eco-news/comments/like?commentId=${parentCommentId}`, {});
+    return this.http.post<void>(`${this.backEnd}eco-news/comments/like?commentId=${parentCommentId}`, {}).pipe(
+      catchError((error) => {
+        console.error('Failed to post like:', error);
+        return throwError(() => error);
+      })
+    );
   }

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

src/app/main/component/events/services/events-comments.service.ts (1)

57-59: LGTM! The implementation follows established patterns.

The new postDislike method is well-implemented and maintains consistency with the existing postLike method. The implementation follows Angular's service patterns and properly handles HTTP requests.

Consider adding error handling to both postLike and postDislike methods to provide better feedback to the UI layer. For example:

 postDislike(commentId: number): Observable<void> {
-  return this.http.post<void>(`${this.backEnd}events/comments/dislike/${commentId}`, {});
+  return this.http.post<void>(`${this.backEnd}events/comments/dislike/${commentId}`, {}).pipe(
+    catchError((error) => {
+      console.error('Error disliking comment:', error);
+      throw error;
+    })
+  );
 }

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

src/assets/mocks/events/mock-events.ts (2)

243-243: Remove unnecessary inline comment.

The comment "// Added this property" is redundant and inconsistent with the rest of the file's style.

-    dislikes: 2,  // Added this property
+    dislikes: 2,

---

183-183: Consider adding more diverse test cases.

While the current mock data provides basic test cases for the dislikes feature, consider adding edge cases such as:

• Zero dislikes
• Very large numbers
• Cases where dislikes > likes

Also applies to: 243-243, 296-296, 358-358, 515-515

src/app/main/service/habit-comments/habit-comments.service.ts (1)

34-36: Consider adding error handling and type safety.

To improve robustness and maintainability:

1. Add retry logic for network failures
2. Add rate limiting to prevent spam
3. Define an interface for the response type

Example implementation:

interface DislikeResponse {
  success: boolean;
  message?: string;
}

postDislike(parentCommentId: number): Observable<DislikeResponse> {
  return this.http
    .post<DislikeResponse>(
      `${this.backEnd}habits/comments/dislike?commentId=${parentCommentId}`,
      {}
    )
    .pipe(
      retry(3),
      throttleTime(1000)
    );
}

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

src/app/main/service/localstorage/local-storage.service.spec.ts (2)

13-59: LGTM! Consider adding test cases for social interaction metrics.

The mock event object has been properly updated to include likes, dislikes, and comment counts, which aligns with the PR objectives. However, since these are new fields being added, it would be beneficial to add specific test cases that verify the handling of these social interaction metrics.

Consider adding test cases like:

it('should handle event social metrics correctly', () => {
  const eventWithMetrics = { ...mockEvent };
  service.setEventForEdit('testKey', eventWithMetrics);
  const savedEvent = JSON.parse(localStorage.getItem('testKey'));
  expect(savedEvent.likes).toBe(5);
  expect(savedEvent.dislikes).toBe(2);
  expect(savedEvent.countComments).toBe(7);
});

---

613-617: Enhance test coverage for event storage.

While the test verifies basic storage functionality, it could be improved to ensure type safety and deep object equality.

Consider enhancing the test:

it('should correctly store and retrieve the event with all properties', () => {
  const key = 'testKey';
  service.setEventForEdit(key, mockEvent);
  
  // Get and parse the stored event
  const storedEvent: EventResponse = JSON.parse(localStorage.getItem(key));
  
  // Verify type safety and deep equality
  expect(storedEvent).toBeTruthy();
  expect(storedEvent.likes).toBe(mockEvent.likes);
  expect(storedEvent.dislikes).toBe(mockEvent.dislikes);
  expect(storedEvent.countComments).toBe(mockEvent.countComments);
  expect(storedEvent.tags).toEqual(mockEvent.tags);
  expect(storedEvent.dates[0].coordinates).toEqual(mockEvent.dates[0].coordinates);
});

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

src/app/main/component/comments/components/comments-list/comments-list.component.spec.ts (1)

14-16: LGTM! Consider organizing imports.

The new imports and module setup are comprehensive and align well with the component's functionality.

Consider organizing imports by category (Angular core, Material, shared components, models) for better maintainability:

- import { WarningPopUpComponent } from '@shared/components';
- import { AddedCommentDTO } from '../../models/comments-model';
- import { MatSnackBarModule } from '@angular/material/snack-bar';
+ // Angular Material
+ import { MatSnackBarModule } from '@angular/material/snack-bar';
+ 
+ // Shared Components
+ import { WarningPopUpComponent } from '@shared/components';
+ 
+ // Models
+ import { AddedCommentDTO } from '../../models/comments-model';

Also applies to: 77-84

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

src/app/main/component/comments/components/comments-list/comments-list.component.spec.ts (1)

22-50: 🛠️ Refactor suggestion

Add tests for like/dislike functionality.

The new like/dislike methods need test coverage. Add the following to the service mock:

 const commentsServiceMock: any = {
   editComment: jasmine.createSpy('editComment').and.returnValue(of()),
+  postLike: jasmine.createSpy('postLike').and.returnValue(of()),
+  postDislike: jasmine.createSpy('postDislike').and.returnValue(of()),
   getActiveRepliesByPage: jasmine.createSpy('getActiveRepliesByPage').and.returnValue(
     // ... existing mock implementation
   )
 };

And add these test cases:

it('should handle successful like action', () => {
  const commentId = 1;
  component.likeComment(commentId);
  expect(commentsServiceMock.postLike).toHaveBeenCalledWith(commentId);
});

it('should handle successful dislike action', () => {
  const commentId = 1;
  component.dislikeComment(commentId);
  expect(commentsServiceMock.postDislike).toHaveBeenCalledWith(commentId);
});

it('should prevent concurrent like/dislike requests', () => {
  const commentId = 1;
  component.likeComment(commentId);
  component.likeComment(commentId);
  expect(commentsServiceMock.postLike).toHaveBeenCalledTimes(1);
});

src/app/main/component/comments/components/comments-list/comments-list.component.ts (2)

81-88: Consider enhancing updateLikeDislikeCount with additional safeguards.

The method could be more robust by:

1. Adding type safety for the comment object
2. Adding validation for negative counts

-  private updateLikeDislikeCount(commentId: number, type: ReactionType, isAdd: boolean): void {
+  private updateLikeDislikeCount(commentId: number, type: ReactionType, isAdd: boolean): void {
+    if (!commentId || !type) {
+      console.warn('Invalid parameters passed to updateLikeDislikeCount');
+      return;
+    }
     this.elementsList = this.elementsList.map((comment) => {
       if (comment?.id === commentId) {
-        comment[type] = Math.max(0, comment[type] + (isAdd ? 1 : -1));
+        const currentCount = comment[type] || 0;
+        comment[type] = Math.max(0, currentCount + (isAdd ? 1 : -1));
       }
       return comment;
     });
   }

---

90-116: Improve user feedback messages for better UX.

The success and error messages could be more user-friendly and specific.

-          this.snackBar.open('Comment liked successfully', 'Close', {
+          this.snackBar.open('Thanks for liking this comment!', 'Dismiss', {
             duration: 3000
           });
-          this.snackBar.open('Failed to like the comment. Please try again.', 'Close', {
+          this.snackBar.open('Unable to like the comment. Please try again later.', 'Dismiss', {

-          this.snackBar.open('Comment disliked successfully', 'Close', {
+          this.snackBar.open('Your feedback has been recorded', 'Dismiss', {
             duration: 3000
           });
-          this.snackBar.open('Failed to dislike the comment. Please try again.', 'Close', {
+          this.snackBar.open('Unable to record your feedback. Please try again later.', 'Dismiss', {

Also applies to: 118-144

src/app/main/component/comments/components/comments-list/comments-list.component.spec.ts (1)

108-110: Fix typos in test descriptions and improve clarity.

Several test descriptions contain typos and are unclear:

• 'return the created componennt' → 'should create the component'
• 'inititilez preperties' → 'should initialize properties'

Also applies to: 112-118

src/app/main/component/events/components/events-list/events-list.component.ts (1)

141-163: Add error handling for edge cases in updateEventReaction.

The updateEventReaction method should handle edge cases where:

1. The likes count might go negative
2. The event might not be found in the list

 private updateEventReaction(event: EventListResponse, reactionType: 'like' | 'dislike'): void {
   const i = this.eventsList.findIndex((e) => e.id === event.id);
   if (i !== -1) {
     const current = this.eventsList[i];
     if (reactionType === 'like') {
       if (!current.isLiked) {
         current.likes++;
         current.isLiked = true;
         current.isDisliked = false;
       }
     } else {
       if (current.isDisliked) {
         current.isDisliked = false;
       } else {
-        if (current.isLiked && current.likes > 0) {
+        if (current.isLiked) {
           current.likes--;
           current.isLiked = false;
         }
         current.isDisliked = true;
       }
     }
+  } else {
+    this.toastr.error('Event not found in the list');
   }
 }

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

src/app/main/component/comments/models/comments-model.ts (1)

15-15: Consider consolidating like-related properties.

The interface has both currentUserLiked and isLiked properties which appear to serve the same purpose. Consider consolidating these properties to maintain a single source of truth and consistent naming:

-  currentUserLiked: boolean;
-  isLiked: boolean;
-  isDisliked: boolean;
+  reactionStatus: {
+    isLiked: boolean;
+    isDisliked: boolean;
+  };

Also applies to: 18-19

src/app/main/component/comments/components/comments-list/comments-list.component.ts (1)

27-27: Remove redundant processing state properties.

The isProcessingLike and isProcessingDislike properties are redundant since you're already using the isProcessing Set to track the processing state per comment.

  private isProcessing = new Set<number>();
- private isProcessingLike = false;
- private isProcessingDislike = false;

Also applies to: 56-57

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

src/app/greencity/modules/events/services/events-comments.service.ts (1)

57-59: Inconsistent parameter naming and missing error handling.

The postDislike method uses commentId as parameter name while related methods like postLike use parentCommentId. For consistency, consider using the same parameter name. Also, unlike the similar methods in EventsService, there's no error handling here.

-  postDislike(commentId: number): Observable<void> {
-    return this.http.post<void>(`${this.backEnd}events/comments/dislike/${commentId}`, {});
+  postDislike(parentCommentId: number): Observable<void> {
+    return this.http.post<void>(`${this.backEnd}events/comments/dislike/${parentCommentId}`, {})
+      .pipe(
+        catchError((error) => {
+          console.error('Error disliking comment:', error);
+          return throwError(() => error);
+        })
+      );

Don't forget to add the necessary imports:

import { catchError } from 'rxjs/operators';
import { throwError } from 'rxjs';

src/app/greencity/modules/events/services/events.service.ts (1)

168-170: Inconsistent error handling and return type.

The dislikeEvent method has a different error handling style and return type compared to likeEvent. For consistency, consider:

1. Using the same error handling pattern (with or without logging)
2. Using the same return type (LikeResponse instead of any)

-  dislikeEvent(eventId: number): Observable<any> {
-    return this.http.post<any>(`${this.backEnd}events/${eventId}/dislike`, {}).pipe(catchError((error) => throwError(() => error)));
+  dislikeEvent(eventId: number): Observable<LikeResponse> {
+    return this.http.post<LikeResponse>(`${this.backEnd}events/${eventId}/dislike`, {}).pipe(
+      catchError((error) => {
+        console.error('Error disliking event:', error);
+        return throwError(() => error);
+      })
+    );

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

src/app/greencity/shared/components/events-list-item/events-list-item.component.scss (1)

22-26: Style Update: Border Removal on #like and #dislike
Removing the border from the #like and #dislike elements aligns with the desired UI adjustments for the new like/dislike indicators. As a minor suggestion, consider whether using ID selectors is optimal for styling or if a class-based approach might offer more flexibility in the future.

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

src/app/greencity/modules/events/services/events.service.ts (1)

159-166: ⚠️ Potential issue

Action Required: Consolidate Duplicate "Like" Methods

The new implementation of likeEvent overlaps significantly with the existing postToggleLike method (line 129). Both methods target similar endpoints (events/${eventId}/like-v2 vs events/${eventId}/like) and perform very similar operations, with the main differences being additional error handling and response typing in likeEvent.

Consider:

1. Consolidating these methods by enhancing postToggleLike with better typing and error handling
2. Deprecating the old method if the new one should be used going forward
3. Adding clear documentation to explain the difference between these methods

postToggleLike(eventId: number): Observable<LikeResponse> {
-  return this.http.post(`${this.backEnd}events/${eventId}/like`, {});
+  return this.http.post<LikeResponse>(`${this.backEnd}events/${eventId}/like-v2`, {}).pipe(
+    catchError((error) => {
+      console.error('Error liking event:', error);
+      return throwError(() => error);
+    })
+  );
}

// Remove this duplicate method
-likeEvent(eventId: number): Observable<LikeResponse> {
-  return this.http.post<LikeResponse>(`${this.backEnd}events/${eventId}/like-v2`, {}).pipe(
-    catchError((error) => {
-      console.error('Error liking event:', error);
-      return throwError(() => error);
-    })
-  );
-}

src/app/greencity/modules/events/services/events.service.ts (2)

4-4: Consider organizing related imports together.

While the new imports are necessary for the added functionality, they could be organized more consistently. Consider grouping related imports together - RxJS operators (catchError) could be included in the existing RxJS imports, and model-related imports (LikeResponse) could be grouped with other model imports.

 import { HttpClient, HttpParams } from '@angular/common/http';
 import { Injectable, OnDestroy } from '@angular/core';
 import { environment } from '@environment/environment';
-import { Observable, ReplaySubject, throwError } from 'rxjs';
+import { Observable, ReplaySubject } from 'rxjs';
+import { throwError } from 'rxjs';
 import {
   Addresses,
   EventAttender,
   EventForm,
   EventResponse,
   EventResponseDto,
   LocationResponse,
   EventDto,
   PlaceOnline
-} from '../models/events.interface';
+} from '../models/events.interface';
+import { LikeResponse } from './LikeResponse';
 import { LanguageService } from 'src/app/shared/i18n/language.service';
-import { catchError } from 'rxjs/operators';
-import { LikeResponse } from './LikeResponse';
+import { catchError } from 'rxjs/operators';

Also applies to: 16-16, 17-17

---

159-170: Document the differences between like/dislike methods and their corresponding endpoints.

Adding clear documentation comments for the new methods would help explain:

1. The purpose of the new -v2 endpoints compared to existing ones
2. The relationship between the new methods and the existing postToggleLike method
3. When developers should use each method

/**
 * Likes an event using the v2 endpoint.
 * @param eventId - The ID of the event to like
 * @returns An Observable containing the like response with ID and liked status
 * @see postToggleLike - Legacy method for toggling likes
 */
likeEvent(eventId: number): Observable<LikeResponse> {
  return this.http.post<LikeResponse>(`${this.backEnd}events/${eventId}/like-v2`, {}).pipe(
    catchError((error) => {
      console.error('Error liking event:', error);
      return throwError(() => error);
    })
  );
}

/**
 * Dislikes an event using the v2 endpoint.
 * @param eventId - The ID of the event to dislike
 * @returns An Observable containing the like response
 */
dislikeEvent(eventId: number): Observable<any> {
  return this.http.post<any>(`${this.backEnd}events/${eventId}/dislike-v2`, {}).pipe(catchError((error) => throwError(() => error)));
}

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

src/app/greencity/shared/components/events-list-item/events-list-item.component.ts (1)

338-354: Improved likePost implementation with proper response handling

The updated likePost method now properly handles both successful (200) and "reset" (204) responses, updating the event object's like/dislike properties accordingly. Good error handling is also included.

However, there's a minor inconsistency in the error message:

- (error) => console.error('Error in likeEvent:', error)
+ (error) => console.error('Error in likePost:', error)

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

src/app/greencity/modules/user/services/habit-comments/habit-comments.service.ts (1)

8-8: ⚠️ Potential issue

Update required for CommentsDTO import.

The file needs to import CommentsDTO from the comments-model to match the interface requirements defined in CommentsService.

-import { AddedCommentDTO, CommentFormData, CommentsModel } from 'src/app/greencity/modules/comments/models/comments-model';
+import { AddedCommentDTO, CommentFormData, CommentsDTO, CommentsModel } from 'src/app/greencity/modules/comments/models/comments-model';

src/app/greencity/modules/eco-news/services/eco-news-comments.service.ts (1)

63-65: New postLikeV2 method looks good, but consider removing old postDislike method.

The new postLikeV2 method correctly returns an Observable instead of Observable, allowing components to update with the latest comment data immediately after a like action. However, while you've added this new method, the old postDislike method (lines 25-32) still exists in the file, which could lead to confusion for developers.

Consider removing the old postDislike method since it's being replaced by postDislikeV2.

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

src/app/greencity/shared/components/events-list-item/events-list-item.component.html (1)

105-105: Clarify Computation of Net Likes Inline

The updated <span> now displays the net likes by subtracting event.dislikes from event.likes. While this inline calculation is concise, consider handling potential edge cases (such as one of the values being null or undefined) using either a safe navigation approach or by computing the net likes within the component class. This would improve clarity and maintainability of the template code.

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro