Implement event related interfaces

BusinessLayer/Services/EventCommentService/EventCommentService.cs

+using BusinessLayer.DTOs.EventComment;
+using BusinessLayer.Utils.Filters;
+using BusinessLayer.Utils.Pagination;
+using DAL.Data;
+using DAL.Models;
+using Mapster;
+using Microsoft.EntityFrameworkCore;
+
+namespace BusinessLayer.Services.EventCommentService
+{
+    public class EventCommentService : BaseService, IEventCommentService
+    {
+        private readonly RestaurantDBContext _dbContext;
+
+        public EventCommentService(RestaurantDBContext dbContext) : base(dbContext)
+        {
+            _dbContext = dbContext;
+        }
+
+        public async Task<EventCommentDTO?> CreateCommentAsync(EventCommentCreateDTO data, bool save = true)
+        {
+            var poster = await _dbContext.Users.FindAsync(data.PosterId);
+            if (poster is null || poster.DeletedAt is not null)
+            {
+                return null;
+            }
+
+            var eventEntity = await _dbContext.Events.FindAsync(data.EventId);
+            if (eventEntity is null || eventEntity.DeletedAt is not null)
+            {
+                return null;
+            }
+
+            if (data.ParentCommentId is not null)
+            {
+                var parentComment = await _dbContext.EventComments.FindAsync(data.ParentCommentId);
+                if (parentComment is null || parentComment.DeletedAt is not null)
+                {
+                    return null;
+                }
+            }
+
+            var comment = data.Adapt<EventComment>();
+            comment.Id = Guid.NewGuid();
+            comment.CreatedAt = DateTime.UtcNow;
+            comment.UpdatedAt = DateTime.UtcNow;
+
+            await _dbContext.EventComments.AddAsync(comment);
+            await SaveAsync(save);
+            return comment.Adapt<EventCommentDTO?>();
+        }
+
+        public async Task<bool> DeleteCommentAsync(Guid id, bool save = true)
+        {
+            var comment = await _dbContext.EventComments.FindAsync(id);
+            if (comment is null || comment.DeletedAt is not null)
+            {
+                return false;
+            }
+
+            comment.UpdatedAt = DateTime.UtcNow;
+            comment.DeletedAt = DateTime.UtcNow;
+
+            _dbContext.EventComments.Update(comment);
+            await SaveAsync(save);
+            return true;
+        }
+
+        public async Task<bool> DoesCommentExistAsync(params Guid[] ids)
+        {
+            return await _dbContext.EventComments.AnyAsync(c => ids.Contains(c.Id) && c.DeletedAt == null);
+        }
+
+        public async Task<EventCommentDTO?> GetByIdAsync(Guid id, bool includeUser = true, bool includeEvent = false, bool includeChildren = false)
+        {
+            var query = BuildQuery(includeUser, includeEvent, includeChildren);
+
+            var result = await query.SingleOrDefaultAsync(c => c.Id == id && c.DeletedAt == null);
+            if (result == null
+                || (includeUser && result.Poster.DeletedAt != null)
+                || (includeEvent && result.Event.DeletedAt != null))
+            {
+                return null;
+            }
+
+            return result.Adapt<EventCommentDTO?>();
+        }
+
+        public async Task<List<EventCommentDTO>> GetCommentsAsync(EventCommentFilter filter,
+            int limit = 0,
+            int offset = 0,
+            Guid[]? ids = null,
+            bool includeUser = true,
+            bool includeEvent = false,
+            bool includeChildren = false)
+        {
+            IQueryable<EventComment> query = BuildQuery(includeUser, includeEvent, includeChildren);
+
+            return await query
+                .Where(filter.ComposeFilterFunction(ids))
+                .OrderByDescending(c => c.CreatedAt)
+                .ApplyPagination(limit, offset)
+                .Select(c => c.Adapt<EventCommentDTO>())
+                .ToListAsync();
+        }
+
+        public async Task<EventCommentDTO?> UpdateCommentAsync(Guid id, EventCommentUpdateDTO data, bool save = true)
+        {
+            var comment = await _dbContext.EventComments.FindAsync(id);
+            if (comment is null || comment.DeletedAt is not null)
+            {
+                return null;
+            }
+
+            comment.Content = data.Content ?? comment.Content;
+            comment.UpdatedAt = DateTime.UtcNow;
+
+            _dbContext.EventComments.Update(comment);
+            await SaveAsync(save);
+
+            return comment.Adapt<EventCommentDTO?>();
+        }
+
+        private IQueryable<EventComment> BuildQuery(bool includeUser, bool includeEvent, bool includeChildren)
+        {
+            IQueryable<EventComment> query = _dbContext.EventComments;
+
+            if (includeUser)
+            {
+                query = query.Include(c => c.Poster);
+            }
+
+            if (includeEvent)
+            {
+                query = query.Include(c => c.Event);
+            }
+
+            if (includeChildren)
+            {
+                query = query.Include(c => c.ChildComments);
+            }
+
+            return query;
+        }
+    }
+}

BusinessLayer/Services/EventParticipantService/EventParticipantService.cs

+using BusinessLayer.DTOs.EventParticipant;
+using BusinessLayer.Utils.Filters;
+using DAL.Data;
+using DAL.Models;
+using Mapster;
+using Microsoft.EntityFrameworkCore;
+
+namespace BusinessLayer.Services.EventParticipantService
+{
+    public class EventParticipantService : BaseService, IEventParticipantService
+    {
+        private readonly RestaurantDBContext _dbContext;
+
+        public EventParticipantService(RestaurantDBContext dbContext) : base(dbContext)
+        {
+            _dbContext = dbContext;
+        }
+
+        public async Task<EventParticipantDTO?> GetParticipantByIdAsync(Guid userId, Guid eventId)
+        {
+            var participant = await _dbContext.EventParticipants
+                .Include(p => p.User)
+                .Include(p => p.Event)
+                .FirstOrDefaultAsync(p => p.UserId == userId && p.EventId == eventId && p.DeletedAt == null);
+
+            return participant?.Adapt<EventParticipantDTO>();
+        }
+
+        public async Task<List<EventParticipantDTO>> GetParticipantsAsync(EventParticipantFilter filter, int limit = 0, int offset = 0)
+        {
+            var query = _dbContext.EventParticipants
+                .Include(p => p.User)
+                .Include(p => p.Event)
+                .Where(filter.ComposeFilterFunction())
+                .OrderBy(p => p.User!.Name)
+                .Skip(offset);
+
+            var participants = limit > 0
+                ? await query.Take(limit).ToListAsync()
+                : await query.ToListAsync();
+
+            return participants.Adapt<List<EventParticipantDTO>>();
+        }
+
+        public async Task<EventParticipantDTO?> CreateParticipantAsync(EventParticipantCreateDTO data, bool save = true)
+        {
+            var user = await _dbContext.Users.FindAsync(data.UserId);
+            if (user == null || user.DeletedAt != null)
+            {
+                return null;
+            }
+
+            var eventEntity = await _dbContext.Events.FindAsync(data.EventId);
+            if (eventEntity == null || eventEntity.DeletedAt != null)
+            {
+                return null;
+            }
+
+            var oldParticipant = await _dbContext.EventParticipants
+                .FirstOrDefaultAsync(p => p.UserId == data.UserId && p.EventId == data.EventId);
+
+            if (oldParticipant != null)
+            {
+                if (oldParticipant.DeletedAt != null)
+                {
+                    oldParticipant.CreatedAt = DateTime.UtcNow;
+                    oldParticipant.UpdatedAt = DateTime.UtcNow;
+                    oldParticipant.DeletedAt = null;
+                    oldParticipant.Attendance = data.Attendance;
+
+                    _dbContext.EventParticipants.Update(oldParticipant);
+                    await SaveAsync(save);
+                    return oldParticipant.Adapt<EventParticipantDTO>();
+                }
+
+                return null;
+            }
+
+            var participant = new EventParticipant
+            {
+                UserId = data.UserId,
+                EventId = data.EventId,
+                Attendance = data.Attendance,
+                CreatedAt = DateTime.UtcNow,
+                UpdatedAt = DateTime.UtcNow
+            };
+
+            await _dbContext.EventParticipants.AddAsync(participant);
+            await SaveAsync(save);
+
+            return participant.Adapt<EventParticipantDTO>();
+        }
+
+        public async Task<EventParticipantDTO?> UpdateParticipantAsync(Guid participantId, EventParticipantUpdateDTO data, bool save = true)
+        {
+            var participant = await _dbContext.EventParticipants.FindAsync(participantId);
+            if (participant == null || participant.DeletedAt != null)
+            {
+                return null;
+            }
+
+            participant.Attendance = data.Attendance;
+            participant.UpdatedAt = DateTime.UtcNow;
+
+            _dbContext.EventParticipants.Update(participant);
+            await SaveAsync(save);
+
+            return participant.Adapt<EventParticipantDTO>();
+        }
+
+        public async Task<bool> DeleteParticipantAsync(Guid participantId, bool save = true)
+        {
+            var participant = await _dbContext.EventParticipants.FindAsync(participantId);
+            if (participant == null || participant.DeletedAt != null)
+            {
+                return false;
+            }
+
+            participant.UpdatedAt = DateTime.UtcNow;
+            participant.DeletedAt = DateTime.UtcNow;
+
+            _dbContext.EventParticipants.Update(participant);
+            await SaveAsync(save);
+
+            return true;
+        }
+    }
+}

BusinessLayer/Services/EventService/EventService.cs

+using BusinessLayer.DTOs.Event;
+using BusinessLayer.Utils.Filters;
+using DAL.Data;
+using DAL.Models;
+using Mapster;
+using Microsoft.EntityFrameworkCore;
+
+namespace BusinessLayer.Services.EventService
+{
+    public class EventService : BaseService, IEventService
+    {
+        private readonly RestaurantDBContext _dbContext;
+
+        public EventService(RestaurantDBContext dbContext) : base(dbContext)
+        {
+            _dbContext = dbContext;
+        }
+
+        public async Task<EventDTO?> GetEventByIdAsync(Guid eventId, bool includeRestaurant = true)
+        {
+            var query = _dbContext.Events.AsQueryable();
+            if (includeRestaurant)
+            {
+                query = query.Include(e => e.Restaurant);
+            }
+
+            var eventEntity = await query
+                .SingleOrDefaultAsync(e => e.Id == eventId && e.DeletedAt == null);
+
+            return eventEntity?.Adapt<EventDTO>();
+        }
+
+        public async Task<List<EventDTO>> GetEventsAsync(EventFilter filter, int limit = 0, int offset = 0)
+        {
+            var eventsQuery = _dbContext.Events
+                .Include(e => e.Restaurant)
+                .Where(filter.ComposeFilterFunction())
+                .OrderBy(e => e.Date)
+                .Skip(offset);
+
+            var events = limit > 0
+                ? await eventsQuery.Take(limit).ToListAsync()
+                : await eventsQuery.ToListAsync();
+
+            return events.Adapt<List<EventDTO>>();
+        }
+
+        public async Task<EventDTO?> CreateEventAsync(EventCreateDTO data, bool save = true)
+        {
+            var user = await _dbContext.Users.FindAsync(data.CreatorId);
+            if (user == null || user.DeletedAt != null)
+            {
+                return null;
+            }
+
+            var restaurant = await _dbContext.Restaurants.FindAsync(data.RestaurantId);
+            if (restaurant == null || restaurant.DeletedAt != null)
+            {
+                return null;
+            }
+
+            var eventEntity = new Event
+            {
+                Id = Guid.NewGuid(),
+                Title = data.Title,
+                RestaurantId = data.RestaurantId,
+                Content = data.Content,
+                Date = data.Date,
+                CreatedAt = DateTime.UtcNow,
+                UpdatedAt = DateTime.UtcNow,
+            };
+
+            var creator = new EventParticipant
+            {
+                EventId = eventEntity.Id,
+                UserId = data.CreatorId,
+                Attendance = DAL.Enums.ParticipantType.Creator
+            };
+
+            await _dbContext.Events.AddAsync(eventEntity);
+            await _dbContext.EventParticipants.AddAsync(creator);
+            await SaveAsync(save);
+
+            return eventEntity.Adapt<EventDTO>();
+        }
+
+        public async Task<EventDTO?> UpdateEventAsync(Guid eventId, EventUpdateDTO data, bool save = true)
+        {
+            var eventEntity = await _dbContext.Events.FindAsync(eventId);
+            if (eventEntity == null || eventEntity.DeletedAt != null)
+            {
+                return null;
+            }
+
+            eventEntity.Title = data.Title ?? eventEntity.Title;
+            eventEntity.Content = data.Content ?? eventEntity.Content;
+            eventEntity.Date = data.Date ?? eventEntity.Date;
+            eventEntity.UpdatedAt = DateTime.UtcNow;
+
+            _dbContext.Events.Update(eventEntity);
+            await SaveAsync(save);
+
+            return eventEntity.Adapt<EventDTO>();
+        }
+
+        public async Task<bool> DeleteEventAsync(Guid eventId, bool save = true)
+        {
+            var eventEntity = await _dbContext.Events.FindAsync(eventId);
+            if (eventEntity == null || eventEntity.DeletedAt != null)
+            {
+                return false;
+            }
+
+            eventEntity.UpdatedAt = DateTime.UtcNow;
+            eventEntity.DeletedAt = DateTime.UtcNow;
+
+            _dbContext.Events.Update(eventEntity);
+            await SaveAsync(save);
+
+            return true;
+        }
+    }
+}