Esempio n. 1
0
        public async Task <IActionResult> UpdateUser(UserRequestUpdate request)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }
            var result = await _userService.UpdateUser(request);

            if (!result.IsSucceed)
            {
                return(BadRequest(result.Messeage));
            }
            return(Ok(result));
        }
Esempio n. 2
0
        public async Task <IActionResult> UpdateUser(string userId, UserRequestUpdate request)
        {
            var resultGet = await _identityService.GetUserByUsername(userId);

            if (!resultGet.Success)
            {
                return(this.GetProblem(resultGet));
            }

            var user = _mapper.Map(request, resultGet.Object.User);

            var roles = ParametersHelper.GetRoles(request.Roles);

            var result = await _identityService.UpdateUserAsync(user, request.Password, roles);

            if (!result.Success)
            {
                return(this.GetValidationProblem(result));
            }

            return(NoContent());
        }
Esempio n. 3
0
        public override async Task <UserResponseUpdate> Update(UserRequestUpdate request, ServerCallContext context)
        {
            var response = new UserResponseUpdate();

            try
            {
                User cacheEntry = await _manager.Update(request.User);

                Cache.Remove(_cache, "User.");
                var result = (await _manager.Get(x => x.Id == cacheEntry.Id)).FirstOrDefault();
                if (result != null)
                {
                    string cacheKey          = "User.GetById::" + cacheEntry.Id.ToString();
                    var    cacheEntryOptions = new MemoryCacheEntryOptions().SetSlidingExpiration(TimeSpan.FromSeconds(_cacheTimeInSeconds));
                    _cache.Set(cacheKey, cacheEntry, cacheEntryOptions);
                    response.User    = cacheEntry;
                    response.Success = true;
                    response.Status  = RequestCodes.TWO_ZERO_ZERO + ", updated 1 row and then selected 1 row from " + Cache.Database;
                    response.Error   = "";
                }
                else
                {
                    response.Success = false;
                    response.Status  = RequestCodes.FIVE_ZERO_ONE;
                    response.Error   = "Could not find setting after adding it.";
                }
            }
            catch (Exception e)
            {
                response.Success = false;
                response.Status  = RequestCodes.FIVE_ZERO_ZERO;
                response.Error   = e.ToString();
            }

            return(await Task.FromResult <UserResponseUpdate>(response));
        }
Esempio n. 4
0
        public async Task <ApiRespond <bool> > UpdateUser(UserRequestUpdate request)
        {
            if (await _userManager.Users.AnyAsync(x => x.Email == request.Email && x.Id != request.Id))
            {
                return(new ApiRespond <bool>()
                {
                    IsSucceed = false,
                    Messeage = "Email is exist"
                });
            }

            var user = await _userManager.FindByIdAsync(request.Id.ToString());

            user.FirstName   = request.FirstName;
            user.LastName    = request.LastName;
            user.Email       = request.Email;
            user.Dob         = request.Dob;
            user.PhoneNumber = request.PhoneNumber;
            user.IsActive    = request.IsActive;

            var result = await _userManager.UpdateAsync(user);

            if (!result.Succeeded)
            {
                return(new ApiRespond <bool>()
                {
                    IsSucceed = false,
                    Messeage = "Update error"
                });
            }

            return(new ApiRespond <bool>
            {
                IsSucceed = true,
            });
        }