Events service update - organizations

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Api/Program.cs

@@ -36,12 +36,16 @@ public static async Task Main(string[] args)
                         .Get("", ctx => ctx.Response.WriteAsync(ctx.RequestServices.GetService<AppOptions>().Name))
                         .Post<SearchEvents>("events/search", async (cmd, ctx) =>
                         {
-                            var pagedResult = await ctx.RequestServices.GetService<IEventService>().SignInAsync(cmd);
+                            var pagedResult = await ctx.RequestServices.GetService<IEventService>().BrowseEventsAsync(cmd);
+                            await ctx.Response.WriteJsonAsync(pagedResult);
+                        })
+                        .Post<SearchOrganizerEvents>("events/search/organizer", async (cmd, ctx) =>
+                        {
+                            var pagedResult = await ctx.RequestServices.GetService<IEventService>().BrowseOrganizerEventsAsync(cmd);
                             await ctx.Response.WriteJsonAsync(pagedResult);
                         }))
                     .UseDispatcherEndpoints(endpoints => endpoints
                         .Get<GetEvent, EventDto>("events/{eventId}")
-                        //.Get<GetEventsOrganizer, IEnumerable<EventDto>>("events/organizer/{organizerId}")
                         .Put<UpdateEvent>("events/{eventId}")
                         .Post<AddEvent>("events", 
                             afterDispatch: (cmd, ctx) => ctx.Response.Created($"events/{cmd.EventId}"))

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Api/appsettings.local.json

@@ -24,7 +24,8 @@
     "type": "direct",
     "retries": 3,
     "services": {
-      "students": "http://localhost:5007"
+      "students": "http://localhost:5007",
+      "organizations": "http://localhost:5015"
     },
     "requestMasking": {
       "enabled": true,

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Application/Commands/AddEvent.cs

@@ -9,6 +9,7 @@ public class AddEvent : ICommand
         public Guid EventId { get; }
         public string Name { get; }
         public Guid OrganizerId { get; }
+        public Guid OrganizationId { get; }
         public string StartDate { get; }
         public string EndDate { get; }
         public string BuildingName { get; }
@@ -23,13 +24,14 @@ public class AddEvent : ICommand
         public string Category { get; }
         public string PublishDate { get; }
 
-        public AddEvent(Guid eventId, string name, Guid organizerId, string startDate, string endDate, 
-            string buildingName, string street, string buildingNumber, string apartmentNumber, string city, 
-            string zipCode, string description, int capacity, decimal fee, string category, string publishDate)
+        public AddEvent(Guid eventId, string name, Guid organizerId, Guid organizationId, string startDate, 
+            string endDate, string buildingName, string street, string buildingNumber, string apartmentNumber, 
+            string city, string zipCode, string description, int capacity, decimal fee, string category, string publishDate)
         {
             EventId = eventId == Guid.Empty ? Guid.NewGuid() : eventId;
             Name = name;
             OrganizerId = organizerId;
+            OrganizationId = organizationId;
             StartDate = startDate;
             EndDate = endDate;
             BuildingName = buildingName;

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Application/Commands/Handlers/AddEventHandler.cs

@@ -6,6 +6,7 @@
 using MiniSpace.Services.Events.Application.Events;
 using MiniSpace.Services.Events.Application.Exceptions;
 using MiniSpace.Services.Events.Application.Services;
+using MiniSpace.Services.Events.Application.Services.Clients;
 using MiniSpace.Services.Events.Core.Entities;
 using MiniSpace.Services.Events.Core.Repositories;
 
@@ -15,17 +16,18 @@ public class AddEventHandler: ICommandHandler<AddEvent>
     {
         private readonly IEventRepository _eventRepository;
         private readonly IMessageBroker _messageBroker;
-        private readonly IEventMapper _eventMapper;
+        private readonly IOrganizationsServiceClient _organizationsServiceClient;
         private readonly IDateTimeProvider _dateTimeProvider;
         private readonly IEventValidator _eventValidator;
         private readonly IAppContext _appContext;
 
-        public AddEventHandler(IEventRepository eventRepository, IMessageBroker messageBroker, IEventMapper eventMapper,
-            IDateTimeProvider dateTimeProvider, IEventValidator eventValidator, IAppContext appContext)
+        public AddEventHandler(IEventRepository eventRepository, IMessageBroker messageBroker, 
+            IOrganizationsServiceClient organizationsServiceClient, IDateTimeProvider dateTimeProvider, 
+            IEventValidator eventValidator, IAppContext appContext)
         {
             _eventRepository = eventRepository;
             _messageBroker = messageBroker;
-            _eventMapper = eventMapper;
+            _organizationsServiceClient = organizationsServiceClient;
             _dateTimeProvider = dateTimeProvider;
             _eventValidator = eventValidator;
             _appContext = appContext;
@@ -39,8 +41,8 @@ public async Task HandleAsync(AddEvent command, CancellationToken cancellationTo
             if(identity.Id != command.OrganizerId)
                 throw new OrganizerCannotAddEventForAnotherOrganizerException(identity.Id, command.OrganizerId);
 
-            _eventValidator.ValidateRequiredField(command.Name, "event_name");
-            _eventValidator.ValidateRequiredField(command.Description, "event_description");
+            _eventValidator.ValidateName(command.Name);
+            _eventValidator.ValidateDescription(command.Description);
             var startDate = _eventValidator.ParseDate(command.StartDate, "event_start_date");
             var endDate = _eventValidator.ParseDate(command.EndDate, "event_end_date");
             var now = _dateTimeProvider.Now;
@@ -62,9 +64,20 @@ public async Task HandleAsync(AddEvent command, CancellationToken cancellationTo
                 state = State.ToBePublished;
             }
 
-            var organizer = new Organizer(command.OrganizerId, identity.Name, identity.Email, string.Empty);
+            var organization = await _organizationsServiceClient.GetAsync(command.OrganizationId);
+            if (organization == null)
+            {
+                throw new OrganizationNotFoundException(command.OrganizationId);
+            }
+
+            if (!organization.Organizers.Contains(command.OrganizerId))
+            {
+                throw new OrganizerDoesNotBelongToOrganizationException(command.OrganizerId, command.OrganizationId);
+            }
+
+            var organizer = new Organizer(command.OrganizerId, identity.Name, identity.Email, command.OrganizerId, string.Empty);
             var @event = Event.Create(command.EventId, command.Name, command.Description, startDate, endDate, 
-                address, command.Capacity, command.Fee, category, state, publishDate, organizer);
+                address, command.Capacity, command.Fee, category, state, publishDate, organizer, now);
 
             await _eventRepository.AddAsync(@event);
             await _messageBroker.PublishAsync(new EventCreated(@event.Id, @event.Organizer.Id));

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Application/Commands/Handlers/UpdateEventHandler.cs

@@ -69,7 +69,7 @@ public async Task HandleAsync(UpdateEvent command, CancellationToken cancellatio
                 state = State.ToBePublished;
             }
 
-            @event.Update(name, description, startDate, endDate, address, capacity, fee, category, state, publishDate);
+            @event.Update(name, description, startDate, endDate, address, capacity, fee, category, state, publishDate, now);
             await _eventRepository.UpdateAsync(@event);
             await _messageBroker.PublishAsync(new EventUpdated(@event.Id, _dateTimeProvider.Now, identity.Id));
         }

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Application/Commands/SearchEvents.cs

@@ -7,6 +7,8 @@ public class SearchEvents : ICommand
     {
         public string Name { get; set; }
         public string Organizer { get; set; }
+        public string Category { get; set; }
+        public string State { get; set; }
         public string DateFrom { get; set; }
         public string DateTo { get; set; }
         public PageableDto Pageable { get; set; }

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Application/Commands/SearchOrganizerEvents.cs

@@ -0,0 +1,16 @@
+using System;
+using Convey.CQRS.Commands;
+using MiniSpace.Services.Events.Application.DTO;
+
+namespace MiniSpace.Services.Events.Application.Commands
+{
+    public class SearchOrganizerEvents : ICommand
+    {
+        public string Name { get; set; }
+        public Guid OrganizerId { get; set; }
+        public string DateFrom { get; set; }
+        public string DateTo { get; set; }
+        public string State { get; set; }
+        public PageableDto Pageable { get; set; }
+    }
+}

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Application/DTO/EventDto.cs

@@ -14,7 +14,6 @@ public class EventDto
         public OrganizerDto Organizer { get; set; }
         public DateTime StartDate { get; set; }
         public DateTime EndDate { get; set; }
-        public IEnumerable<OrganizerDto> CoOrganizers { get; set; }
         public AddressDto Location { get; set; }
         //public string Image { get; set; }
         public int InterestedStudents { get; set; }
@@ -24,6 +23,7 @@ public class EventDto
         public string Category { get; set; }
         public string Status { get; set; }
         public DateTime PublishDate { get; set; }
+        public DateTime UpdatedAt { get; set; }
         public bool IsSignedUp { get; set; }
         public bool IsInterested { get; set; }
         public bool HasRated { get; set; }
@@ -40,7 +40,6 @@ public EventDto(Event @event, Guid studentId)
             Organizer = new OrganizerDto(@event.Organizer);
             StartDate = @event.StartDate;
             EndDate = @event.EndDate;
-            CoOrganizers = @event.CoOrganizers.Select(x => new OrganizerDto(x));
             Location = new AddressDto(@event.Location);
             InterestedStudents = @event.InterestedStudents.Count();
             SignedUpStudents = @event.SignedUpStudents.Count();

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Application/DTO/OrganizationDto.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+
+namespace MiniSpace.Services.Events.Application.DTO
+{
+    public class OrganizationDto
+    {
+        public Guid Id { get; set; }
+        public string Name { get; set; }
+        public IEnumerable<Guid> Organizers;
+    }
+}

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Application/DTO/OrganizerDto.cs

@@ -8,7 +8,8 @@ public class OrganizerDto
         public Guid Id { get; set; }
         public string Name { get; set; }
         public string Email { get; set; }
-        public string Organization { get; set; }
+        public Guid OrganizationId { get; set; }
+        public string OrganizationName { get; set; }
 
         public OrganizerDto()
         {
@@ -19,7 +20,8 @@ public OrganizerDto(Organizer organizer)
             Id = organizer.Id;
             Name = organizer.Name;
             Email = organizer.Email;
-            Organization = organizer.Organization;
+            OrganizationId = organizer.OrganizationId;
+            OrganizationName = organizer.OrganizationName;
         }
     }
 }

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Application/Exceptions/InvalidEventDescriptionException.cs

@@ -0,0 +1,13 @@
+namespace MiniSpace.Services.Events.Application.Exceptions
+{
+    public class InvalidEventDescriptionException : AppException
+    {
+        public override string Code { get; } = "invalid_event_description";
+        public string Description { get; }
+
+        public InvalidEventDescriptionException(string description): base("Invalid event description. It cannot be empty or longer than 5000 characters.")
+        {
+            Description = description;
+        }
+    }
+}

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Application/Exceptions/InvalidEventNameException.cs

@@ -0,0 +1,13 @@
+namespace MiniSpace.Services.Events.Application.Exceptions
+{
+    public class InvalidEventNameException : AppException
+    {
+        public override string Code { get; } = "invalid_event_name";
+        public string Name { get; }
+
+        public InvalidEventNameException(string name): base("Invalid event name. It cannot be empty or longer than 300 characters.")
+        {
+            Name = name;
+        }
+    }
+}

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Application/Exceptions/InvalidEventStateException.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace MiniSpace.Services.Events.Application.Exceptions
+{
+    public class InvalidEventStateException : AppException
+    {
+        public override string Code { get; } = "invalid_event_state";
+        public string State { get; }
+
+        public InvalidEventStateException(string state) : base($"Event State property is invalid: {state}.")
+        {
+            State = state;
+        }
+    }
+}

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Application/Exceptions/OrganizationNotFoundException.cs

@@ -0,0 +1,15 @@
+using System;
+
+namespace MiniSpace.Services.Events.Application.Exceptions
+{
+    public class OrganizationNotFoundException: AppException
+    {
+        public override string Code { get; } = "organization_not_found";
+        public Guid OrganizationId { get; }
+
+        public OrganizationNotFoundException(Guid organizationId): base($"Organization with id: '{organizationId}' was not found.")
+        {
+            OrganizationId = organizationId;
+        }
+    }
+}

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Application/Exceptions/OrganizerDoesNotBelongToOrganizationException.cs

@@ -0,0 +1,18 @@
+using System;
+
+namespace MiniSpace.Services.Events.Application.Exceptions
+{
+    public class OrganizerDoesNotBelongToOrganizationException : AppException
+    {
+        public override string Code => "organizer_does_not_belong_to_organization";
+        public Guid OrganizerId { get; }
+        public Guid OrganizationId { get; }
+
+        public OrganizerDoesNotBelongToOrganizationException(Guid organizerId, Guid organizationId) 
+            : base($"Organizer with ID: {organizerId} does not belong to organization with ID: {organizationId}.")
+        {
+            OrganizerId = organizerId;
+            OrganizationId = organizationId;
+        }
+    }
+}

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Application/Exceptions/UnauthorizedOrganizerEventsAccessException.cs

@@ -0,0 +1,18 @@
+using System;
+
+namespace MiniSpace.Services.Events.Application.Exceptions
+{
+    public class UnauthorizedOrganizerEventsAccessException : AppException
+    {
+        public override string Code { get; } = "unauthorized_event_access";
+        public Guid OrganizerId { get; }
+        public Guid UserId { get; }
+
+        public UnauthorizedOrganizerEventsAccessException(Guid organizerId, Guid userId) 
+            : base($"Unauthorized access to organizer events with ID: '{organizerId}' by user with ID: '{userId}'.")
+        {
+            OrganizerId = organizerId;
+            UserId = userId;
+        }
+    }
+}

MiniSpace.Services.Events/src/MiniSpace.Services.Events.Application/Services/Clients/IOrganizationsServiceClient.cs

@@ -0,0 +1,11 @@
+using System;
+using System.Threading.Tasks;
+using MiniSpace.Services.Events.Application.DTO;
+
+namespace MiniSpace.Services.Events.Application.Services.Clients
+{
+    public interface IOrganizationsServiceClient
+    {
+        Task<OrganizationDto> GetAsync(Guid id);
+    }
+}