Ejemplo n.º 1
0
        public async Task <ActionResultResponse> Insert(string tenantId, RoleMeta roleMeta)
        {
            if (roleMeta.RolePagePermissions == null || !roleMeta.RolePagePermissions.Any())
            {
                return(new ActionResultResponse(-1, _resourceService.GetString("Please select at least 1 page and permission.")));
            }

            var roleId = Guid.NewGuid().ToString();
            // Check RoleName exists.
            var isNameExists = await _roleRepository.CheckExists(tenantId, roleId, roleMeta.Name);

            if (isNameExists)
            {
                return(new ActionResultResponse(-2, _resourceService.GetString("Role name already exists. Please try again.")));
            }

            var role = new Role
            {
                Id               = roleId,
                Name             = roleMeta.Name.Trim(),
                NormalizedName   = roleMeta.Name.Trim().StripVietnameseChars().ToUpper(),
                Description      = roleMeta.Description?.Trim(),
                TenantId         = tenantId,
                Type             = RoleType.Custom,
                ConcurrencyStamp = roleId
            };
            var result = await _roleRepository.CreateAsync(role, new CancellationToken());

            if (result.Errors.Any())
            {
                return(new ActionResultResponse(-3, string.Join(",", result.Errors.Select(x => x.Description).ToArray())));
            }

            // Add new user role.
            if (roleMeta.UserIds != null && roleMeta.UserIds.Any())
            {
                await AddNewUserRole(tenantId, roleId, roleMeta.UserIds);
            }

            // Add new role pages.
            var resultInsertResultPage = await AddNewRolePage(roleId, roleMeta.RolePagePermissions);

            if (resultInsertResultPage > 0)
            {
                return(new ActionResultResponse(resultInsertResultPage, _resourceService.GetString("Add new role successful.")));
            }

            await RollbackInsert();

            return(new ActionResultResponse(-4, _sharedResourceService.GetString(ErrorMessage.SomethingWentWrong)));

            async Task RollbackInsert()
            {
                await _roleRepository.ForceDelete(roleId);

                await _rolePageRepository.ForceDeleteByRoleId(roleId);
            }
        }
Ejemplo n.º 2
0
        public async Task <IActionResult> Update(string id, [FromBody] RoleMeta roleMeta)
        {
            var result = await _roleService.Update(CurrentUser.TenantId, id, roleMeta);

            if (result.Code <= 0)
            {
                return(BadRequest(result));
            }
            return(Ok(result));
        }
Ejemplo n.º 3
0
        public async Task <ActionResultResponse> Update(string tenantId, string id, RoleMeta roleMeta)
        {
            if (roleMeta.RolePagePermissions == null || !roleMeta.RolePagePermissions.Any())
            {
                return(new ActionResultResponse(-1, _resourceService.GetString("Please select at least 1 page and permission.")));
            }

            // Check RoleName exists.
            var isNameExists = await _roleRepository.CheckExists(tenantId, id, roleMeta.Name);

            if (isNameExists)
            {
                return(new ActionResultResponse(-2, _resourceService.GetString("Role name already exists. Please try again.")));
            }

            var roleInfo = await _roleRepository.FindByIdAsync(id, new CancellationToken());

            if (roleInfo == null)
            {
                return(new ActionResultResponse(-3, _resourceService.GetString("Role does not exists. Please try again.")));
            }

            if (roleInfo.TenantId != tenantId)
            {
                return(new ActionResultResponse(-4, _sharedResourceService.GetString(ErrorMessage.NotHavePermission)));
            }

            if (roleMeta.ConcurrencyStamp != roleInfo.ConcurrencyStamp)
            {
                return(new ActionResultResponse(-5, _resourceService.GetString("Role has been updated by another staff. You can not update this role.")));
            }

            if (roleInfo.Type == RoleType.BuiltIn)
            {
                return(new ActionResultResponse(-6, _resourceService.GetString("You can not modifi built-In role.")));
            }

            roleInfo.Name             = roleMeta.Name.Trim();
            roleInfo.Description      = roleMeta.Description?.Trim();
            roleInfo.ConcurrencyStamp = Guid.NewGuid().ToString();
            roleInfo.NormalizedName   = roleInfo.Name.StripVietnameseChars().ToUpper();
            var result = await _roleRepository.UpdateAsync(roleInfo, new CancellationToken());

            // Save role pages.
            await UpdateRolePages(roleInfo.Id, roleMeta.RolePagePermissions);

            // Save user roles.
            await SaveUsers();

            return(new ActionResultResponse(result.Succeeded ? 1 : 0, result.Succeeded
                ? _resourceService.GetString("Update role successful.")
                : _sharedResourceService.GetString("Something went wrong. Please contact with administrator.")));

            async Task SaveUsers()
            {
                // Delete all user role.
                await _userRoleRepository.DeleteByRoleId(roleInfo.Id);

                // Add new user role.
                await AddNewUserRole(tenantId, roleInfo.Id, roleMeta.UserIds);
            }
        }
Ejemplo n.º 4
0
 public InsertRoleCommand(Guid tenantId, RoleMeta roleMeta)
 {
     TenantId = tenantId;
     RoleMeta = roleMeta;
 }
 public UpdateRoleCommand(Guid tenantId, Guid id, RoleMeta roleMeta)
 {
     TenantId = tenantId;
     Id       = id;
     RoleMeta = roleMeta;
 }