mws.backend.dotnet/infrastructure/Persistence/Repositories/ProjectRepository.cs

using Microsoft.EntityFrameworkCore;
using mws.backend.dotnet.application.Common;
using mws.backend.dotnet.application.Common.Repositories;
using mws.backend.dotnet.application.Projects;
using mws.backend.dotnet.domain.Projects;

namespace mws.backend.dotnet.infrastructure.Persistence.Repositories;

public class ProjectRepository(AppDbContext db) : RepositoryBase<Project>(db), IProjectRepository
{
    public Task<Project?> GetByIdAsync(Guid id, CancellationToken ct = default) =>
        Set.FirstOrDefaultAsync(p => p.Id == id, ct);

    public Task<Project?> GetForUserAsync(Guid userId, Guid projectId, CancellationToken ct = default) =>
        Set.Include(p => p.CreatedByUser).Include(p => p.UpdatedByUser)
            .FirstOrDefaultAsync(p => p.Id == projectId && p.Members.Any(m => m.UserId == userId), ct);

    public Task<PagedResult<Project>> GetForUserAsync(ProjectListFilter filter, int page, int pageSize, CancellationToken ct = default)
    {
        var query = Set.Include(p => p.CreatedByUser).Include(p => p.UpdatedByUser)
            .Where(p => p.Members.Any(m => m.UserId == filter.UserId));

        if (!string.IsNullOrWhiteSpace(filter.Term))
        {
            var lower = filter.Term.Trim().ToLower();
            query = query.Where(p => p.Name.ToLower().Contains(lower));
        }

        if (filter.Status is { } status)
        {
            query = query.Where(p => p.Status == status);
        }

        if (!string.IsNullOrWhiteSpace(filter.CreatedBy))
        {
            var lower = filter.CreatedBy.Trim().ToLower();
            query = query.Where(p => p.CreatedByUser != null && p.CreatedByUser.DisplayName.ToLower().Contains(lower));
        }

        if (!string.IsNullOrWhiteSpace(filter.UpdatedBy))
        {
            var lower = filter.UpdatedBy.Trim().ToLower();
            query = query.Where(p => p.UpdatedByUser != null && p.UpdatedByUser.DisplayName.ToLower().Contains(lower));
        }

        return query.OrderByDescending(p => p.UpdatedAt).ToPagedResultAsync(page, pageSize, ct);
    }

    public Task<List<Project>> SearchForUserAsync(Guid userId, string? term, CancellationToken ct = default)
    {
        var query = Set.Include(p => p.CreatedByUser).Include(p => p.UpdatedByUser)
            .Where(p => p.Members.Any(m => m.UserId == userId));
        if (!string.IsNullOrWhiteSpace(term))
        {
            var lower = term.Trim().ToLower();
            query = query.Where(p => p.Name.ToLower().Contains(lower));
        }

        return query.OrderByDescending(p => p.UpdatedAt).ToListAsync(ct);
    }

    public Task<int> CountMembersAsync(Guid projectId, CancellationToken ct = default) =>
        Db.ProjectMembers.CountAsync(m => m.ProjectId == projectId, ct);

    public Task<bool> IsMemberAsync(Guid projectId, Guid userId, CancellationToken ct = default) =>
        Db.ProjectMembers.AnyAsync(m => m.ProjectId == projectId && m.UserId == userId, ct);

    public Task<MemberRole?> GetMemberRoleAsync(Guid projectId, Guid userId, CancellationToken ct = default) =>
        Db.ProjectMembers
            .Where(m => m.ProjectId == projectId && m.UserId == userId)
            .Select(m => (MemberRole?)m.Role)
            .SingleOrDefaultAsync(ct);

    public Task<ProjectMember?> GetMemberAsync(Guid projectId, Guid userId, CancellationToken ct = default) =>
        Db.ProjectMembers.FirstOrDefaultAsync(m => m.ProjectId == projectId && m.UserId == userId, ct);

    public Task<ProjectMember?> GetMemberWithUserAsync(Guid projectId, Guid userId, CancellationToken ct = default) =>
        Db.ProjectMembers.Include(m => m.User).FirstOrDefaultAsync(m => m.ProjectId == projectId && m.UserId == userId, ct);

    public Task<PagedResult<ProjectMember>> GetMembersWithUserAsync(Guid projectId, MemberListFilter filter, int page, int pageSize, CancellationToken ct = default)
    {
        var query = Db.ProjectMembers
            .Where(m => m.ProjectId == projectId)
            .Include(m => m.User)
            .AsQueryable();

        if (!string.IsNullOrWhiteSpace(filter.Term))
        {
            var lower = filter.Term.Trim().ToLower();
            query = query.Where(m => m.User.Username.ToLower().Contains(lower) || m.User.DisplayName.ToLower().Contains(lower));
        }

        if (filter.Role is { } role)
        {
            query = query.Where(m => m.Role == role);
        }

        return query.OrderByDescending(m => m.Role)
            .ThenBy(m => m.User.DisplayName)
            .ToPagedResultAsync(page, pageSize, ct);
    }

    public Task<int> CountOwnersAsync(Guid projectId, CancellationToken ct = default) =>
        Db.ProjectMembers.CountAsync(m => m.ProjectId == projectId && m.Role == MemberRole.Owner, ct);

    public Task<List<Guid>> GetProjectIdsForUserAsync(Guid userId, CancellationToken ct = default) =>
        Set.Where(p => p.Members.Any(m => m.UserId == userId)).Select(p => p.Id).ToListAsync(ct);

    public Task<List<Guid>> GetOwnedProjectIdsAsync(Guid userId, CancellationToken ct = default) =>
        Db.ProjectMembers.Where(m => m.UserId == userId && m.Role == MemberRole.Owner).Select(m => m.ProjectId).ToListAsync(ct);

    public Task<List<Guid>> GetDocumentViewableProjectIdsAsync(Guid userId, CancellationToken ct = default) =>
        Db.ProjectMembers
            .Where(m => m.UserId == userId &&
                (m.Role == MemberRole.Owner ||
                 Db.ProjectMemberPermissions.Any(p => p.ProjectId == m.ProjectId && p.UserId == userId && p.Screen == ProjectPermissionScreens.Documents && p.CanView)))
            .Select(m => m.ProjectId)
            .ToListAsync(ct);

    public void AddMember(ProjectMember member) => Db.ProjectMembers.Add(member);

    public void RemoveMember(ProjectMember member) => Db.ProjectMembers.Remove(member);

    public Task<ProjectMemberPermission?> GetMemberPermissionAsync(Guid projectId, Guid userId, string screen, CancellationToken ct = default) =>
        Db.ProjectMemberPermissions.FirstOrDefaultAsync(p => p.ProjectId == projectId && p.UserId == userId && p.Screen == screen, ct);

    public Task<Dictionary<Guid, ProjectMemberPermission>> GetMemberPermissionsAsync(Guid projectId, string screen, CancellationToken ct = default) =>
        Db.ProjectMemberPermissions
            .Where(p => p.ProjectId == projectId && p.Screen == screen)
            .ToDictionaryAsync(p => p.UserId, ct);

    public void AddMemberPermission(ProjectMemberPermission permission) => Db.ProjectMemberPermissions.Add(permission);
}