mws/mws.backend.dotnet
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

ref: project structure

Browse Source
This commit is contained in:
namdh
2026-08-19 23:25:08 +07:00
parent 05a93cfc09
commit a1fe31cf70
155 changed files with 3339 additions and 1007 deletions
Download Patch File Download Diff File Expand all files Collapse all files
application/Projects/Commands/AddProjectMember.cs
+61
View File
@@ -0,0 +1,61 @@
using MediatR;
using mws.backend.dotnet.application.Common;
using mws.backend.dotnet.domain.Projects;
namespace mws.backend.dotnet.application.Projects;
public record AddProjectMemberCommand(Guid UserId, Guid ProjectId, AddMemberRequest Request) : IRequest<ProjectMemberDto>;
public class AddProjectMemberHandler(IUnitOfWork uow) : IRequestHandler<AddProjectMemberCommand, ProjectMemberDto>
{
public async Task<ProjectMemberDto> Handle(AddProjectMemberCommand command, CancellationToken ct)
{
if (await uow.Projects.GetMemberRoleAsync(command.ProjectId, command.UserId, ct) != MemberRole.Owner)
{
throw new ForbiddenException("Only the project owner can add members");
}
var request = command.Request;
var user = await uow.Users.GetByIdAsync(request.UserId, ct)
?? throw new NotFoundException("User not found");
var already = await uow.Projects.IsMemberAsync(command.ProjectId, request.UserId, ct);
if (already)
{
throw new BadRequestException("User is already a member of this project");
}
var role = request.Role is MemberRole.Owner or MemberRole.Member ? request.Role : MemberRole.Member;
var member = new ProjectMember
{
ProjectId = command.ProjectId,
UserId = request.UserId,
Role = role,
};
uow.Projects.AddMember(member);
uow.Projects.AddMemberPermission(new ProjectMemberPermission
{
ProjectId = command.ProjectId,
UserId = request.UserId,
Screen = ProjectPermissionScreens.Documents,
CanView = true,
CanCreate = role == MemberRole.Owner,
CanEdit = role == MemberRole.Owner,
CanDelete = role == MemberRole.Owner,
});
await uow.SaveChangesAsync(ct);
return new ProjectMemberDto
{
UserId = user.Id,
Username = user.Username,
DisplayName = user.DisplayName,
Role = member.Role,
CanViewDocuments = true,
CanCreateDocuments = role == MemberRole.Owner,
CanEditDocuments = role == MemberRole.Owner,
CanDeleteDocuments = role == MemberRole.Owner,
};
}
}
application/Projects/Commands/ArchiveProject.cs
+24
View File
@@ -0,0 +1,24 @@
using MediatR;
using mws.backend.dotnet.application.Common;
using mws.backend.dotnet.domain.Projects;
namespace mws.backend.dotnet.application.Projects;
public record ArchiveProjectCommand(Guid UserId, Guid ProjectId) : IRequest;
public class ArchiveProjectHandler(IUnitOfWork uow) : IRequestHandler<ArchiveProjectCommand>
{
public async Task Handle(ArchiveProjectCommand command, CancellationToken ct)
{
var project = await ProjectAccess.GetForUserOrThrowAsync(uow, command.UserId, command.ProjectId, ct);
if (await uow.Projects.GetMemberRoleAsync(command.ProjectId, command.UserId, ct) != MemberRole.Owner)
{
throw new ForbiddenException("Only the project owner can archive the project");
}
project.Status = ProjectStatus.Archived;
project.UpdatedAt = DateTime.UtcNow;
await uow.SaveChangesAsync(ct);
}
}
application/Projects/Commands/CreateProject.cs
+44
View File
@@ -0,0 +1,44 @@
using AutoMapper;
using MediatR;
using mws.backend.dotnet.application.Common;
using mws.backend.dotnet.domain.Projects;
namespace mws.backend.dotnet.application.Projects;
public record CreateProjectCommand(Guid UserId, CreateProjectRequest Request) : IRequest<ProjectDto>;
public class CreateProjectHandler(IUnitOfWork uow, IMapper mapper) : IRequestHandler<CreateProjectCommand, ProjectDto>
{
public async Task<ProjectDto> Handle(CreateProjectCommand command, CancellationToken ct)
{
var request = command.Request;
if (string.IsNullOrWhiteSpace(request.Name))
{
throw new BadRequestException("Project name is required");
}
var now = DateTime.UtcNow;
var project = new Project
{
Id = Guid.NewGuid(),
Name = request.Name.Trim(),
Description = request.Description,
Status = ProjectStatus.Active,
CreatedBy = command.UserId,
CreatedAt = now,
UpdatedBy = command.UserId,
UpdatedAt = now,
};
project.Members.Add(new ProjectMember
{
ProjectId = project.Id,
UserId = command.UserId,
Role = MemberRole.Owner,
});
uow.Projects.Add(project);
await uow.SaveChangesAsync(ct);
return mapper.Map<ProjectDto>(project);
}
}
application/Projects/Commands/RemoveProjectMember.cs
+31
View File
@@ -0,0 +1,31 @@
using MediatR;
using mws.backend.dotnet.application.Common;
using mws.backend.dotnet.domain.Projects;
namespace mws.backend.dotnet.application.Projects;
public record RemoveProjectMemberCommand(Guid UserId, Guid ProjectId, Guid MemberUserId) : IRequest;
public class RemoveProjectMemberHandler(IUnitOfWork uow) : IRequestHandler<RemoveProjectMemberCommand>
{
public async Task Handle(RemoveProjectMemberCommand command, CancellationToken ct)
{
if (await uow.Projects.GetMemberRoleAsync(command.ProjectId, command.UserId, ct) != MemberRole.Owner)
{
throw new ForbiddenException("Only the project owner can remove members");
}
var member = await uow.Projects.GetMemberAsync(command.ProjectId, command.MemberUserId, ct)
?? throw new NotFoundException("Member not found in project");
var owners = await uow.Projects.CountOwnersAsync(command.ProjectId, ct);
if (member.Role == MemberRole.Owner && owners <= 1)
{
throw new BadRequestException("Cannot remove the last owner of the project");
}
uow.Projects.RemoveMember(member);
await uow.SaveChangesAsync(ct);
}
}
application/Projects/Commands/UpdateMemberDocumentPermissions.cs
+54
View File
@@ -0,0 +1,54 @@
using MediatR;
using mws.backend.dotnet.application.Common;
using mws.backend.dotnet.domain.Projects;
namespace mws.backend.dotnet.application.Projects;
public record UpdateMemberDocumentPermissionsCommand(
Guid UserId, Guid ProjectId, Guid MemberUserId, UpdateMemberDocumentPermissionsRequest Request) : IRequest<ProjectMemberDto>;
public class UpdateMemberDocumentPermissionsHandler(IUnitOfWork uow)
: IRequestHandler<UpdateMemberDocumentPermissionsCommand, ProjectMemberDto>
{
public async Task<ProjectMemberDto> Handle(UpdateMemberDocumentPermissionsCommand command, CancellationToken ct)
{
if (await uow.Projects.GetMemberRoleAsync(command.ProjectId, command.UserId, ct) != MemberRole.Owner)
{
throw new ForbiddenException("Only the project owner can change member permissions");
}
var member = await uow.Projects.GetMemberWithUserAsync(command.ProjectId, command.MemberUserId, ct)
?? throw new NotFoundException("Member not found in project");
if (member.Role == MemberRole.Owner)
{
throw new BadRequestException("Owner permissions cannot be changed");
}
var permission = await uow.Projects.GetMemberPermissionAsync(command.ProjectId, command.MemberUserId, ProjectPermissionScreens.Documents, ct);
if (permission is null)
{
permission = new ProjectMemberPermission { ProjectId = command.ProjectId, UserId = command.MemberUserId, Screen = ProjectPermissionScreens.Documents };
uow.Projects.AddMemberPermission(permission);
}
var request = command.Request;
permission.CanView = request.CanViewDocuments;
permission.CanCreate = request.CanCreateDocuments;
permission.CanEdit = request.CanEditDocuments;
permission.CanDelete = request.CanDeleteDocuments;
await uow.SaveChangesAsync(ct);
return new ProjectMemberDto
{
UserId = member.UserId,
Username = member.User.Username,
DisplayName = member.User.DisplayName,
Role = member.Role,
CanViewDocuments = permission.CanView,
CanCreateDocuments = permission.CanCreate,
CanEditDocuments = permission.CanEdit,
CanDeleteDocuments = permission.CanDelete,
};
}
}
application/Projects/Commands/UpdateProject.cs
+36
View File
@@ -0,0 +1,36 @@
using AutoMapper;
using MediatR;
using mws.backend.dotnet.application.Common;
using mws.backend.dotnet.domain.Projects;
namespace mws.backend.dotnet.application.Projects;
public record UpdateProjectCommand(Guid UserId, Guid ProjectId, UpdateProjectRequest Request) : IRequest<ProjectDto>;
public class UpdateProjectHandler(IUnitOfWork uow, IMapper mapper) : IRequestHandler<UpdateProjectCommand, ProjectDto>
{
public async Task<ProjectDto> Handle(UpdateProjectCommand command, CancellationToken ct)
{
var project = await ProjectAccess.GetForUserOrThrowAsync(uow, command.UserId, command.ProjectId, ct);
if (MemberRole.Owner != await uow.Projects.GetMemberRoleAsync(command.ProjectId, command.UserId, ct))
{
throw new ForbiddenException("Only the project owner can update the project");
}
var request = command.Request;
if (string.IsNullOrWhiteSpace(request.Name))
{
throw new BadRequestException("Project name is required");
}
project.Name = request.Name.Trim();
project.Description = request.Description;
project.Status = request.Status;
project.UpdatedBy = command.UserId;
project.UpdatedAt = DateTime.UtcNow;
await uow.SaveChangesAsync(ct);
return mapper.Map<ProjectDto>(project);
}
}
application/Projects/Contracts.cs
+81
View File
@@ -0,0 +1,81 @@
using mws.backend.dotnet.domain.Projects;
namespace mws.backend.dotnet.application.Projects;
public class CreateProjectRequest
{
public string Name { get; set; } = string.Empty;
public string? Description { get; set; }
}
public class UpdateProjectRequest
{
public string Name { get; set; } = string.Empty;
public string? Description { get; set; }
public ProjectStatus Status { get; set; } = ProjectStatus.Active;
}
public class AddMemberRequest
{
public Guid UserId { get; set; }
public MemberRole Role { get; set; } = MemberRole.Member;
}
public class ProjectMemberDto
{
public Guid UserId { get; set; }
public string Username { get; set; } = string.Empty;
public string DisplayName { get; set; } = string.Empty;
public MemberRole Role { get; set; }
public bool CanViewDocuments { get; set; }
public bool CanCreateDocuments { get; set; }
public bool CanEditDocuments { get; set; }
public bool CanDeleteDocuments { get; set; }
}
public class UpdateMemberDocumentPermissionsRequest
{
public bool CanViewDocuments { get; set; }
public bool CanCreateDocuments { get; set; }
public bool CanEditDocuments { get; set; }
public bool CanDeleteDocuments { get; set; }
}
public class ProjectDto
{
public Guid Id { get; set; }
public string Name { get; set; } = string.Empty;
public string? Description { get; set; }
public ProjectStatus Status { get; set; }
public Guid CreatedBy { get; set; }
public string CreatedByName { get; set; } = string.Empty;
public DateTime CreatedAt { get; set; }
public Guid? UpdatedBy { get; set; }
public string? UpdatedByName { get; set; }
public DateTime UpdatedAt { get; set; }
}
public class ProjectOverviewDto
{
public ProjectDto Project { get; set; } = null!;
public int MemberCount { get; set; }
public int DocumentCount { get; set; }
public Dictionary<string, int> TaskCountsByStatus { get; set; } = [];
public List<RecentTaskDto> RecentTasks { get; set; } = [];
public List<RecentDocumentDto> RecentDocuments { get; set; } = [];
}
public class RecentTaskDto
{
public Guid Id { get; set; }
public string Title { get; set; } = string.Empty;
public string Status { get; set; } = string.Empty;
public DateTime UpdatedAt { get; set; }
}
public class RecentDocumentDto
{
public Guid Id { get; set; }
public string Title { get; set; } = string.Empty;
public DateTime UpdatedAt { get; set; }
}
application/Projects/ProjectAccess.cs
+13
View File
@@ -0,0 +1,13 @@
using mws.backend.dotnet.application.Common;
using mws.backend.dotnet.domain.Projects;
namespace mws.backend.dotnet.application.Projects;
internal static class ProjectAccess
{
public static async Task<Project> GetForUserOrThrowAsync(IUnitOfWork uow, Guid userId, Guid projectId, CancellationToken ct)
{
return await uow.Projects.GetForUserAsync(userId, projectId, ct)
?? throw new NotFoundException("Project not found");
}
}
application/Projects/Queries/GetProject.cs
+16
View File
@@ -0,0 +1,16 @@
using AutoMapper;
using MediatR;
using mws.backend.dotnet.application.Common;
namespace mws.backend.dotnet.application.Projects;
public record GetProjectQuery(Guid UserId, Guid ProjectId) : IRequest<ProjectDto>;
public class GetProjectHandler(IUnitOfWork uow, IMapper mapper) : IRequestHandler<GetProjectQuery, ProjectDto>
{
public async Task<ProjectDto> Handle(GetProjectQuery query, CancellationToken ct)
{
var project = await ProjectAccess.GetForUserOrThrowAsync(uow, query.UserId, query.ProjectId, ct);
return mapper.Map<ProjectDto>(project);
}
}
application/Projects/Queries/GetProjectMembers.cs
+46
View File
@@ -0,0 +1,46 @@
using MediatR;
using mws.backend.dotnet.application.Common;
using mws.backend.dotnet.domain.Projects;
namespace mws.backend.dotnet.application.Projects;
public record GetProjectMembersQuery(Guid UserId, Guid ProjectId, int Page, int PageSize) : IRequest<PagedResult<ProjectMemberDto>>;
public class GetProjectMembersHandler(IUnitOfWork uow) : IRequestHandler<GetProjectMembersQuery, PagedResult<ProjectMemberDto>>
{
public async Task<PagedResult<ProjectMemberDto>> Handle(GetProjectMembersQuery query, CancellationToken ct)
{
var isMember = await uow.Projects.IsMemberAsync(query.ProjectId, query.UserId, ct);
if (!isMember)
{
throw new NotFoundException("Project not found");
}
var members = await uow.Projects.GetMembersWithUserAsync(query.ProjectId, query.Page, query.PageSize, ct);
var permissions = await uow.Projects.GetMemberPermissionsAsync(query.ProjectId, ProjectPermissionScreens.Documents, ct);
var items = members.Items.Select(m =>
{
permissions.TryGetValue(m.UserId, out var p);
return new ProjectMemberDto
{
UserId = m.UserId,
Username = m.User.Username,
DisplayName = m.User.DisplayName,
Role = m.Role,
CanViewDocuments = m.Role == MemberRole.Owner || (p?.CanView ?? false),
CanCreateDocuments = m.Role == MemberRole.Owner || (p?.CanCreate ?? false),
CanEditDocuments = m.Role == MemberRole.Owner || (p?.CanEdit ?? false),
CanDeleteDocuments = m.Role == MemberRole.Owner || (p?.CanDelete ?? false),
};
}).ToList();
return new PagedResult<ProjectMemberDto>
{
Items = items,
TotalCount = members.TotalCount,
Page = members.Page,
PageSize = members.PageSize,
};
}
}
application/Projects/Queries/GetProjectOverview.cs
+35
View File
@@ -0,0 +1,35 @@
using AutoMapper;
using MediatR;
using mws.backend.dotnet.application.Common;
using mws.backend.dotnet.domain.Documents;
namespace mws.backend.dotnet.application.Projects;
public record GetProjectOverviewQuery(Guid UserId, Guid ProjectId) : IRequest<ProjectOverviewDto>;
public class GetProjectOverviewHandler(IUnitOfWork uow, IMapper mapper) : IRequestHandler<GetProjectOverviewQuery, ProjectOverviewDto>
{
public async Task<ProjectOverviewDto> Handle(GetProjectOverviewQuery query, CancellationToken ct)
{
var project = await ProjectAccess.GetForUserOrThrowAsync(uow, query.UserId, query.ProjectId, ct);
var memberCount = await uow.Projects.CountMembersAsync(query.ProjectId, ct);
var documentCount = await uow.Documents.CountByTypeForProjectAsync(query.ProjectId, DocumentType.Document, ct);
var taskCounts = await uow.Tasks.CountByStatusForProjectAsync(query.ProjectId, ct);
var taskCountsByStatus = taskCounts.ToDictionary(kv => kv.Key.ToString(), kv => kv.Value);
var recentTasks = await uow.Tasks.GetRecentForProjectAsync(query.ProjectId, 5, ct);
var recentDocuments = await uow.Documents.GetRecentForProjectAsync(query.ProjectId, DocumentType.Document, 5, ct);
return new ProjectOverviewDto
{
Project = mapper.Map<ProjectDto>(project),
MemberCount = memberCount,
DocumentCount = documentCount,
TaskCountsByStatus = taskCountsByStatus,
RecentTasks = mapper.Map<List<RecentTaskDto>>(recentTasks),
RecentDocuments = mapper.Map<List<RecentDocumentDto>>(recentDocuments),
};
}
}
application/Projects/Queries/GetProjects.cs
+22
View File
@@ -0,0 +1,22 @@
using AutoMapper;
using MediatR;
using mws.backend.dotnet.application.Common;
namespace mws.backend.dotnet.application.Projects;
public record GetProjectsQuery(Guid UserId, int Page, int PageSize) : IRequest<PagedResult<ProjectDto>>;
public class GetProjectsHandler(IUnitOfWork uow, IMapper mapper) : IRequestHandler<GetProjectsQuery, PagedResult<ProjectDto>>
{
public async Task<PagedResult<ProjectDto>> Handle(GetProjectsQuery query, CancellationToken ct)
{
var projects = await uow.Projects.GetForUserAsync(query.UserId, query.Page, query.PageSize, ct);
return new PagedResult<ProjectDto>
{
Items = mapper.Map<List<ProjectDto>>(projects.Items),
TotalCount = projects.TotalCount,
Page = projects.Page,
PageSize = projects.PageSize,
};
}
}
application/Projects/Queries/SearchProjects.cs
+16
View File
@@ -0,0 +1,16 @@
using AutoMapper;
using MediatR;
using mws.backend.dotnet.application.Common;
namespace mws.backend.dotnet.application.Projects;
public record SearchProjectsQuery(Guid UserId, string Term) : IRequest<List<ProjectDto>>;
public class SearchProjectsHandler(IUnitOfWork uow, IMapper mapper) : IRequestHandler<SearchProjectsQuery, List<ProjectDto>>
{
public async Task<List<ProjectDto>> Handle(SearchProjectsQuery query, CancellationToken ct)
{
var projects = await uow.Projects.SearchForUserAsync(query.UserId, query.Term, ct);
return mapper.Map<List<ProjectDto>>(projects);
}
}