Commit MWS backend source tree

The ASP.NET Core solution (mws.api/mws.application/mws.domain/
mws.infrastructure) existed only as untracked working files. Adding
it to version control, plus a .gitignore for build output and local
tooling directories, so the CQRS/mediator refactor plan has a real
git history to branch and diff against.

mws.application/Common/Exceptions.cs

@@ -0,0 +1,9 @@
+namespace Mws.Application.Common;
+
+public class NotFoundException(string message) : Exception(message);
+
+public class ForbiddenException(string message) : Exception(message);
+
+public class UnauthorizedException(string message) : Exception(message);
+
+public class BadRequestException(string message) : Exception(message);

mws.application/Common/IUnitOfWork.cs

@@ -0,0 +1,14 @@
+using Mws.Application.Common.Repositories;
+
+namespace Mws.Application.Common;
+
+public interface IUnitOfWork
+{
+    IUserRepository Users { get; }
+    IProjectRepository Projects { get; }
+    ITaskRepository Tasks { get; }
+    IDocumentRepository Documents { get; }
+    IRoleRepository Roles { get; }
+
+    Task<int> SaveChangesAsync(CancellationToken ct = default);
+}

mws.application/Common/MappingProfile.cs

@@ -0,0 +1,33 @@
+using AutoMapper;
+using Mws.Application.Accounts;
+using Mws.Application.Auth;
+using Mws.Application.Documents;
+using Mws.Application.Projects;
+using Mws.Application.Roles;
+using Mws.Application.Tasks;
+using Mws.Domain.Documents;
+using Mws.Domain.Roles;
+using Mws.Domain.Tasks;
+using Mws.Domain.Users;
+
+namespace Mws.Application.Common;
+
+public class MappingProfile : Profile
+{
+    public MappingProfile()
+    {
+        CreateMap<Domain.Projects.Project, ProjectDto>();
+        CreateMap<Role, RoleDto>();
+        CreateMap<RolePermission, PermissionEntryDto>();
+        CreateMap<User, AccountDto>();
+        CreateMap<User, UserDto>();
+        CreateMap<Document, DocumentDto>();
+        CreateMap<Document, DocumentNodeDto>()
+            .ForMember(d => d.Children, opt => opt.Ignore());
+        CreateMap<TaskItem, TaskDto>()
+            .ForMember(d => d.AssigneeName, opt => opt.MapFrom(s => s.Assignee == null ? null : s.Assignee.DisplayName));
+        CreateMap<TaskItem, RecentTaskDto>()
+            .ForMember(d => d.Status, opt => opt.MapFrom(s => s.Status.ToString()));
+        CreateMap<Document, RecentDocumentDto>();
+    }
+}

mws.application/Common/Repositories/IDocumentRepository.cs

@@ -0,0 +1,15 @@
+using Mws.Domain.Documents;
+
+namespace Mws.Application.Common.Repositories;
+
+public interface IDocumentRepository : IRepository<Document>
+{
+    Task<Document?> GetByIdAsync(Guid id, CancellationToken ct = default);
+    Task<List<Document>> GetTreeForProjectAsync(Guid projectId, CancellationToken ct = default);
+    Task<Document?> GetInProjectAsync(Guid parentId, Guid projectId, CancellationToken ct = default);
+    Task<Guid?> GetParentIdAsync(Guid documentId, CancellationToken ct = default);
+    Task<List<Document>> GetChildrenAsync(Guid parentId, CancellationToken ct = default);
+    Task<List<Document>> SearchAsync(List<Guid> projectIds, string? term, int take, CancellationToken ct = default);
+    Task<int> CountByTypeForProjectAsync(Guid projectId, DocumentType type, CancellationToken ct = default);
+    Task<List<Document>> GetRecentForProjectAsync(Guid projectId, DocumentType type, int take, CancellationToken ct = default);
+}

mws.application/Common/Repositories/IProjectRepository.cs

@@ -0,0 +1,28 @@
+using Mws.Domain.Projects;
+
+namespace Mws.Application.Common.Repositories;
+
+public interface IProjectRepository : IRepository<Project>
+{
+    Task<Project?> GetByIdAsync(Guid id, CancellationToken ct = default);
+    Task<Project?> GetForUserAsync(Guid userId, Guid projectId, CancellationToken ct = default);
+    Task<List<Project>> GetForUserAsync(Guid userId, CancellationToken ct = default);
+    Task<List<Project>> SearchForUserAsync(Guid userId, string? term, CancellationToken ct = default);
+    Task<int> CountMembersAsync(Guid projectId, CancellationToken ct = default);
+
+    Task<bool> IsMemberAsync(Guid projectId, Guid userId, CancellationToken ct = default);
+    Task<MemberRole?> GetMemberRoleAsync(Guid projectId, Guid userId, CancellationToken ct = default);
+    Task<ProjectMember?> GetMemberAsync(Guid projectId, Guid userId, CancellationToken ct = default);
+    Task<ProjectMember?> GetMemberWithUserAsync(Guid projectId, Guid userId, CancellationToken ct = default);
+    Task<List<ProjectMember>> GetMembersWithUserAsync(Guid projectId, CancellationToken ct = default);
+    Task<int> CountOwnersAsync(Guid projectId, CancellationToken ct = default);
+    Task<List<Guid>> GetProjectIdsForUserAsync(Guid userId, CancellationToken ct = default);
+    Task<List<Guid>> GetOwnedProjectIdsAsync(Guid userId, CancellationToken ct = default);
+    Task<List<Guid>> GetDocumentViewableProjectIdsAsync(Guid userId, CancellationToken ct = default);
+    void AddMember(ProjectMember member);
+    void RemoveMember(ProjectMember member);
+
+    Task<ProjectMemberPermission?> GetMemberPermissionAsync(Guid projectId, Guid userId, string screen, CancellationToken ct = default);
+    Task<Dictionary<Guid, ProjectMemberPermission>> GetMemberPermissionsAsync(Guid projectId, string screen, CancellationToken ct = default);
+    void AddMemberPermission(ProjectMemberPermission permission);
+}

mws.application/Common/Repositories/IRepository.cs

@@ -0,0 +1,7 @@
+namespace Mws.Application.Common.Repositories;
+
+public interface IRepository<in T> where T : class
+{
+    void Add(T entity);
+    void Remove(T entity);
+}

mws.application/Common/Repositories/IRoleRepository.cs

@@ -0,0 +1,14 @@
+using Mws.Domain.Roles;
+
+namespace Mws.Application.Common.Repositories;
+
+public interface IRoleRepository : IRepository<Role>
+{
+    Task<List<Role>> GetAllWithPermissionsAsync(CancellationToken ct = default);
+    Task<Role?> GetByIdWithPermissionsAsync(Guid id, CancellationToken ct = default);
+    Task<Role?> GetByIdAsync(Guid id, CancellationToken ct = default);
+    Task<bool> ExistsByNameAsync(string name, Guid? excludeId, CancellationToken ct = default);
+    Task<RolePermission?> GetPermissionAsync(Guid roleId, string screen, CancellationToken ct = default);
+    Task<Dictionary<string, RolePermission>> GetPermissionsAsync(Guid roleId, CancellationToken ct = default);
+    void RemovePermissions(IEnumerable<RolePermission> permissions);
+}

mws.application/Common/Repositories/ITaskRepository.cs

@@ -0,0 +1,16 @@
+using Mws.Domain.Tasks;
+using TaskPriority = Mws.Domain.Tasks.TaskPriority;
+using TaskStatus = Mws.Domain.Tasks.TaskStatus;
+
+namespace Mws.Application.Common.Repositories;
+
+public interface ITaskRepository : IRepository<TaskItem>
+{
+    Task<TaskItem?> GetByIdAsync(Guid id, CancellationToken ct = default);
+    Task<TaskItem?> GetWithAssigneeAsync(Guid id, CancellationToken ct = default);
+    Task<List<TaskItem>> GetForProjectAsync(
+        Guid projectId, TaskStatus? status, TaskPriority? priority, Guid? assigneeId, CancellationToken ct = default);
+    Task<List<TaskItem>> SearchWithAssigneeAsync(List<Guid> projectIds, string? term, int take, CancellationToken ct = default);
+    Task<Dictionary<TaskStatus, int>> CountByStatusForProjectAsync(Guid projectId, CancellationToken ct = default);
+    Task<List<TaskItem>> GetRecentForProjectAsync(Guid projectId, int take, CancellationToken ct = default);
+}

mws.application/Common/Repositories/IUserRepository.cs

@@ -0,0 +1,14 @@
+using Mws.Domain.Users;
+
+namespace Mws.Application.Common.Repositories;
+
+public interface IUserRepository : IRepository<User>
+{
+    Task<User?> GetByIdAsync(Guid id, CancellationToken ct = default);
+    Task<User?> GetByIdWithRoleAsync(Guid id, CancellationToken ct = default);
+    Task<User?> GetByUsernameWithRoleAsync(string username, CancellationToken ct = default);
+    Task<bool> ExistsByUsernameAsync(string username, CancellationToken ct = default);
+    Task<bool> ExistsByRoleIdAsync(Guid roleId, CancellationToken ct = default);
+    Task<Guid> GetRoleIdAsync(Guid userId, CancellationToken ct = default);
+    Task<List<User>> SearchWithRoleAsync(string? term, int? take, CancellationToken ct = default);
+}