role

Author: brunobritodev

src/Backend/Jp.Application/AutoMapper/DomainToViewModelMappingProfile.cs

@@ -29,6 +29,7 @@ public DomainToViewModelMappingProfile()
             CreateMap<IdentityServer4.EntityFramework.Entities.IdentityResource, IdentityResourceListView>(MemberList.Destination);
             CreateMap<IdentityServer4.EntityFramework.Entities.ApiScope, ScopeViewModel>(MemberList.Destination);
             CreateMap<Claim, ClaimViewModel>(MemberList.Destination);
+            CreateMap<Role, RoleViewModel>(MemberList.Destination);
         }
     }
 }

src/Backend/Jp.Application/AutoMapper/ViewModelToDomainMappingProfile.cs

@@ -44,6 +44,8 @@ public ViewModelToDomainMappingProfile()
             CreateMap<RemoveAccountViewModel, RemoveAccountCommand>().ConstructUsing(c => new RemoveAccountCommand(c.Id));
             CreateMap<SaveUserClaimViewModel, SaveUserClaimCommand>().ConstructUsing(c => new SaveUserClaimCommand(c.Username, c.Type, c.Value));
             CreateMap<RemoveUserClaimViewModel, RemoveUserClaimCommand>().ConstructUsing(c => new RemoveUserClaimCommand(c.Username, c.Type));
+            CreateMap<RemoveUserRoleViewModel, RemoveUserRoleCommand>().ConstructUsing(c => new RemoveUserRoleCommand(c.Username, c.Role));
+            CreateMap<SaveUserRoleViewModel, SaveUserRoleCommand>().ConstructUsing(c => new SaveUserRoleCommand(c.Username, c.Role));
 
             /*
              * Client commands

src/Backend/Jp.Application/Interfaces/IRoleManagerAppService.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using Jp.Application.ViewModels;
+
+namespace Jp.Application.Interfaces
+{
+    public interface IRoleManagerAppService: IDisposable
+    {
+        Task<IEnumerable<RoleViewModel>> GetAllRoles();
+    }
+}

src/Backend/Jp.Application/Interfaces/IUserManageAppService.cs

@@ -25,5 +25,8 @@ public interface IUserManageAppService : IDisposable
         Task<IEnumerable<ClaimViewModel>> GetClaims(string userName);
         Task SaveClaim(SaveUserClaimViewModel model);
         Task RemoveClaim(RemoveUserClaimViewModel model);
+        Task<IEnumerable<RoleViewModel>> GetRoles(string userName);
+        Task RemoveRole(RemoveUserRoleViewModel model);
+        Task SaveRole(SaveUserRoleViewModel model);
     }
 }

src/Backend/Jp.Application/Services/RoleManagerAppService.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using AutoMapper;
+using Jp.Application.Interfaces;
+using Jp.Application.ViewModels;
+using Jp.Domain.Core.Bus;
+using Jp.Domain.Interfaces;
+using Jp.Domain.Models;
+
+namespace Jp.Application.Services
+{
+    public class RoleManagerAppService : IRoleManagerAppService
+    {
+        private IEventStoreRepository _eventStoreRepository;
+        private IMapper _mapper;
+        private readonly IRoleService _roleService;
+
+        public IMediatorHandler Bus { get; set; }
+        public RoleManagerAppService(IMapper mapper,
+            IRoleService roleService,
+            IMediatorHandler bus,
+            IEventStoreRepository eventStoreRepository
+        )
+        {
+            _mapper = mapper;
+            _roleService = roleService;
+            Bus = bus;
+            _eventStoreRepository = eventStoreRepository;
+        }
+
+
+
+        public void Dispose()
+        {
+            GC.SuppressFinalize(this);
+        }
+
+        public async Task<IEnumerable<RoleViewModel>> GetAllRoles()
+        {
+            return _mapper.Map<IEnumerable<RoleViewModel>>(await _roleService.GetAllRoles());
+        }
+    }
+}

src/Backend/Jp.Application/Services/UserManagerAppService.cs

@@ -1,7 +1,4 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using AutoMapper;
+using AutoMapper;
 using Jp.Application.EventSourcedNormalizers;
 using Jp.Application.Interfaces;
 using Jp.Application.ViewModels;
@@ -10,6 +7,10 @@
 using Jp.Domain.Commands.UserManagement;
 using Jp.Domain.Core.Bus;
 using Jp.Domain.Interfaces;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
 
 namespace Jp.Application.Services
 {
@@ -120,7 +121,25 @@ public Task SaveClaim(SaveUserClaimViewModel model)
 
         public Task RemoveClaim(RemoveUserClaimViewModel model)
         {
-            var registerCommand = _mapper.Map<RemoveUserClaimCommand>(model);
+            var removeCommand = _mapper.Map<RemoveUserClaimCommand>(model);
+            return Bus.SendCommand(removeCommand);
+        }
+
+        public async Task<IEnumerable<RoleViewModel>> GetRoles(string userName)
+        {
+            var roles = await _userService.GetRoles(userName);
+            return roles.Select(s => new RoleViewModel() { Name = s });
+        }
+
+        public Task RemoveRole(RemoveUserRoleViewModel model)
+        {
+            var removeCommand = _mapper.Map<RemoveUserRoleCommand>(model);
+            return Bus.SendCommand(removeCommand);
+        }
+
+        public Task SaveRole(SaveUserRoleViewModel model)
+        {
+            var registerCommand = _mapper.Map<SaveUserRoleCommand>(model);
             return Bus.SendCommand(registerCommand);
         }
     }

src/Backend/Jp.Application/ViewModels/RoleViewModel.cs

@@ -0,0 +1,10 @@
+using System;
+
+namespace Jp.Application.ViewModels
+{
+    public class RoleViewModel
+    {
+        public Guid Id { get; set; }
+        public string Name { get; set; }
+    }
+}

src/Backend/Jp.Application/ViewModels/UserViewModels/RemoveUserRoleViewModel.cs

@@ -0,0 +1,15 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+
+namespace Jp.Application.ViewModels.UserViewModels
+{
+    public class RemoveUserRoleViewModel
+    {
+        [Required]
+        public string Role { get; set; }
+        [Required]
+        public string Username { get; set; }
+
+        public Guid UserId { get; set; }
+    }
+}

src/Backend/Jp.Application/ViewModels/UserViewModels/SaveUserRoleViewModel.cs

@@ -0,0 +1,12 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace Jp.Application.ViewModels.UserViewModels
+{
+    public class SaveUserRoleViewModel
+    {
+        [Required]
+        public string Role { get; set; }
+        [Required]
+        public string Username { get; set; }
+    }
+}

src/Backend/Jp.Domain/CommandHandlers/UserManagementCommandHandler.cs

@@ -20,18 +20,22 @@ public class UserManagementCommandHandler : CommandHandler,
         IRequestHandler<RemoveAccountCommand>,
         IRequestHandler<UpdateUserCommand>,
         IRequestHandler<SaveUserClaimCommand>,
-        IRequestHandler<RemoveUserClaimCommand>
+        IRequestHandler<RemoveUserClaimCommand>,
+        IRequestHandler<RemoveUserRoleCommand>
     {
         private readonly IUserService _userService;
+        private readonly ISystemUser _user;
 
         public UserManagementCommandHandler(
             IUnitOfWork uow,
             IMediatorHandler bus,
             INotificationHandler<DomainNotification> notifications,
-            IUserService userService)
+            IUserService userService,
+            ISystemUser user)
             : base(uow, bus, notifications)
         {
             _userService = userService;
+            _user = user;
         }
 
         public async Task Handle(UpdateProfileCommand request, CancellationToken cancellationToken)
@@ -173,5 +177,28 @@ public async Task Handle(RemoveUserClaimCommand request, CancellationToken cance
                 await Bus.RaiseEvent(new UserClaimRemovedEvent(request.Username, request.Type));
             }
         }
+
+        public async Task Handle(RemoveUserRoleCommand request, CancellationToken cancellationToken)
+        {
+            if (!request.IsValid())
+            {
+                NotifyValidationErrors(request);
+                return;
+            }
+
+            var userDb = await _userService.FindByNameAsync(request.Username);
+            if (userDb == null)
+            {
+                await Bus.RaiseEvent(new DomainNotification("1", "User not found"));
+                return;
+            }
+
+            var success = await _userService.RemoveRole(userDb.Id, request.Role);
+
+            if (success)
+            {
+                await Bus.RaiseEvent(new UserRoleRemovedEvent(_user.UserId, request.Username, request.Role));
+            }
+        }
     }
 }