ref: project structure

2026-08-19 23:25:08 +07:00
parent 05a93cfc09
commit a1fe31cf70
155 changed files with 3339 additions and 1007 deletions
@@ -0,0 +1,27 @@
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using mws.backend.dotnet.application.Auth;
+using mws.backend.dotnet.application.Users;
+
+namespace mws.backend.dotnet.api.Controllers;
+
+[ApiController]
+[Route("api/auth")]
+public class AuthController(ISender sender) : ControllerBase
+{
+    [HttpPost("login")]
+    [AllowAnonymous]
+    public async Task<ActionResult<LoginResponse>> Login([FromBody] LoginRequest request, CancellationToken ct)
+    {
+        var response = await sender.Send(new LoginCommand(request), ct);
+        return Ok(response);
+    }
+
+    [HttpGet("me")]
+    [Authorize]
+    public async Task<ActionResult<UserDto>> GetProfile(CancellationToken ct)
+    {
+        return Ok(await sender.Send(new GetProfileQuery(User.GetUserId()), ct));
+    }
+}
@@ -0,0 +1,57 @@
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using mws.backend.dotnet.application.Documents;
+
+namespace mws.backend.dotnet.api.Controllers;
+
+[ApiController]
+[Route("api")]
+[Authorize]
+public class DocumentsController(ISender sender) : ControllerBase
+{
+    [HttpGet("documents/search")]
+    public async Task<ActionResult<List<DocumentNodeDto>>> Search([FromQuery] string? q, CancellationToken ct)
+    {
+        return Ok(await sender.Send(new SearchDocumentsQuery(User.GetUserId(), q ?? string.Empty), ct));
+    }
+
+    [HttpGet("projects/{projectId:guid}/documents")]
+    public async Task<ActionResult<List<DocumentNodeDto>>> GetTree(Guid projectId, CancellationToken ct)
+    {
+        return Ok(await sender.Send(new GetDocumentTreeQuery(User.GetUserId(), projectId), ct));
+    }
+
+    [HttpPost("projects/{projectId:guid}/documents")]
+    public async Task<ActionResult<DocumentDto>> Create(Guid projectId, [FromBody] CreateDocumentRequest request, CancellationToken ct)
+    {
+        var result = await sender.Send(new CreateDocumentCommand(User.GetUserId(), projectId, request), ct);
+        return CreatedAtAction(nameof(Get), new { id = result.Id }, result);
+    }
+
+    [HttpGet("documents/{id:guid}")]
+    public async Task<ActionResult<DocumentDto>> Get(Guid id, CancellationToken ct)
+    {
+        return Ok(await sender.Send(new GetDocumentQuery(User.GetUserId(), id), ct));
+    }
+
+    [HttpPut("documents/{id:guid}")]
+    public async Task<ActionResult<DocumentDto>> Update(Guid id, [FromBody] UpdateDocumentRequest request, CancellationToken ct)
+    {
+        return Ok(await sender.Send(new UpdateDocumentCommand(User.GetUserId(), id, request), ct));
+    }
+
+    [HttpPut("documents/{id:guid}/move")]
+    public async Task<ActionResult<DocumentDto>> Move(Guid id, [FromBody] MoveDocumentRequest request, CancellationToken ct)
+    {
+        await sender.Send(new MoveDocumentCommand(User.GetUserId(), id, request.NewParentId), ct);
+        return Ok(await sender.Send(new GetDocumentQuery(User.GetUserId(), id), ct));
+    }
+
+    [HttpDelete("documents/{id:guid}")]
+    public async Task<IActionResult> Delete(Guid id, CancellationToken ct)
+    {
+        await sender.Send(new DeleteDocumentCommand(User.GetUserId(), id), ct);
+        return NoContent();
+    }
+}
@@ -0,0 +1,50 @@
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using mws.backend.dotnet.application.Common;
+using mws.backend.dotnet.application.MasterData;
+using mws.backend.dotnet.application.Permissions;
+
+namespace mws.backend.dotnet.api.Controllers;
+
+[ApiController]
+[Route("api/masterdata")]
+[Authorize]
+public class MasterDataController(ISender sender, IPermissionService permissions) : ControllerBase
+{
+    [HttpGet("groups/{group}")]
+    public async Task<ActionResult<List<MasterDataDto>>> GetByGroup(string group, CancellationToken ct)
+    {
+        return Ok(await sender.Send(new GetMasterDataByGroupQuery(group), ct));
+    }
+
+    [HttpGet]
+    public async Task<ActionResult<PagedResult<MasterDataDto>>> GetAll(
+        [FromQuery] string? group, [FromQuery] int page = 1, [FromQuery] int pageSize = 20, CancellationToken ct = default)
+    {
+        await permissions.EnsureAsync(User.GetUserId(), "masterdata", PermissionAction.View, ct);
+        return Ok(await sender.Send(new GetMasterDataListQuery(group, page, pageSize), ct));
+    }
+
+    [HttpPost]
+    public async Task<ActionResult<MasterDataDto>> Create([FromBody] SaveMasterDataRequest request, CancellationToken ct)
+    {
+        await permissions.EnsureAsync(User.GetUserId(), "masterdata", PermissionAction.Create, ct);
+        return Ok(await sender.Send(new CreateMasterDataCommand(request), ct));
+    }
+
+    [HttpPut("{id:guid}")]
+    public async Task<ActionResult<MasterDataDto>> Update(Guid id, [FromBody] SaveMasterDataRequest request, CancellationToken ct)
+    {
+        await permissions.EnsureAsync(User.GetUserId(), "masterdata", PermissionAction.Edit, ct);
+        return Ok(await sender.Send(new UpdateMasterDataCommand(id, request), ct));
+    }
+
+    [HttpDelete("{id:guid}")]
+    public async Task<IActionResult> Delete(Guid id, CancellationToken ct)
+    {
+        await permissions.EnsureAsync(User.GetUserId(), "masterdata", PermissionAction.Delete, ct);
+        await sender.Send(new DeleteMasterDataCommand(id), ct);
+        return NoContent();
+    }
+}
@@ -0,0 +1,55 @@
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using mws.backend.dotnet.application.Common;
+using mws.backend.dotnet.application.Permissions;
+
+namespace mws.backend.dotnet.api.Controllers;
+
+[ApiController]
+[Route("api/settings/permission")]
+[Authorize]
+public class PermissionsController(ISender sender, IPermissionService permissions) : ControllerBase
+{
+    [HttpGet("menu")]
+    public async Task<ActionResult<List<MenuItemDto>>> GetMenu(CancellationToken ct)
+    {
+        return Ok(await permissions.GetMenuAsync(User.GetUserId(), ct));
+    }
+
+    [HttpGet]
+    public async Task<ActionResult<PagedResult<RoleDto>>> GetAll([FromQuery] int page = 1, [FromQuery] int pageSize = 20, CancellationToken ct = default)
+    {
+        await permissions.EnsureAsync(User.GetUserId(), "permissions", PermissionAction.View, ct);
+        return Ok(await sender.Send(new GetRolesQuery(page, pageSize), ct));
+    }
+
+    [HttpGet("{id:guid}")]
+    public async Task<ActionResult<RoleDto>> Get(Guid id, CancellationToken ct)
+    {
+        await permissions.EnsureAsync(User.GetUserId(), "permissions", PermissionAction.View, ct);
+        return Ok(await sender.Send(new GetRoleQuery(id), ct));
+    }
+
+    [HttpPost]
+    public async Task<ActionResult<RoleDto>> Create([FromBody] SaveRoleRequest request, CancellationToken ct)
+    {
+        await permissions.EnsureAsync(User.GetUserId(), "permissions", PermissionAction.Create, ct);
+        return Ok(await sender.Send(new CreateRoleCommand(request), ct));
+    }
+
+    [HttpPut("{id:guid}")]
+    public async Task<ActionResult<RoleDto>> Update(Guid id, [FromBody] SaveRoleRequest request, CancellationToken ct)
+    {
+        await permissions.EnsureAsync(User.GetUserId(), "permissions", PermissionAction.Edit, ct);
+        return Ok(await sender.Send(new UpdateRoleCommand(id, request), ct));
+    }
+
+    [HttpDelete("{id:guid}")]
+    public async Task<IActionResult> Delete(Guid id, CancellationToken ct)
+    {
+        await permissions.EnsureAsync(User.GetUserId(), "permissions", PermissionAction.Delete, ct);
+        await sender.Send(new DeleteRoleCommand(id), ct);
+        return NoContent();
+    }
+}
@@ -0,0 +1,40 @@
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using mws.backend.dotnet.application.Common;
+using mws.backend.dotnet.application.Projects;
+
+namespace mws.backend.dotnet.api.Controllers;
+
+[ApiController]
+[Route("api/projects/{projectId:guid}/members")]
+[Authorize]
+public class ProjectMembersController(ISender sender) : ControllerBase
+{
+    [HttpGet]
+    public async Task<ActionResult<PagedResult<ProjectMemberDto>>> GetAll(
+        Guid projectId, [FromQuery] int page = 1, [FromQuery] int pageSize = 20, CancellationToken ct = default)
+    {
+        return Ok(await sender.Send(new GetProjectMembersQuery(User.GetUserId(), projectId, page, pageSize), ct));
+    }
+
+    [HttpPost]
+    public async Task<ActionResult<ProjectMemberDto>> Add(Guid projectId, [FromBody] AddMemberRequest request, CancellationToken ct)
+    {
+        return Ok(await sender.Send(new AddProjectMemberCommand(User.GetUserId(), projectId, request), ct));
+    }
+
+    [HttpPut("{userId:guid}/document-permissions")]
+    public async Task<ActionResult<ProjectMemberDto>> UpdateDocumentPermissions(
+        Guid projectId, Guid userId, [FromBody] UpdateMemberDocumentPermissionsRequest request, CancellationToken ct)
+    {
+        return Ok(await sender.Send(new UpdateMemberDocumentPermissionsCommand(User.GetUserId(), projectId, userId, request), ct));
+    }
+
+    [HttpDelete("{userId:guid}")]
+    public async Task<IActionResult> Remove(Guid projectId, Guid userId, CancellationToken ct)
+    {
+        await sender.Send(new RemoveProjectMemberCommand(User.GetUserId(), projectId, userId), ct);
+        return NoContent();
+    }
+}
@@ -0,0 +1,57 @@
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using mws.backend.dotnet.application.Common;
+using mws.backend.dotnet.application.Projects;
+
+namespace mws.backend.dotnet.api.Controllers;
+
+[ApiController]
+[Route("api/projects")]
+[Authorize]
+public class ProjectsController(ISender sender) : ControllerBase
+{
+    [HttpGet]
+    public async Task<ActionResult<PagedResult<ProjectDto>>> GetAll([FromQuery] int page = 1, [FromQuery] int pageSize = 20, CancellationToken ct = default)
+    {
+        return Ok(await sender.Send(new GetProjectsQuery(User.GetUserId(), page, pageSize), ct));
+    }
+
+    [HttpGet("search")]
+    public async Task<ActionResult<List<ProjectDto>>> Search([FromQuery] string? q, CancellationToken ct)
+    {
+        return Ok(await sender.Send(new SearchProjectsQuery(User.GetUserId(), q ?? string.Empty), ct));
+    }
+
+    [HttpGet("{projectId:guid}")]
+    public async Task<ActionResult<ProjectDto>> Get(Guid projectId, CancellationToken ct)
+    {
+        return Ok(await sender.Send(new GetProjectQuery(User.GetUserId(), projectId), ct));
+    }
+
+    [HttpGet("{projectId:guid}/overview")]
+    public async Task<ActionResult<ProjectOverviewDto>> Overview(Guid projectId, CancellationToken ct)
+    {
+        return Ok(await sender.Send(new GetProjectOverviewQuery(User.GetUserId(), projectId), ct));
+    }
+
+    [HttpPost]
+    public async Task<ActionResult<ProjectDto>> Create([FromBody] CreateProjectRequest request, CancellationToken ct)
+    {
+        var result = await sender.Send(new CreateProjectCommand(User.GetUserId(), request), ct);
+        return CreatedAtAction(nameof(Get), new { projectId = result.Id }, result);
+    }
+
+    [HttpPut("{projectId:guid}")]
+    public async Task<ActionResult<ProjectDto>> Update(Guid projectId, [FromBody] UpdateProjectRequest request, CancellationToken ct)
+    {
+        return Ok(await sender.Send(new UpdateProjectCommand(User.GetUserId(), projectId, request), ct));
+    }
+
+    [HttpDelete("{projectId:guid}")]
+    public async Task<IActionResult> Delete(Guid projectId, CancellationToken ct)
+    {
+        await sender.Send(new ArchiveProjectCommand(User.GetUserId(), projectId), ct);
+        return NoContent();
+    }
+}
@@ -0,0 +1,71 @@
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using mws.backend.dotnet.application.Common;
+using mws.backend.dotnet.application.Tasks;
+using TaskPriority = mws.backend.dotnet.domain.Tasks.TaskPriority;
+using TaskStatus = mws.backend.dotnet.domain.Tasks.TaskStatus;
+
+namespace mws.backend.dotnet.api.Controllers;
+
+[ApiController]
+[Route("api")]
+[Authorize]
+public class TasksController(ISender sender) : ControllerBase
+{
+    [HttpGet("tasks/search")]
+    public async Task<ActionResult<List<TaskDto>>> Search([FromQuery] string? q, CancellationToken ct)
+    {
+        return Ok(await sender.Send(new SearchTasksQuery(User.GetUserId(), q ?? string.Empty), ct));
+    }
+
+    [HttpGet("projects/{projectId:guid}/tasks")]
+    public async Task<ActionResult<PagedResult<TaskDto>>> GetAll(
+        Guid projectId,
+        [FromQuery] string? status,
+        [FromQuery] string? priority,
+        [FromQuery] Guid? assigneeId,
+        [FromQuery] int page = 1,
+        [FromQuery] int pageSize = 20,
+        CancellationToken ct = default)
+    {
+        var statusValue = ParseOptional<TaskStatus>(status);
+        var priorityValue = ParseOptional<TaskPriority>(priority);
+        return Ok(await sender.Send(new GetTasksQuery(User.GetUserId(), projectId, statusValue, priorityValue, assigneeId, page, pageSize), ct));
+    }
+
+    [HttpPost("projects/{projectId:guid}/tasks")]
+    public async Task<ActionResult<TaskDto>> Create(Guid projectId, [FromBody] CreateTaskRequest request, CancellationToken ct)
+    {
+        var result = await sender.Send(new CreateTaskCommand(User.GetUserId(), projectId, request), ct);
+        return CreatedAtAction(nameof(Get), new { id = result.Id }, result);
+    }
+
+    [HttpGet("tasks/{id:guid}")]
+    public async Task<ActionResult<TaskDto>> Get(Guid id, CancellationToken ct)
+    {
+        return Ok(await sender.Send(new GetTaskQuery(User.GetUserId(), id), ct));
+    }
+
+    [HttpPut("tasks/{id:guid}")]
+    public async Task<ActionResult<TaskDto>> Update(Guid id, [FromBody] UpdateTaskRequest request, CancellationToken ct)
+    {
+        return Ok(await sender.Send(new UpdateTaskCommand(User.GetUserId(), id, request), ct));
+    }
+
+    [HttpDelete("tasks/{id:guid}")]
+    public async Task<IActionResult> Delete(Guid id, CancellationToken ct)
+    {
+        await sender.Send(new DeleteTaskCommand(User.GetUserId(), id), ct);
+        return NoContent();
+    }
+
+    private static TEnum? ParseOptional<TEnum>(string? value) where TEnum : struct, Enum
+    {
+        if (string.IsNullOrWhiteSpace(value))
+        {
+            return null;
+        }
+        return Enum.TryParse<TEnum>(value, ignoreCase: true, out var result) ? result : throw new BadRequestException($"Invalid {typeof(TEnum).Name}: {value}");
+    }
+}
@@ -0,0 +1,161 @@
+using AutoMapper;
+using MediatR;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using mws.backend.dotnet.application.Common;
+using mws.backend.dotnet.application.Permissions;
+using mws.backend.dotnet.application.Users;
+using mws.backend.dotnet.domain.Users;
+using mws.backend.dotnet.infrastructure.Persistence;
+
+namespace mws.backend.dotnet.api.Controllers;
+
+[ApiController]
+[Route("api/users")]
+[Authorize]
+public class UsersController(ISender sender, AppDbContext db, IPermissionService permissions, IMapper mapper) : ControllerBase
+{
+    [HttpGet]
+    public async Task<ActionResult<PagedResult<UserDto>>> GetAll([FromQuery] string? q, [FromQuery] int page = 1, [FromQuery] int pageSize = 20, CancellationToken ct = default)
+    {
+        return Ok(await sender.Send(new GetUsersQuery(User.GetUserId(), q, page, pageSize), ct));
+    }
+
+    [HttpPost]
+    public async Task<ActionResult<UserDto>> Create([FromBody] CreateUserRequest request, CancellationToken ct)
+    {
+        return Ok(await sender.Send(new CreateUserCommand(User.GetUserId(), request), ct));
+    }
+
+    [HttpPut("{id:guid}")]
+    public async Task<ActionResult<UserDto>> Update(Guid id, [FromBody] UpdateUserRequest request, CancellationToken ct)
+    {
+        return Ok(await sender.Send(new UpdateUserCommand(User.GetUserId(), id, request), ct));
+    }
+
+    [HttpDelete("{id:guid}")]
+    public async Task<IActionResult> Delete(Guid id, CancellationToken ct)
+    {
+        await sender.Send(new DeleteUserCommand(User.GetUserId(), id), ct);
+        return NoContent();
+    }
+
+    [HttpPost("{id:guid}/reset-password")]
+    public async Task<IActionResult> ResetPassword(Guid id, [FromBody] ResetPasswordRequest request, CancellationToken ct)
+    {
+        await sender.Send(new ResetPasswordCommand(User.GetUserId(), id, request), ct);
+        return NoContent();
+    }
+
+    [HttpGet("list")]
+    public async Task<ActionResult<List<UserDto>>> GetList([FromQuery] string? q, CancellationToken ct)
+    {
+        var query = db.Users.AsQueryable();
+        if (!string.IsNullOrWhiteSpace(q))
+        {
+            var lower = q.Trim().ToLower();
+            query = query.Where(u => u.Username.ToLower().Contains(lower) || u.DisplayName.ToLower().Contains(lower));
+        }
+
+        var users = await query.OrderBy(u => u.DisplayName).ToListAsync(ct);
+        return Ok(mapper.Map<List<UserDto>>(users));
+    }
+
+    [HttpGet("{id:guid}/roles")]
+    public async Task<ActionResult<UserRoleDetailDto>> GetUserRoles(Guid id, CancellationToken ct)
+    {
+        await permissions.EnsureAsync(User.GetUserId(), "permissions", PermissionAction.View, ct);
+
+        var user = await db.Users
+            .Include(u => u.UserRoles)
+            .ThenInclude(ur => ur.Role)
+            .FirstOrDefaultAsync(u => u.Id == id, ct);
+
+        if (user is null) return NotFound("User not found");
+
+        var allRoles = await db.Roles.Include(r => r.Permissions).OrderBy(r => r.Name).ToListAsync(ct);
+        var assignedRoleIds = user.UserRoles.Select(ur => ur.RoleId).ToHashSet();
+
+        var assigned = allRoles.Where(r => assignedRoleIds.Contains(r.Id)).ToList();
+        var unassigned = allRoles.Where(r => !assignedRoleIds.Contains(r.Id)).ToList();
+
+        return Ok(new UserRoleDetailDto
+        {
+            UserId = user.Id,
+            Username = user.Username,
+            DisplayName = user.DisplayName,
+            AssignedRoles = mapper.Map<List<RoleDto>>(assigned),
+            UnassignedRoles = mapper.Map<List<RoleDto>>(unassigned)
+        });
+    }
+
+    [HttpPost("{id:guid}/roles")]
+    public async Task<IActionResult> AssignRole(Guid id, [FromBody] AssignRoleRequest req, CancellationToken ct)
+    {
+        await permissions.EnsureAsync(User.GetUserId(), "permissions", PermissionAction.Edit, ct);
+
+        var user = await db.Users.Include(u => u.UserRoles).FirstOrDefaultAsync(u => u.Id == id, ct);
+        if (user is null) return NotFound("User not found");
+
+        if (!user.UserRoles.Any(ur => ur.RoleId == req.RoleId))
+        {
+            user.UserRoles.Add(new UserRole { UserId = id, RoleId = req.RoleId });
+            await db.SaveChangesAsync(ct);
+        }
+
+        return NoContent();
+    }
+
+    [HttpDelete("{id:guid}/roles/{roleId:guid}")]
+    public async Task<IActionResult> UnassignRole(Guid id, Guid roleId, CancellationToken ct)
+    {
+        await permissions.EnsureAsync(User.GetUserId(), "permissions", PermissionAction.Edit, ct);
+
+        var ur = await db.UserRoles.FirstOrDefaultAsync(x => x.UserId == id && x.RoleId == roleId, ct);
+        if (ur != null)
+        {
+            db.UserRoles.Remove(ur);
+            await db.SaveChangesAsync(ct);
+        }
+
+        return NoContent();
+    }
+
+    [HttpGet("{id:guid}/permissions")]
+    public async Task<ActionResult<List<MenuItemDto>>> GetUserPermissions(Guid id, CancellationToken ct)
+    {
+        await permissions.EnsureAsync(User.GetUserId(), "permissions", PermissionAction.View, ct);
+
+        var roleIds = await db.UserRoles.Where(ur => ur.UserId == id).Select(ur => ur.RoleId).ToListAsync(ct);
+        var permissionsList = await db.RolePermissions.Where(p => roleIds.Contains(p.RoleId)).ToListAsync(ct);
+
+        var merged = permissionsList.GroupBy(p => p.Screen).ToDictionary(
+            g => g.Key,
+            g => new
+            {
+                CanView = g.Any(p => p.CanView),
+                CanCreate = g.Any(p => p.CanCreate),
+                CanEdit = g.Any(p => p.CanEdit),
+                CanDelete = g.Any(p => p.CanDelete),
+            }
+        );
+
+        var res = ScreenCatalog.Screens.Select(s =>
+        {
+            merged.TryGetValue(s.Key, out var p);
+            return new MenuItemDto
+            {
+                Key = s.Key,
+                Label = s.Label,
+                Path = s.Path,
+                CanView = p?.CanView ?? false,
+                CanCreate = p?.CanCreate ?? false,
+                CanEdit = p?.CanEdit ?? false,
+                CanDelete = p?.CanDelete ?? false,
+            };
+        }).ToList();
+
+        return Ok(res);
+    }
+}