nice refactorings

PracticeCalendar.Application/ConfigureServices.cs

@@ -0,0 +1,18 @@
+using MapsterMapper;
+using MediatR;
+using Microsoft.Extensions.DependencyInjection;
+using System.Reflection;
+
+namespace PracticeCalendar.Application
+{
+    public static class ConfigureServices
+    {
+        public static IServiceCollection AddApplicationServices(this IServiceCollection services)
+        {
+            services.AddSingleton<IMapper>(new Mapper(new Mapster.TypeAdapterConfig()));
+            services.AddMediatR(Assembly.GetExecutingAssembly());
+
+            return services;
+        }
+    }
+}

PracticeCalendar.Application/PracticeCalendar.Application.csproj

@@ -11,11 +11,10 @@
   </ItemGroup>
 
   <ItemGroup>
-    <Folder Include="PracticeEvents\Commands\" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="6.0.0" />
+    <PackageReference Include="Mapster.DependencyInjection" Version="1.0.0" />
+    <PackageReference Include="MediatR.Extensions.Microsoft.DependencyInjection" Version="11.0.0" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="6.0.0" />
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" Version="6.0.2" />
   </ItemGroup>
 
 </Project>

PracticeCalendar.Application/PracticeEvents/Commands/AttendeeAcceptEventCommand.cs

@@ -0,0 +1,44 @@
+using MediatR;
+using PracticeCalendar.Domain.Common.Interfaces;
+using PracticeCalendar.Domain.Entities;
+using PracticeCalendar.Domain.Entities.Specifications;
+using PracticeCalendar.Domain.Exceptions;
+
+namespace PracticeCalendar.Application.PracticeEvents.Commands
+{
+    public record AttendeeAcceptEventCommand : IRequest
+    {
+        public AttendeeAcceptEventCommand(int eventId, int attendeeId)
+        {
+            EventId = eventId;
+            AttendeeId = attendeeId;
+        }
+
+        public int EventId { get; }
+        public int AttendeeId { get; }
+    }
+
+    public class AttendeeAcceptEventCommandHandler : IRequestHandler<AttendeeAcceptEventCommand>
+    {
+        private readonly IRepository<PracticeEvent> eventsRepo;
+
+        public AttendeeAcceptEventCommandHandler(IRepository<PracticeEvent> eventsRepo)
+        {
+            this.eventsRepo = eventsRepo;
+        }
+
+        public async Task<Unit> Handle(AttendeeAcceptEventCommand request, CancellationToken cancellationToken)
+        {
+            var spec = new PracticeEventByIdWithAttendees(request.EventId);
+            var practiceEvent = await eventsRepo.FirstOrDefaultAsync(spec, cancellationToken);
+            if (practiceEvent == null)
+            {
+                throw new PracticeEventNotFoundException();
+            }
+            practiceEvent.AttendeeAcceptEvent(request.AttendeeId);
+            await eventsRepo.SaveChangesAsync(cancellationToken);
+            
+            return Unit.Value;
+        }
+    }
+}

PracticeCalendar.Application/PracticeEvents/Commands/AttendeeDeclineEventCommand.cs

@@ -0,0 +1,43 @@
+using MediatR;
+using PracticeCalendar.Domain.Common.Interfaces;
+using PracticeCalendar.Domain.Entities;
+using PracticeCalendar.Domain.Entities.Specifications;
+using PracticeCalendar.Domain.Exceptions;
+
+namespace PracticeCalendar.Application.PracticeEvents.Commands
+{
+    public record AttendeeDeclineEventCommand : IRequest
+    {
+        public AttendeeDeclineEventCommand(int eventId, int attendeeId)
+        {
+            EventId = eventId;
+            AttendeeId = attendeeId;
+        }
+
+        public int EventId { get; }
+        public int AttendeeId { get; }
+    }
+
+    public class AttendeeDeclineEventCommandHandler : IRequestHandler<AttendeeDeclineEventCommand>
+    {
+        private readonly IRepository<PracticeEvent> eventsRepo;
+
+        public AttendeeDeclineEventCommandHandler(IRepository<PracticeEvent> eventsRepo)
+        {
+            this.eventsRepo = eventsRepo;
+        }
+
+        public async Task<Unit> Handle(AttendeeDeclineEventCommand request, CancellationToken cancellationToken)
+        {
+            var spec = new PracticeEventByIdWithAttendees(request.EventId);
+            var practiceEvent = await eventsRepo.FirstOrDefaultAsync(spec, cancellationToken);
+            if (practiceEvent == null)
+            {
+                throw new PracticeEventNotFoundException();
+            }
+            practiceEvent.AttendeeDeclineEvent(request.AttendeeId);
+            
+            return Unit.Value;
+        }
+    }
+}

PracticeCalendar.Application/PracticeEvents/Commands/CreatePracticeEventCommand.cs

@@ -0,0 +1,41 @@
+using Mapster;
+using MediatR;
+using PracticeCalendar.Application.PracticeEvents.Queries;
+using PracticeCalendar.Domain.Common.Interfaces;
+using PracticeCalendar.Domain.Entities;
+
+namespace PracticeCalendar.Application.PracticeEvents.Commands
+{
+    public record CreatePracticeEventCommand : IRequest<PracticeEventDto>
+    {
+        public CreatePracticeEventCommand(PracticeEventDto eventDto)
+        {
+            Event = eventDto;
+        }
+
+        public PracticeEventDto Event { get; }
+    }
+
+    public class CreatePracticeEventCommandHandler : IRequestHandler<CreatePracticeEventCommand, PracticeEventDto>
+    {
+        private readonly IRepository<PracticeEvent> eventsRepo;
+
+        public CreatePracticeEventCommandHandler(IRepository<PracticeEvent> eventsRepo)
+        {
+            this.eventsRepo = eventsRepo;
+        }
+
+        public async Task<PracticeEventDto> Handle(CreatePracticeEventCommand request, CancellationToken cancellationToken)
+        {
+            var input = request.Event;
+            var practiceEvent = new PracticeEvent(input.Title, input.Description);
+            foreach (var att in input.Attendees)
+            {
+                practiceEvent.AddAttendee(new Attendee(att.Name, att.EmailAddress));
+            }
+            var result = await eventsRepo.AddAsync(practiceEvent, cancellationToken);
+            await eventsRepo.SaveChangesAsync(cancellationToken);
+            return result.Adapt<PracticeEventDto>();
+        }
+    }
+}

PracticeCalendar.Application/PracticeEvents/Commands/DeletePracticeEventCommand.cs

@@ -0,0 +1,39 @@
+using MediatR;
+using PracticeCalendar.Domain.Common.Interfaces;
+using PracticeCalendar.Domain.Entities;
+using PracticeCalendar.Domain.Exceptions;
+
+namespace PracticeCalendar.Application.PracticeEvents.Commands
+{
+    public record DeletePracticeEventCommand : IRequest
+    {
+        public DeletePracticeEventCommand(int practiceEventId)
+        {
+            PracticeEventId = practiceEventId;
+        }
+
+        public int PracticeEventId { get; }
+    }
+    public class DeletePracticeEventCommandHandler : IRequestHandler<DeletePracticeEventCommand>
+    {
+        private readonly IRepository<PracticeEvent> eventsRepo;
+
+        public DeletePracticeEventCommandHandler(IRepository<PracticeEvent> eventsRepo)
+        {
+            this.eventsRepo = eventsRepo;
+        }
+
+        public async Task<Unit> Handle(DeletePracticeEventCommand request, CancellationToken cancellationToken)
+        {
+            var org = await eventsRepo.GetByIdAsync(request.PracticeEventId, cancellationToken);
+            if (org == null)
+            {
+                throw new PracticeEventNotFoundException();
+            }
+            await eventsRepo.DeleteAsync(org, cancellationToken);
+            await eventsRepo.SaveChangesAsync(cancellationToken);
+            
+            return Unit.Value;
+        }
+    }
+}

PracticeCalendar.Application/PracticeEvents/Commands/UpdatePracticeEventCommand.cs

@@ -0,0 +1,43 @@
+using Mapster;
+using MediatR;
+using PracticeCalendar.Application.PracticeEvents.Queries;
+using PracticeCalendar.Domain.Common.Interfaces;
+using PracticeCalendar.Domain.Entities;
+using PracticeCalendar.Domain.Exceptions;
+
+namespace PracticeCalendar.Application.PracticeEvents.Commands
+{
+    public record UpdatePracticeEventCommand : IRequest<PracticeEventDto>
+    {
+        public UpdatePracticeEventCommand(PracticeEventDto eventDto)
+        {
+            Event = eventDto;
+        }
+
+        public PracticeEventDto Event { get; }
+    }
+
+    public class UpdatePracticeEventCommandHandler : IRequestHandler<UpdatePracticeEventCommand, PracticeEventDto>
+    {
+        private readonly IRepository<PracticeEvent> eventsRepo;
+
+        public UpdatePracticeEventCommandHandler(IRepository<PracticeEvent> eventsRepo)
+        {
+            this.eventsRepo = eventsRepo;
+        }
+
+        public async Task<PracticeEventDto> Handle(UpdatePracticeEventCommand request, CancellationToken cancellationToken)
+        {
+            var eventModel = request.Event;
+            var practiceEvent = await eventsRepo.GetByIdAsync(eventModel.Id, cancellationToken);
+            if (practiceEvent == null)
+            {
+                throw new PracticeEventNotFoundException();
+            }
+            practiceEvent.UpdateTitleAndDescription(eventModel.Title, eventModel.Description);
+            await eventsRepo.UpdateAsync(practiceEvent, cancellationToken);
+            await eventsRepo.SaveChangesAsync(cancellationToken);
+            return practiceEvent.Adapt<PracticeEventDto>();
+        }
+    }
+}

PracticeCalendar.Application/PracticeEvents/Queries/AttendeeDto.cs

@@ -0,0 +1,10 @@
+namespace PracticeCalendar.Application.PracticeEvents.Queries
+{
+    public class AttendeeDto
+    {
+        public int Id { get; set; }
+        public string Name { get; set; } = string.Empty;
+        public string EmailAddress { get; set; } = string.Empty;
+        public bool IsAttending { get; set; }
+    }
+}

PracticeCalendar.Application/PracticeEvents/Queries/GetPracticeEvents/GetPracticeEventsQuery.cs

@@ -1,4 +1,6 @@
-using MediatR;
+using Mapster;
+using MapsterMapper;
+using MediatR;
 using Microsoft.Extensions.Logging;
 using PracticeCalendar.Domain.Common.Interfaces;
 using PracticeCalendar.Domain.Entities;
@@ -6,27 +8,31 @@ using PracticeCalendar.Domain.Entities.Specifications;
 
 namespace PracticeCalendar.Application.PracticeEvents.Queries.GetPracticeEvents
 {
-    public record class GetPracticeEventsQuery : IRequest<List<PracticeEvent>>
+    public record class GetPracticeEventsQuery : IRequest<List<PracticeEventDto>>
     {
     }
 
-    public class GetPracticeEventsQueryHandler : IRequestHandler<GetPracticeEventsQuery, List<PracticeEvent>>
+    public class GetPracticeEventsQueryHandler : IRequestHandler<GetPracticeEventsQuery, List<PracticeEventDto>>
     {
         private readonly ILogger<GetPracticeEventsQueryHandler> logger;
         private readonly IRepository<PracticeEvent> eventsRepo;
+        private readonly IMapper mapper;
 
-        public GetPracticeEventsQueryHandler(IRepository<PracticeEvent> eventsRepo, 
-            ILogger<GetPracticeEventsQueryHandler> logger)
+        public GetPracticeEventsQueryHandler(IRepository<PracticeEvent> eventsRepo,
+            ILogger<GetPracticeEventsQueryHandler> logger,
+            IMapper mapper)
         {
             this.eventsRepo = eventsRepo;
             this.logger = logger;
+            this.mapper = mapper;
         }
 
-        public async Task<List<PracticeEvent>> Handle(GetPracticeEventsQuery request, CancellationToken cancellationToken)
+        public async Task<List<PracticeEventDto>> Handle(GetPracticeEventsQuery request, CancellationToken cancellationToken)
         {
             var spec = new PracticeEventsWithAttendees();
-            var evList = await eventsRepo.ListAsync(spec);
-            return evList;
+            var evList = await eventsRepo.ListAsync(spec, cancellationToken);
+            var lst = evList.Adapt<List<PracticeEventDto>>(mapper.Config);
+            return lst;
         }
     }
 }

PracticeCalendar.Application/PracticeEvents/Queries/PracticeEventDto.cs

@@ -0,0 +1,14 @@
+namespace PracticeCalendar.Application.PracticeEvents.Queries
+{
+    public class PracticeEventDto
+    {
+        public int Id { get; set; }
+        public string Title { get; set; } = string.Empty;
+        public string Description { get; set; } = string.Empty;
+
+        public DateTime StartTime { get; set; }
+        public DateTime EndTime { get; set; }
+
+        public IList<AttendeeDto> Attendees { get; set; } = new List<AttendeeDto>();
+    }
+}