Add user and role management features

2026-08-18 15:43:55 +05:30
parent e0e691acbf
commit be51351f74
10 changed files with 386 additions and 0 deletions
@@ -0,0 +1,18 @@
+namespace Distribution.Features.User;
+
+public interface IUserRepository
+{
+    Task<Models.User?> GetByIdAsync(Guid id);
+    Task<Models.User?> GetByUsernameAsync(string username);
+    Task<List<Models.User>> GetAllAsync();
+    Task AddAsync(Models.User entity);
+    void Update(Models.User entity);
+    void Remove(Models.User entity);
+
+    Task<List<Models.UserRegionScope>> GetRegionScopesAsync(Guid userId);
+    Task<List<Models.UserRouteScope>> GetRouteScopesAsync(Guid userId);
+    Task<List<Models.UserStoreScope>> GetStoreScopesAsync(Guid userId);
+    Task ReplaceRegionScopesAsync(Guid userId, IEnumerable<Guid> regionIds);
+    Task ReplaceRouteScopesAsync(Guid userId, IEnumerable<Guid> routeIds);
+    Task ReplaceStoreScopesAsync(Guid userId, IEnumerable<Guid> storeIds);
+}
@@ -0,0 +1,63 @@
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Distribution.Features.User;
+
+[ApiController]
+[Route("api/users")]
+[Authorize]
+public class UserController(UserService service) : ControllerBase
+{
+    [HttpGet]
+    [Authorize(Policy = "users.view")]
+    public async Task<IActionResult> GetAll() =>
+        Ok(await service.GetAllAsync());
+
+    [HttpGet("{id:guid}")]
+    [Authorize(Policy = "users.view")]
+    public async Task<IActionResult> GetById(Guid id)
+    {
+        var result = await service.GetByIdAsync(id);
+        return result is null ? NotFound() : Ok(result);
+    }
+
+    [HttpPost]
+    [Authorize(Policy = "users.create")]
+    public async Task<IActionResult> Create(CreateUserRequest request, CancellationToken ct)
+    {
+        var result = await service.CreateAsync(request, ct);
+        return CreatedAtAction(nameof(GetById), new { id = result.Id }, result);
+    }
+
+    [HttpPut("{id:guid}")]
+    [Authorize(Policy = "users.update")]
+    public async Task<IActionResult> Update(Guid id, UpdateUserRequest request, CancellationToken ct)
+    {
+        var result = await service.UpdateAsync(id, request, ct);
+        return result is null ? NotFound() : Ok(result);
+    }
+
+    [HttpPut("{id:guid}/role")]
+    [Authorize(Policy = "users.assign_role")]
+    public async Task<IActionResult> AssignRole(Guid id, AssignUserRoleRequest request, CancellationToken ct)
+    {
+        var result = await service.AssignRoleAsync(id, request, ct);
+        return result is null ? NotFound() : Ok(result);
+    }
+
+    [HttpPut("{id:guid}/scope")]
+    [Authorize(Policy = "users.assign_scope")]
+    public async Task<IActionResult> AssignScope(Guid id, AssignUserScopeRequest request, CancellationToken ct)
+    {
+        var updated = await service.AssignScopeAsync(id, request, ct);
+        return updated ? NoContent() : NotFound();
+    }
+
+    [HttpDelete("{id:guid}")]
+    [Authorize(Policy = "users.deactivate")]
+    public async Task<IActionResult> Deactivate(Guid id, CancellationToken ct)
+    {
+        var deactivated = await service.DeactivateAsync(id, ct);
+        return deactivated ? NoContent() : NotFound();
+    }
+}
@@ -0,0 +1,28 @@
+namespace Distribution.Features.User;
+
+public record CreateUserRequest(
+    string Username,
+    string Password,
+    string FullName,
+    Guid RoleId,
+    Guid? ReportsToUserId);
+
+public record UpdateUserRequest(string FullName);
+
+public record AssignUserRoleRequest(Guid RoleId);
+
+public record AssignUserScopeRequest(
+    List<Guid> RegionIds,
+    List<Guid> RouteIds,
+    List<Guid> StoreIds);
+
+public record UserResponse(
+    Guid Id,
+    string Username,
+    string FullName,
+    Guid RoleId,
+    string RoleName,
+    Guid? ReportsToUserId,
+    bool IsActive,
+    DateTime CreatedAt,
+    DateTime? UpdatedAt);
@@ -0,0 +1,61 @@
+using Distribution.Data;
+using Microsoft.EntityFrameworkCore;
+
+namespace Distribution.Features.User;
+
+public class UserRepository(AppDBContext context) : IUserRepository
+{
+    public async Task<Models.User?> GetByIdAsync(Guid id) =>
+        await context.Users.Include(u => u.Role).FirstOrDefaultAsync(u => u.Id == id);
+
+    public async Task<Models.User?> GetByUsernameAsync(string username) =>
+        await context.Users.Include(u => u.Role).FirstOrDefaultAsync(u => u.Username == username);
+
+    public async Task<List<Models.User>> GetAllAsync() =>
+        await context.Users.Include(u => u.Role).ToListAsync();
+
+    public async Task AddAsync(Models.User entity) =>
+        await context.Users.AddAsync(entity);
+
+    public void Update(Models.User entity) =>
+        context.Users.Update(entity);
+
+    public void Remove(Models.User entity)
+    {
+        entity.IsActive = false;
+        context.Users.Update(entity);
+    }
+
+    public async Task<List<Models.UserRegionScope>> GetRegionScopesAsync(Guid userId) =>
+        await context.UserRegionScopes.Where(s => s.FK_UserId == userId && s.IsActive).ToListAsync();
+
+    public async Task<List<Models.UserRouteScope>> GetRouteScopesAsync(Guid userId) =>
+        await context.UserRouteScopes.Where(s => s.FK_UserId == userId && s.IsActive).ToListAsync();
+
+    public async Task<List<Models.UserStoreScope>> GetStoreScopesAsync(Guid userId) =>
+        await context.UserStoreScopes.Where(s => s.FK_UserId == userId && s.IsActive).ToListAsync();
+
+    public async Task ReplaceRegionScopesAsync(Guid userId, IEnumerable<Guid> regionIds)
+    {
+        var existing = await context.UserRegionScopes.Where(s => s.FK_UserId == userId).ToListAsync();
+        context.UserRegionScopes.RemoveRange(existing);
+        await context.UserRegionScopes.AddRangeAsync(
+            regionIds.Select(id => new Models.UserRegionScope { FK_UserId = userId, FK_RegionId = id }));
+    }
+
+    public async Task ReplaceRouteScopesAsync(Guid userId, IEnumerable<Guid> routeIds)
+    {
+        var existing = await context.UserRouteScopes.Where(s => s.FK_UserId == userId).ToListAsync();
+        context.UserRouteScopes.RemoveRange(existing);
+        await context.UserRouteScopes.AddRangeAsync(
+            routeIds.Select(id => new Models.UserRouteScope { FK_UserId = userId, FK_RouteId = id }));
+    }
+
+    public async Task ReplaceStoreScopesAsync(Guid userId, IEnumerable<Guid> storeIds)
+    {
+        var existing = await context.UserStoreScopes.Where(s => s.FK_UserId == userId).ToListAsync();
+        context.UserStoreScopes.RemoveRange(existing);
+        await context.UserStoreScopes.AddRangeAsync(
+            storeIds.Select(id => new Models.UserStoreScope { FK_UserId = userId, FK_StoreId = id }));
+    }
+}
@@ -0,0 +1,130 @@
+using Distribution.Infra.UoW;
+using Microsoft.AspNetCore.Identity;
+
+namespace Distribution.Features.User;
+
+public class UserService(IUserRepository repo, IUnitOfWork uow)
+{
+    private readonly PasswordHasher<Models.User> _hasher = new();
+
+    private static UserResponse ToResponse(Models.User u) =>
+        new(u.Id, u.Username, u.FullName, u.FK_RoleId, u.Role?.Name ?? string.Empty,
+            u.FK_ReportsToUserId, u.IsActive, u.CreatedAt, u.UpdatedAt);
+
+    public async Task<List<UserResponse>> GetAllAsync() =>
+        (await repo.GetAllAsync())
+            .Where(u => u.IsActive)
+            .Select(ToResponse)
+            .ToList();
+
+    public async Task<UserResponse?> GetByIdAsync(Guid id)
+    {
+        var user = await repo.GetByIdAsync(id);
+        if (user is null || !user.IsActive) return null;
+        return ToResponse(user);
+    }
+
+    public async Task<UserResponse> CreateAsync(CreateUserRequest request, CancellationToken ct = default)
+    {
+        var user = new Models.User
+        {
+            Username = request.Username,
+            FullName = request.FullName,
+            FK_RoleId = request.RoleId,
+            FK_ReportsToUserId = request.ReportsToUserId
+        };
+        user.PasswordHash = _hasher.HashPassword(user, request.Password);
+
+        await uow.BeginAsync(ct);
+        try
+        {
+            await repo.AddAsync(user);
+            await uow.CommitAsync(ct);
+        }
+        catch
+        {
+            await uow.RollbackAsync(ct);
+            throw;
+        }
+        return ToResponse(user);
+    }
+
+    public async Task<UserResponse?> UpdateAsync(Guid id, UpdateUserRequest request, CancellationToken ct = default)
+    {
+        var user = await repo.GetByIdAsync(id);
+        if (user is null || !user.IsActive) return null;
+        user.FullName = request.FullName;
+        user.UpdatedAt = DateTime.Now;
+        await uow.BeginAsync(ct);
+        try
+        {
+            repo.Update(user);
+            await uow.CommitAsync(ct);
+        }
+        catch
+        {
+            await uow.RollbackAsync(ct);
+            throw;
+        }
+        return ToResponse(user);
+    }
+
+    public async Task<UserResponse?> AssignRoleAsync(Guid id, AssignUserRoleRequest request, CancellationToken ct = default)
+    {
+        var user = await repo.GetByIdAsync(id);
+        if (user is null || !user.IsActive) return null;
+        user.FK_RoleId = request.RoleId;
+        user.UpdatedAt = DateTime.Now;
+        await uow.BeginAsync(ct);
+        try
+        {
+            repo.Update(user);
+            await uow.CommitAsync(ct);
+        }
+        catch
+        {
+            await uow.RollbackAsync(ct);
+            throw;
+        }
+        return ToResponse(user);
+    }
+
+    public async Task<bool> AssignScopeAsync(Guid id, AssignUserScopeRequest request, CancellationToken ct = default)
+    {
+        var user = await repo.GetByIdAsync(id);
+        if (user is null || !user.IsActive) return false;
+
+        await uow.BeginAsync(ct);
+        try
+        {
+            await repo.ReplaceRegionScopesAsync(id, request.RegionIds);
+            await repo.ReplaceRouteScopesAsync(id, request.RouteIds);
+            await repo.ReplaceStoreScopesAsync(id, request.StoreIds);
+            await uow.CommitAsync(ct);
+        }
+        catch
+        {
+            await uow.RollbackAsync(ct);
+            throw;
+        }
+        return true;
+    }
+
+    public async Task<bool> DeactivateAsync(Guid id, CancellationToken ct = default)
+    {
+        var user = await repo.GetByIdAsync(id);
+        if (user is null || !user.IsActive) return false;
+        await uow.BeginAsync(ct);
+        try
+        {
+            repo.Remove(user);
+            await uow.CommitAsync(ct);
+        }
+        catch
+        {
+            await uow.RollbackAsync(ct);
+            throw;
+        }
+        return true;
+    }
+}