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

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

namespace SeaHaven.DataServices.Implementation
{
    public class SettingsDataService : ISettingsDataService
    {
        private readonly ApplicationDbContext _context;

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

        public async Task AddCategoryAsync(string name, CancellationToken cancellationToken)
        {
            var category = new Category { Name = name };
            await _context.Categories.AddAsync(category, cancellationToken);
            await _context.SaveChangesAsync(cancellationToken);
        }

        public async Task<bool> UpdateCategoryAsync(int id, string name, CancellationToken cancellationToken)
        {
            var exist = await _context.Categories
                .Where(w => w.Id == id)
                .FirstOrDefaultAsync(cancellationToken);
            if (exist == null)
                return false;

            exist.Name = name;
            _context.Categories.Update(exist);
            await _context.SaveChangesAsync(cancellationToken);
            return true;
        }

        public async Task<bool> DeleteCategoryCascadeAsync(int id, CancellationToken cancellationToken)
        {
            var exist = await _context.Categories
                .Where(w => w.Id == id)
                .FirstOrDefaultAsync(cancellationToken);
            if (exist == null)
                return false;

            var templates = await _context.Templates.Where(w => w.CategoryId == id).ToListAsync(cancellationToken);
            if (templates != null)
            {
                _context.RemoveRange(templates);
            }

            var workOrderCategories = await _context.workOrderCategories.Where(w => w.CategoryId == id).ToListAsync(cancellationToken);
            if (workOrderCategories != null)
            {
                _context.RemoveRange(workOrderCategories);
            }

            _context.Remove(exist);
            await _context.SaveChangesAsync(cancellationToken);
            return true;
        }

        public async Task<(IReadOnlyList<SettingsCategoryItemDTO> Items, int Total)> GetCategoryListPagedAsync(
            int page,
            int pageSize,
            CancellationToken cancellationToken)
        {
            var totalCount = await _context.Categories.CountAsync(cancellationToken);
            var data = await _context.Categories
                .AsNoTracking()
                .Select(s => new SettingsCategoryItemDTO
                {
                    Id = s.Id,
                    Name = s.Name
                })
                .OrderByDescending(d => d.Id)
                .Skip((page - 1) * pageSize)
                .Take(pageSize)
                .ToListAsync(cancellationToken);

            return (data, totalCount);
        }

        public async Task<(IReadOnlyList<WorkOrder> Items, int Total)> GetTemplatesPagedAsync(
            int page,
            int pageSize,
            CancellationToken cancellationToken)
        {
            var totalCount = await _context.workOrders.CountAsync(w => w.istemplate == true, cancellationToken);
            var data = await _context.workOrders
                .AsNoTracking()
                .Where(w => w.istemplate == true)
                .OrderByDescending(d => d.Id)
                .Skip((page - 1) * pageSize)
                .Take(pageSize)
                .ToListAsync(cancellationToken);

            return (data, totalCount);
        }

        public async Task<(IReadOnlyList<ApplicationUser> Users, int Total)> GetUsersPagedAsync(
            string? search,
            int page,
            int pageSize,
            CancellationToken cancellationToken)
        {
            var totalCount = await _context.Users.CountAsync(cancellationToken);
            var users = await _context.Users
                .AsNoTracking()
                .Where(w => (w.FirstName ?? "").ToLower().Contains((search ?? "").ToLower()))
                .OrderByDescending(d => d.Id)
                .Skip((page - 1) * pageSize)
                .Take(pageSize)
                .ToListAsync(cancellationToken);

            return (users, totalCount);
        }

        public async Task<IReadOnlyList<string>> GetRoleNamesAsync(CancellationToken cancellationToken)
        {
            var roles = await _context.Roles.AsNoTracking().ToListAsync(cancellationToken);
            return roles.Select(r => r.Name!).ToList();
        }
    }
}