Пример #1
0
        public void TestUpdaateUsersRole()
        {
            string failureResult = "";

            try
            {
                // Arrange
                var dbContext     = DbContextMocker.UserRoleDbContext();
                var dbUserContext = DbContextMocker.UserDbContext();
                var controller    = new UsersRoleRepository(dbUserContext, dbContext);
                var request       = new UpdateAssignUserRole
                {
                    username = "******",
                    rolename = "user",
                    IsEdit   = true
                };

                // Act
                var response = controller.UpdateAssignRoleUser(request, null);
                dbContext.Dispose();
            }
            catch (Exception ex)
            {
                failureResult = ex.Message;
            }

            // Assert
            //Assert.IsType<OkObjectResult>(response);
            // var result = Assert.IsType<OkObjectResult>(response);
            Assert.Equal("", failureResult);
        }
Пример #2
0
        public async Task <IActionResult> UpdateUserRole([FromBody] UpdateAssignUserRole updateassignUserRole)
        {
            try
            {
                _logger.LogInfo("Attempted submission attempted");

                if (updateassignUserRole == null)
                {
                    _logger.LogWarn("Empty request submitted");
                    return(BadRequest(ModelState));
                }
                if (!ModelState.IsValid)
                {
                    _logger.LogWarn("User data was incomplete");
                    return(BadRequest(ModelState));
                }
                int UID       = _UserRoleRepository.UpdateAssignRoleUser(updateassignUserRole, _userManager);
                var UserAudit = await _UserRepository.FindByUserName(updateassignUserRole.username.ToString());

                var User_new = _Mapper.Map <IList <Users> >(UserAudit);
                _logger.LogInfo("User Role created");

                Audit_logs audit = new Audit_logs()
                {
                    uid      = User_new[0].id,
                    action   = "Update User Role",
                    log      = $"{updateassignUserRole.username} Role has updated to{updateassignUserRole.rolename}",
                    datetime = DateTime.Now
                };
                await _audit_Logs.Create(audit);

                return(NoContent());
            }
            catch (Exception ex)
            {
                return(InternalError($"{ex.Message}-{ex.InnerException}"));
            }
        }
        public int UpdateAssignRoleUser(UpdateAssignUserRole updateassignUserRole, UserManager <IdentityUser> userManager)
        {
            var param = new SqlParameter[] {
                new SqlParameter()
                {
                    ParameterName = "@username",
                    SqlDbType     = System.Data.SqlDbType.VarChar,
                    Size          = 100,
                    Direction     = System.Data.ParameterDirection.Input,
                    Value         = updateassignUserRole.username.ToString()
                },
                new SqlParameter()
                {
                    ParameterName = "@rolename",
                    SqlDbType     = System.Data.SqlDbType.VarChar,
                    Size          = 100,
                    Direction     = System.Data.ParameterDirection.Input,
                    Value         = updateassignUserRole.rolename.ToString()
                },
                new SqlParameter()
                {
                    ParameterName = "@IsEdit",
                    SqlDbType     = System.Data.SqlDbType.Bit,
                    Direction     = System.Data.ParameterDirection.Input,
                    Value         = Convert.ToBoolean(updateassignUserRole.IsEdit)
                },
            };
            //    IQueryable<Users> studentList = _dbRole.User_new.FromSqlRaw("EXEC ProcAddRoletoUser @username, @rolename, @IsDelete", param[0].Value, param[1].Value, param[2].Value).IgnoreQueryFilters();
            string SQLQuery = $"EXECUTE ProcAddRoletoUser @username='******', @rolename='{param[1].Value}', @IsEdit={param[2].Value}";

            int v = _dbRole.Database.ExecuteSqlRaw(SQLQuery);

            if (userManager != null)
            {
                UpdateSeedUsers(userManager, updateassignUserRole).Wait();
            }
            return(v);
        }
        private async Task UpdateSeedUsers(UserManager <IdentityUser> userManager, UpdateAssignUserRole updateassignUsername)
        {
            IList <Users> Users = await FindByUserName(updateassignUsername.username);

            if (await userManager.FindByNameAsync(updateassignUsername.username) != null)
            {
                var user = new IdentityUser
                {
                    UserName = updateassignUsername.username,
                    Email    = Users[0].Email,
                };
                var result = await userManager.FindByNameAsync(updateassignUsername.username);

                if (result != null)
                {
                    IdentityResult deletionResult = await userManager.RemoveFromRolesAsync(result, await userManager.GetRolesAsync(result));

                    if (deletionResult != null)
                    {
                        await userManager.AddToRoleAsync(result, updateassignUsername.rolename);
                    }
                }
            }
        }