Dev

Application/Commands/CancelPlayOfferCommand.cs

@@ -2,6 +2,6 @@
 
 namespace PlayOfferService.Application.Commands;
 
-public record CancelPlayOfferCommand(Guid PlayOfferId) : IRequest<Task>
+public record CancelPlayOfferCommand(Guid PlayOfferId, Guid MemberId) : IRequest<Task>
 {
 }

Application/Commands/CreatePlayOfferCommand.cs

@@ -2,6 +2,6 @@
 using PlayOfferService.Domain.Models;
 
 namespace PlayOfferService.Application.Commands;
-public record CreatePlayOfferCommand(PlayOfferDto PlayOfferDto) : IRequest<Guid>
+public record CreatePlayOfferCommand(CreatePlayOfferDto CreatePlayOfferDto, Guid CreatorId, Guid ClubId) : IRequest<Guid>
 {
 }

Application/Commands/JoinPlayOfferCommand.cs

@@ -2,6 +2,6 @@
 using PlayOfferService.Domain.Models;
 
 namespace PlayOfferService.Application.Commands;
-public record JoinPlayOfferCommand(JoinPlayOfferDto JoinPlayOfferDto) : IRequest<Task>
+public record JoinPlayOfferCommand(JoinPlayOfferDto JoinPlayOfferDto, Guid MemberId) : IRequest<Task>
 {
 }

Application/Controllers/PlayOfferController.cs

@@ -1,13 +1,16 @@
+using System.Security.Claims;
 using MediatR;
+using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
 using PlayOfferService.Application.Commands;
+using PlayOfferService.Application.Exceptions;
 using PlayOfferService.Application.Queries;
 using PlayOfferService.Domain.Models;
 
 namespace PlayOfferService.Application.Controllers;
 
 [ApiController]
-[Route("api")]
+[Route("api/playoffers")]
 public class PlayOfferController : ControllerBase
 {
 
@@ -18,49 +21,114 @@
         _mediator = mediator;
     }
 
+    /// <summary>
+    /// Retrieve all Play Offers of the logged in users club
+    /// </summary>
+    /// <returns>Play offers with a matching club id</returns>
+    /// <response code="200">Returns a list of Play offers matching the query params</response>
+    /// <response code="204">No Play offer with matching properties was found</response>
+    [HttpGet]
+    [Authorize]
+    [Route("club")]
+    [ProducesResponseType(typeof(IEnumerable<PlayOfferDto>), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ActionResult), StatusCodes.Status204NoContent)]
+    [Consumes("application/json")]
+    [Produces("application/json")]
+    public async Task<ActionResult<IEnumerable<PlayOfferDto>>> GetByClubIdAsync()
+    {
+        var clubId = Guid.Parse(User.Claims.First(c => c.Type == "tennisClubId").Value);
+        var result = await _mediator.Send(new GetPlayOffersByClubIdQuery(clubId));
+
+        if (result.Count() == 0)
+            return NoContent();
+
+        return Ok(result);
+    }
+
     ///<summary>
-    ///Retrieve all Play Offers matching the query params
+    ///Retrieve all Play Offers of a logged in user
     ///</summary>
-    ///<param name="playOfferId">The id of the play offer</param>
-    ///<param name="creatorId">The id of the creator of the play offer</param>
-    ///<param name="clubId">The id of the club of the play offer</param>
-    ///<returns>Play offer with a matching id</returns>
-    ///<response code="200">Returns a Play offer matching the query params</response>
+    ///<returns>List of Play offers with where given member is creator or opponent</returns>
+    ///<response code="200">Returns a list of Play offers matching the query params</response>
     ///<response code="204">No Play offer with matching properties was found</response>
     [HttpGet]
+    [Authorize]
+    [Route("participant")]
+    [ProducesResponseType(typeof(IEnumerable<PlayOffer>), StatusCodes.Status200OK)]
+    [ProducesResponseType(typeof(ActionResult), StatusCodes.Status204NoContent)]
+    [Consumes("application/json")]
+    [Produces("application/json")]
+    public async Task<ActionResult<IEnumerable<PlayOfferDto>>> GetByParticipantIdAsync()
+    {
+        var participantId = Guid.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
+        var result = await _mediator.Send(new GetPlayOffersByParticipantIdQuery(participantId));
+
+        if (result.Count() == 0)
+            return NoContent();
+
+        return Ok(result);
+    }
+
+    ///<summary>
+    ///Get all Play offers created by a member with a matching name
+    ///</summary>
+    ///<param name="creatorName">Name of the creator in the format '[FirstName] [LastName]', '[FirstName]' or '[LastName]'</param>
+    ///<returns>A list of Play offers with a matching id</returns>
+    ///<response code="200">Returns a List of Play offers with creator matching the query params</response>
+    ///<response code="204">No Play offers with matching creator was found</response>
+    [HttpGet]
+    [Authorize]
+    [Route("search")]
     [ProducesResponseType(typeof(IEnumerable<PlayOffer>), StatusCodes.Status200OK)]
     [ProducesResponseType(typeof(ActionResult), StatusCodes.Status204NoContent)]
     [Consumes("application/json")]
     [Produces("application/json")]
-    public async Task<ActionResult<IEnumerable<PlayOffer>>> GetByIdAsync([FromQuery] Guid? playOfferId, [FromQuery] Guid? creatorId, [FromQuery] Guid? clubId)
+    public async Task<ActionResult<IEnumerable<PlayOfferDto>>> GetByCreatorNameAsync([FromQuery] string creatorName)
     {
-        var result = await _mediator.Send(new GetPlayOffersByIdQuery(playOfferId, creatorId, clubId));
+        IEnumerable<PlayOfferDto> result;
+        try
+        {
+            result = await _mediator.Send(new GetPlayOffersByCreatorNameQuery(creatorName));
+        }
+        catch (Exception e)
+        {
+            return BadRequest(e.Message);
+        }
 
         if (result.Count() == 0)
             return NoContent();
 
         return Ok(result);
     }
+
 
 
     ///<summary>
-    ///Create a new Play Offer
+    ///Create a new Play Offer for the logged in user
     ///</summary>
-    ///<param name="playOfferDto">The Play Offer to create</param>
+    ///<param name="createPlayOfferDto">The Play Offer to create</param>
     ///<returns>The newly created Play offer</returns>
     ///<response code="200">Returns the id of the created Play Offer</response>
     ///<response code="400">Invalid Play Offer structure</response>
+    ///<response code="401">Only members can create Play Offers</response>
     [HttpPost]
+    [Authorize]
     [ProducesResponseType(typeof(PlayOffer), StatusCodes.Status201Created)]
     [ProducesResponseType(typeof(ActionResult), StatusCodes.Status400BadRequest)]
     [Consumes("application/json")]
     [Produces("application/json")]
-    public async Task<ActionResult<PlayOffer>> Create(PlayOfferDto playOfferDto)
+    public async Task<ActionResult<PlayOffer>> Create(CreatePlayOfferDto createPlayOfferDto)
     {
+        if (User.Claims.First(c => c.Type == "groups").Value != "MEMBER")
+            return Unauthorized("Only members can create Play Offers!");
+
+        var creatorId = Guid.Parse(User.FindFirst(ClaimTypes.NameIdentifier)!.Value);
+        var clubId = Guid.Parse(User.FindFirst("tennisClubId")!.Value);
+
         Guid result;
         try
         {
-            result = await _mediator.Send(new CreatePlayOfferCommand(playOfferDto));
+            result = await _mediator.Send(new CreatePlayOfferCommand(createPlayOfferDto, creatorId, clubId));
         }
         catch (Exception e)
         {
@@ -71,22 +139,33 @@
     }
 
     ///<summary>
-    ///Cancels a Play Offer with a matching id
+    ///Cancels a Play Offer with a matching id of the logged in user
     ///</summary>
     ///<param name="playOfferId">The id of the Play Offer to cancel</param>
     ///<returns>Nothing</returns>
     ///<response code="200">The Play Offer with the matching id was cancelled</response>
     ///<response code="400">No Play Offer with matching id found</response>
+    ///<response code="401">Only creator can cancel Play Offers</response>
     [HttpDelete]
+    [Authorize]
     [ProducesResponseType(typeof(ActionResult), StatusCodes.Status200OK)]
     [ProducesResponseType(typeof(ActionResult), StatusCodes.Status400BadRequest)]
     [Consumes("application/json")]
     [Produces("application/json")]
     public async Task<ActionResult> Delete(Guid playOfferId)
     {
+        if (User.Claims.First(c => c.Type == "groups").Value != "MEMBER")
+            return Unauthorized("Only members can cancel Play Offers!");
+
+        var memberId = Guid.Parse(User.FindFirst(ClaimTypes.NameIdentifier)!.Value);
+
         try
         {
-            await _mediator.Send(new CancelPlayOfferCommand(playOfferId));
+            await _mediator.Send(new CancelPlayOfferCommand(playOfferId, memberId));
+        }
+        catch (AuthorizationException e)
+        {
+            return Unauthorized(e.Message);
         }
         catch (Exception e)
         {
@@ -97,23 +176,29 @@
     }
 
     ///<summary>
-    ///Adds a given opponentId to a Play Offer and creates a reservation
+    ///Logged in user joins a Play Offer with a matching playOfferId
     ///</summary>
     ///<param name="joinPlayOfferDto">The opponentId to add to the Play Offer with the matching playOfferId</param>
     ///<returns>Nothing</returns>
     ///<response code="200">The opponentId was added to the Play Offer with the matching playOfferId</response>
     ///<response code="400">No playOffer with a matching playOfferId found</response>
+    ///<response code="401">Only members can join Play Offers</response>
     [HttpPost]
-    [Route("/join")]
+    [Authorize]
+    [Route("join")]
     [ProducesResponseType(typeof(ActionResult), StatusCodes.Status200OK)]
     [ProducesResponseType(typeof(ActionResult), StatusCodes.Status400BadRequest)]
     [Consumes("application/json")]
     [Produces("application/json")]
     public async Task<ActionResult> Join(JoinPlayOfferDto joinPlayOfferDto)
     {
+        if (User.Claims.First(c => c.Type == "groups").Value != "MEMBER")
+            return Unauthorized("Only members can join Play Offers!");
+
+        var memberId = Guid.Parse(User.FindFirst(ClaimTypes.NameIdentifier)!.Value);
         try
         {
-            await _mediator.Send(new JoinPlayOfferCommand(joinPlayOfferDto));
+            await _mediator.Send(new JoinPlayOfferCommand(joinPlayOfferDto, memberId));
         }
         catch (Exception e)
         {

Application/EventParser.cs

@@ -1,15 +1,30 @@
 using System.Text.Json;
 using System.Text.Json.Nodes;
 using PlayOfferService.Domain.Events;
+using PlayOfferService.Domain.Events.Reservation;
 
 namespace PlayOfferService.Application;
 
 public class EventParser
 {
-    public static BaseEvent ParseEvent(JsonNode jsonEvent)
+    public static T ParseEvent<T>(JsonNode jsonEvent) where T : BaseEvent, new()
     {
-        var originalEventData = JsonNode.Parse(jsonEvent["eventData"].GetValue<string>());
+        JsonNode? originalEventData = null;
+        DateTime timestamp = DateTime.UtcNow;
 
+        // If eventData is JsonValue (escaped as string), parse it
+        if (jsonEvent["eventData"] is JsonValue)
+        {
+            originalEventData = JsonNode.Parse(jsonEvent["eventData"].GetValue<string>());
+            timestamp = DateTime.Parse(jsonEvent["timestamp"].GetValue<string>()).ToUniversalTime();
+        }
+        else // If eventData is already a JsonNode, just use it --> court_service
+        {
+            originalEventData = jsonEvent["eventData"];
+            timestamp = DateTimeOffset.FromUnixTimeMilliseconds(jsonEvent["timestamp"]["$date"].GetValue<long>())
+                .UtcDateTime;
+        }
+
         // We need to add the eventType to the event data so we can deserialize it correctly
         // Since the discriminator needs to be at the first position in the JSON object, we need to create a new object
         // because JsonNode doesn't allow us to insert at the beginning of the object
@@ -18,14 +33,22 @@
         newEventData["eventType"] = jsonEvent["eventType"].GetValue<string>();
         foreach (var kvp in originalEventData.AsObject())
         {
-            newEventData[kvp.Key] = kvp.Value.DeepClone();
+            if (kvp.Value is JsonObject && kvp.Value?["$date"] != null)
+            {
+                newEventData[kvp.Key] = DateTimeOffset.FromUnixTimeMilliseconds(kvp.Value["$date"]
+                    .GetValue<long>()).UtcDateTime;
+            }
+            else
+            {
+                newEventData[kvp.Key] = kvp.Value.DeepClone();
+            }
         }
-        
-        return new BaseEvent
+
+        return new T
         {
             EventId = Guid.Parse(jsonEvent["eventId"].GetValue<string>()),
             EventType = (EventType)Enum.Parse(typeof(EventType), jsonEvent["eventType"].GetValue<string>()),
-            Timestamp = DateTime.Parse(jsonEvent["timestamp"].GetValue<string>()).ToUniversalTime(),
+            Timestamp = timestamp,
             EntityId = Guid.Parse(jsonEvent["entityId"].GetValue<string>()),
             EntityType = (EntityType)Enum.Parse(typeof(EntityType), jsonEvent["entityType"].GetValue<string>()),
             EventData = JsonSerializer.Deserialize<DomainEvent>(newEventData, JsonSerializerOptions.Default),

Application/Exceptions/AuthorizationException.cs

@@ -0,0 +1,3 @@
+namespace PlayOfferService.Application.Exceptions;
+
+public class AuthorizationException(string message) : Exception(message);

Application/Handlers/CancelPlayOfferHandler.cs

@@ -1,7 +1,6 @@
 using MediatR;
 using PlayOfferService.Application.Commands;
 using PlayOfferService.Application.Exceptions;
-using PlayOfferService.Domain;
 using PlayOfferService.Domain.Events;
 using PlayOfferService.Domain.Events.PlayOffer;
 using PlayOfferService.Domain.Models;
@@ -11,40 +10,46 @@ namespace PlayOfferService.Application.Handlers;
 
 public class CancelPlayOfferHandler : IRequestHandler<CancelPlayOfferCommand, Task>
 {
-    private readonly DbWriteContext _context;
+    private readonly WriteEventRepository _writeEventRepository;
     private readonly PlayOfferRepository _playOfferRepository;
     private readonly ClubRepository _clubRepository;
-    
-    public CancelPlayOfferHandler(DbWriteContext context, PlayOfferRepository playOfferRepository, ClubRepository clubRepository)
+
+    public CancelPlayOfferHandler(WriteEventRepository writeEventRepository, PlayOfferRepository playOfferRepository, ClubRepository clubRepository)
     {
-        _context = context;
+        _writeEventRepository = writeEventRepository;
         _playOfferRepository = playOfferRepository;
         _clubRepository = clubRepository;
     }
 
     public async Task<Task> Handle(CancelPlayOfferCommand request, CancellationToken cancellationToken)
     {
+        var transaction = _writeEventRepository.StartTransaction();
+        var excpectedEventCount = _writeEventRepository.GetEventCount(request.PlayOfferId) + 1;
+
         var existingPlayOffer = (await _playOfferRepository.GetPlayOffersByIds(request.PlayOfferId)).FirstOrDefault();
         if (existingPlayOffer == null)
             throw new NotFoundException($"PlayOffer {request.PlayOfferId} not found!");
+        if (existingPlayOffer.CreatorId != request.MemberId)
+            throw new AuthorizationException($"PlayOffer {request.PlayOfferId} can only be cancelled by creator!");
+
         if (existingPlayOffer.OpponentId != null)
             throw new InvalidOperationException($"PlayOffer {request.PlayOfferId} is already accepted and cannot be cancelled!");
         if (existingPlayOffer.IsCancelled)
             throw new InvalidOperationException($"PlayOffer {request.PlayOfferId} is already cancelled!");
-        
+
         var existingClub = await _clubRepository.GetClubById(existingPlayOffer.ClubId);
         if (existingClub == null)
             throw new NotFoundException($"Club {existingPlayOffer.ClubId} not found!");
-        
-        
+
+
         switch (existingClub.Status)
         {
             case Status.LOCKED:
                 throw new InvalidOperationException("Can't cancel PlayOffer while club is locked!");
             case Status.DELETED:
                 throw new InvalidOperationException("Can't cancel PlayOffer in deleted club!");
         }
-        
+
         var domainEvent = new BaseEvent
         {
             EntityId = request.PlayOfferId,
@@ -54,9 +59,20 @@ public async Task<Task> Handle(CancelPlayOfferCommand request, CancellationToken
             EventData = new PlayOfferCancelledEvent(),
             Timestamp = DateTime.UtcNow
         };
+
+        await _writeEventRepository.AppendEvent(domainEvent);
+        await _writeEventRepository.Update();
+
+
+        var eventCount = _writeEventRepository.GetEventCount(request.PlayOfferId);
+
+        if (eventCount != excpectedEventCount)
+        {
+            transaction.Rollback();
+            throw new InvalidOperationException("Concurrent modification detected!");
+        }
 
-        _context.Events.Add(domainEvent);
-        await _context.SaveChangesAsync();
+        transaction.Commit();
 
         return Task.CompletedTask;
     }