public async Task <IActionResult> PatchUserAsync([FromServices] ApplicationDbContext applicationDbContext,
                                                         [FromServices] IMapper mapper,
                                                         string userId, JsonPatchDocument <CreateOrUpdateUserViewModel> document)
        {
            var user = await applicationDbContext.Users.FirstOrDefaultAsync(e => e.Id == userId).ConfigureAwait(false);

            if (user == null)
            {
                return(NotFound());
            }

            CreateOrUpdateUserViewModel dto = mapper.Map <CreateOrUpdateUserViewModel>(user);

            document.ApplyTo(dto);

            user = mapper.Map(dto, user);

            try
            {
                await applicationDbContext.SaveChangesAsync().ConfigureAwait(false);

                return(Ok());
            }
            catch (DbUpdateException ex)
            {
                return(this.StatusCode(StatusCodes.Status500InternalServerError, ex.InnerException?.Message ?? ex.Message));
            }
        }
        /// <summary>
        /// 创建或编辑用户
        /// </summary>
        /// <param name="addOrUpdateUserViewModel"></param>
        /// <returns></returns>
        public async Task <IActionResult> OnPostCreateOrUpdateUserAsync(CreateOrUpdateUserViewModel addOrUpdateUserViewModel)
        {
            if (addOrUpdateUserViewModel is null)
            {
                throw new ArgumentNullException(nameof(addOrUpdateUserViewModel));
            }

            if (!TryValidateModel(addOrUpdateUserViewModel))
            {
                return(BadRequest(ModelState));
            }

            var result = await userService.CreateOrUpdateUserAsync(new Models.ApplicationUser
            {
                Id       = addOrUpdateUserViewModel.Id,
                UserName = addOrUpdateUserViewModel.UserName,
                Name     = addOrUpdateUserViewModel.Name,
                Password = addOrUpdateUserViewModel.Password
            }).ConfigureAwait(false);

            if (result.Succeeded)
            {
                return(Content(result.Data));
            }
            else
            {
                ModelState.AddModelError(string.Empty, result.ErrorMessage);
                return(BadRequest(ModelState));
            }
        }
        public async Task <IActionResult> CreateOrUpdateUserAsync(CreateOrUpdateUserViewModel viewModel)
        {
            return(Ok());

            var result = await userService.CreateOrUpdateUserAsync(new Models.ApplicationUser()).ConfigureAwait(false);

            if (result.Succeeded)
            {
                return(new JsonResult(result.Data));
            }

            ModelState.AddModelError(string.Empty, result.ErrorMessage);
            return(BadRequest(ModelState));
        }
Beispiel #4
0
        public async Task <IActionResult> CreateOrUpdateUserAsync([FromBody] CreateOrUpdateUserViewModel viewModel)
        {
            if (viewModel is null)
            {
                throw new ArgumentNullException(nameof(viewModel));
            }

            DataResult <string> result;

            if (string.IsNullOrEmpty(viewModel.Id))
            {
                result = await userService.CreateUserAsync(new CreateUserDto
                {
                    Name     = viewModel.Name,
                    UserName = viewModel.UserName,
                    Password = viewModel.Password
                }).ConfigureAwait(false);
            }
            else
            {
                var user = await userService.FindByIdAsync(viewModel.Id).ConfigureAwait(false);

                if (user == null)
                {
                    return(NotFound());
                }

                user.Name     = viewModel.Name;
                user.UserName = viewModel.UserName;
                user.Password = viewModel.Password;
                result        = await userService.UpdateUserAsync(user).ConfigureAwait(false);
            }

            if (result.Succeeded)
            {
                return(new JsonResult(result.Data));
            }

            ModelState.AddModelError(string.Empty, result.ErrorMessage);
            return(BadRequest(ModelState));
        }