shoc-backend/SeaHaven.DataServices/Implementation/CalendarDataService.cs

using Data.SeaHavenIndustries;
using Microsoft.EntityFrameworkCore;
using SeaHaven.DataServices.Interfaces;

namespace SeaHaven.DataServices.Implementation
{
    public class CalendarDataService : ICalendarDataService
    {
        private readonly ApplicationDbContext _context;

        public CalendarDataService(ApplicationDbContext context)
        {
            _context = context;
        }

        public async Task<Events?> GetEventByIdAsync(int id, CancellationToken cancellationToken)
        {
            return await _context.Events
                .AsNoTracking()
                .Where(e => e.Id == id && e.IsDeleted != true)
                .FirstOrDefaultAsync(cancellationToken);
        }

        public async Task<Events?> GetEventForEditAsync(int id, CancellationToken cancellationToken)
        {
            return await _context.Events.FindAsync(new object[] { id }, cancellationToken);
        }

        public async Task<Events> AddEventAsync(Events ev, CancellationToken cancellationToken)
        {
            await _context.Events.AddAsync(ev, cancellationToken);
            await _context.SaveChangesAsync(cancellationToken);
            return ev;
        }

        public async Task UpdateEventAsync(Events ev, CancellationToken cancellationToken)
        {
            _context.Events.Update(ev);
            await _context.SaveChangesAsync(cancellationToken);
        }

        public async Task<(IEnumerable<Events> Items, int TotalCount)> GetEventListPagedAsync(int page, int pageSize, string? search, CancellationToken cancellationToken)
        {
            var query = _context.Events.Where(e => e.IsDeleted != true);

            if (!string.IsNullOrWhiteSpace(search))
            {
                var searchLower = search.ToLower();
                query = query.Where(e =>
                    e.Title.ToLower().Contains(searchLower) ||
                    (e.Description != null && e.Description.ToLower().Contains(searchLower)) ||
                    (e.Location != null && e.Location.ToLower().Contains(searchLower)));
            }

            var totalCount = await query.CountAsync(cancellationToken);

            var events = await query
                .OrderByDescending(e => e.StartDate)
                .ThenByDescending(e => e.CreatedDate)
                .Skip((page - 1) * pageSize)
                .Take(pageSize)
                .AsNoTracking()
                .ToListAsync(cancellationToken);

            return (events, totalCount);
        }

        public async Task<IEnumerable<Events>> GetEventsForCalendarAsync(DateTime? start, DateTime? end, CancellationToken cancellationToken)
        {
            var query = _context.Events.Where(e => e.IsDeleted != true);

            if (start.HasValue && end.HasValue)
            {
                query = query.Where(e =>
                    (e.StartDate >= start.Value && e.StartDate <= end.Value) ||
                    (e.EndDate >= start.Value && e.EndDate <= end.Value) ||
                    (e.StartDate <= start.Value && e.EndDate >= end.Value));
            }

            return await query
                .AsNoTracking()
                .ToListAsync(cancellationToken);
        }
    }
}