♻️refactor: refactor service interfaces to separate paged and unpaged methods

- Split methods returning paged results and unpaged lists in Event, Organizer, Participant, and Speaker services and interfaces.
- Added new methods for unpaged retrieval and renamed paged methods for clarity.
- This improves API clarity and flexibility for consumers.

Author: alysonsz

EventFlow.Application/Services/EventService.cs

@@ -13,9 +13,15 @@ public class EventService(IEventRepository repository, IMapper mapper) : IEventS
             mapper.Map<EventDTO>(entity);
     }
 
-    public async Task<PagedResult<EventDTO>> GetAllEventsAsync(QueryParameters queryParameters)
+    public async Task<List<EventDTO>> GetAllEventsAsync()
     {
-        var pagedEvents = await repository.GetAllEventsAsync(queryParameters);
+        var events = await repository.GetAllEventsAsync();
+        return mapper.Map<List<EventDTO>>(events);
+    }
+
+    public async Task<PagedResult<EventDTO>> GetAllPagedEventsAsync(QueryParameters queryParameters)
+    {
+        var pagedEvents = await repository.GetAllPagedEventsAsync(queryParameters);
 
         var eventDtos = mapper.Map<List<EventDTO>>(pagedEvents.Items);
 

EventFlow.Application/Services/OrganizerService.cs

@@ -12,9 +12,15 @@ public class OrganizerService(IOrganizerRepository repository, IEventRepository
             mapper.Map<OrganizerDTO>(entity);
     }
 
-    public async Task<PagedResult<OrganizerDTO>> GetAllOrganizersAsync(QueryParameters queryParameters)
+    public async Task<List<OrganizerDTO>> GetAllOrganizersAsync()
     {
-        var pagedOrganizers = await repository.GetAllOrganizersAsync(queryParameters);
+        var organizers = await repository.GetAllOrganizersAsync();
+        return mapper.Map<List<OrganizerDTO>>(organizers);
+    }
+
+    public async Task<PagedResult<OrganizerDTO>> GetAllPagedOrganizersAsync(QueryParameters queryParameters)
+    {
+        var pagedOrganizers = await repository.GetAllPagedOrganizersAsync(queryParameters);
 
         var organizerDtos = mapper.Map<List<OrganizerDTO>>(pagedOrganizers.Items);
 

EventFlow.Application/Services/ParticipantService.cs

@@ -11,9 +11,9 @@ public class ParticipantService(IParticipantRepository repository, IEventReposit
             null : mapper.Map<ParticipantDTO>(entity);
     }
 
-    public async Task<PagedResult<ParticipantDTO>> GetAllParticipantsByEventIdAsync(int eventId, QueryParameters queryParameters)
+    public async Task<PagedResult<ParticipantDTO>> GetAllPagedParticipantsByEventIdAsync(int eventId, QueryParameters queryParameters)
     {
-        var pagedParticipants = await repository.GetAllParticipantsByEventIdAsync(eventId, queryParameters);
+        var pagedParticipants = await repository.GetAllPagedParticipantsByEventIdAsync(eventId, queryParameters);
 
         var participantDtos = mapper.Map<List<ParticipantDTO>>(pagedParticipants.Items);
 
@@ -71,4 +71,10 @@ public async Task<bool> DeleteAsync(int id)
         var deleted = await repository.DeleteAsync(id);
         return deleted > 0;
     }
+
+    public async Task<List<ParticipantDTO>> GetAllParticipantsWithEventsAsync()
+    {
+        var allParticipants = await repository.GetAllParticipantsWithEventsAsync();
+        return mapper.Map<List<ParticipantDTO>>(allParticipants);
+    }
 }

EventFlow.Application/Services/SpeakerService.cs

@@ -12,10 +12,15 @@ public class SpeakerService(ISpeakerRepository repository, IEventRepository even
             mapper.Map<SpeakerDTO>(entity);
     }
 
+    public async Task<List<SpeakerDTO>> GetAllSpeakersAsync()
+    {
+        var speakers = await repository.GetAllSpeakersAsync();
+        return mapper.Map<List<SpeakerDTO>>(speakers);
+    }
 
-    public async Task<PagedResult<SpeakerDTO>> GetAllSpeakersAsync(QueryParameters queryParameters)
+    public async Task<PagedResult<SpeakerDTO>> GetAllPagedSpeakersAsync(QueryParameters queryParameters)
     {
-        var pagedSpeakers = await repository.GetAllSpeakersAsync(queryParameters);
+        var pagedSpeakers = await repository.GetAllPagedSpeakersAsync(queryParameters);
 
         var speakerDtos = mapper.Map<List<SpeakerDTO>>(pagedSpeakers.Items);
 

EventFlow.Core/Services/Interfaces/IEventService.cs

@@ -3,7 +3,8 @@
 public interface IEventService
 {
     Task<EventDTO?> GetByIdAsync(int id);
-    Task<PagedResult<EventDTO>> GetAllEventsAsync(QueryParameters queryParameters);
+    Task<List<EventDTO>> GetAllEventsAsync();
+    Task<PagedResult<EventDTO>> GetAllPagedEventsAsync(QueryParameters queryParameters);
     Task<Event?> CreateAsync(EventCommand command);
     Task<EventDTO?> UpdateAsync(int id, EventCommand command);
     Task<bool> DeleteAsync(int id);

EventFlow.Core/Services/Interfaces/IOrganizerService.cs

@@ -3,7 +3,8 @@
 public interface IOrganizerService
 {
     Task<OrganizerDTO?> GetByIdAsync(int id);
-    Task<PagedResult<OrganizerDTO>> GetAllOrganizersAsync(QueryParameters queryParameters);
+    Task<List<OrganizerDTO>> GetAllOrganizersAsync();
+    Task<PagedResult<OrganizerDTO>> GetAllPagedOrganizersAsync(QueryParameters queryParameters);
     Task<Organizer?> CreateAsync(OrganizerCommand command);
     Task<bool> RegisterToEventAsync(int eventId, int organizerId);
     Task<OrganizerDTO?> UpdateAsync(int id, OrganizerCommand command);

EventFlow.Core/Services/Interfaces/IParticipantService.cs

@@ -3,9 +3,10 @@
 public interface IParticipantService
 {
     Task<ParticipantDTO?> GetByIdAsync(int id);
-    Task<PagedResult<ParticipantDTO>> GetAllParticipantsByEventIdAsync(int eventId, QueryParameters queryParameters);
+    Task<PagedResult<ParticipantDTO>> GetAllPagedParticipantsByEventIdAsync(int eventId, QueryParameters queryParameters);
     Task<Participant?> CreateAsync(ParticipantCommand command);
     Task<bool> RegisterToEventAsync(int eventId, int participantId);
     Task<ParticipantDTO?> UpdateAsync(int id, ParticipantCommand command);
+    Task<List<ParticipantDTO>> GetAllParticipantsWithEventsAsync();
     Task<bool> DeleteAsync(int id);
 }

EventFlow.Core/Services/Interfaces/ISpeakerService.cs

@@ -3,7 +3,8 @@
 public interface ISpeakerService
 {
     Task<SpeakerDTO?> GetByIdAsync(int id);
-    Task<PagedResult<SpeakerDTO>> GetAllSpeakersAsync(QueryParameters queryParameters);
+    Task<List<SpeakerDTO>> GetAllSpeakersAsync();
+    Task<PagedResult<SpeakerDTO>> GetAllPagedSpeakersAsync(QueryParameters queryParameters);
     Task<Speaker?> CreateAsync(SpeakerCommand command);
     Task<bool> RegisterToEventAsync(int eventId, int speakerId);
     Task<SpeakerDTO?> UpdateAsync(int id, SpeakerCommand command);