예제 #1
0
        /// <summary>
        /// Updates the name, email, password and phone number of the customer with the specified id.
        /// </summary>
        /// <param name="request">The request containing the information that should be updated for the customer.</param>
        /// <param name="customerId">The id of the customer the changes should be applied to.</param>
        /// <returns></returns>
        public async Task <EditCustomerResponse> EditCustomerAsync(EditCustomerRequest request, string customerId)
        {
            var customer = await _unitOfWork.CustomerRepository.FindByIDAsync(customerId);

            await _unitOfWork.IdentityUserRepository.TransactionWrapper(async() =>
            {
                customer.Name        = request.Name;
                customer.PhoneNumber = request.PhoneNumber;

                if (request.ChangePassword == true)
                {
                    var password    = request.Password;
                    var oldPassword = request.OldPassword;
                    await _unitOfWork.IdentityUserRepository.ChangePasswordAsync(customer, password, oldPassword);
                }

                if (customer.Email != request.Email)
                {
                    await _unitOfWork.IdentityUserRepository.ChangeEmailAsync(customer, request.Email);
                }

                _unitOfWork.CustomerRepository.Update(customer);
                await _unitOfWork.SaveChangesAsync();
            });

            var customerDto = _mapper.Map <CustomerDto>(customer);
            var response    = new EditCustomerResponse
            {
                Customer = customerDto
            };

            return(response);
        }
예제 #2
0
        //Edit Customer
        public async Task <CustomerResponse> EditCustomer(EditCustomerRequest req)
        {
            string jsonRequest  = CommonService.JsonSerializer <EditCustomerRequest>(req);
            string jsonResponse = await PostRequest(jsonRequest, "editcustomer", req.CustomerID);

            return(CommonService.JsonDeSerializer <CustomerResponse>(jsonResponse));
        }
예제 #3
0
        public async Task <IActionResult> EditCustomer(int?id)
        {
            if (id == null)
            {
                return(NotFound());
            }

            var request  = new EditCustomerRequest(id);
            var response = await _mediator.Send(request);

            return(View(response));
        }
        public void Email_WhenSet_ValidatesInput(string email, int numberOfErrors)
        {
            var request = new EditCustomerRequest
            {
                Email          = email,
                Name           = ValidName,
                PhoneNumber    = ValidPhoneNumber,
                ChangePassword = false
            };

            Assert.That(ValidateModelHelper.ValidateModel(request).Count, Is.EqualTo(numberOfErrors));
        }
        public void Name_WhenSetToWhiteSpaceOrNull_ValidationFails(string name, int numberOfErrors)
        {
            var request = new EditCustomerRequest
            {
                Email          = ValidEmail,
                Name           = name,
                PhoneNumber    = ValidPhoneNumber,
                ChangePassword = false
            };

            Assert.That(ValidateModelHelper.ValidateModel(request).Count, Is.EqualTo(numberOfErrors));
        }
예제 #6
0
        public IHttpActionResult Edit(EditCustomerRequest request, CancellationToken cancellationToken)
        {
            try
            {
                var command  = mapper.Map <EditCustomerCommand>(request);
                var response = mediator.Send(command, cancellationToken);

                return(Ok(response));
            }
            catch (Exception ex)
            {
                return(BadRequest(ex.Message));
            }
        }
        public void Name_WhenSet_ValidatesLengthIsMin3Max255(int numberOfCharsInName, int numberOfErrors)
        {
            var name = GenerateString(numberOfCharsInName);

            var request = new EditCustomerRequest
            {
                Email          = ValidEmail,
                Name           = name.ToString(),
                ChangePassword = false,
                PhoneNumber    = ValidPhoneNumber
            };

            Assert.That(ValidateModelHelper.ValidateModel(request).Count, Is.EqualTo(numberOfErrors));
        }
        public void Password_WhenSet_ValidatesThatBothPasswordsIsPresentAndThatTheyAreEqual(string first, string second, int numberOfErrors)
        {
            var request = new EditCustomerRequest
            {
                Email            = ValidEmail,
                Password         = first,
                RepeatedPassword = second,
                Name             = ValidName,
                PhoneNumber      = ValidPhoneNumber,
                ChangePassword   = false
            };

            Assert.That(ValidateModelHelper.ValidateModel(request).Count, Is.EqualTo(numberOfErrors));
        }
        public async Task <IActionResult> Edit([FromHeader] string authorization, [FromBody] EditCustomerRequest request)
        {
            var customerId = User.Claims.FirstOrDefault(x => x.Type == Constants.UserIdClaim)?.Value;

            if (string.IsNullOrEmpty(customerId))
            {
                throw new UserIdInvalidException(
                          $"The supplied JSON Web Token does not contain a valid value in the '{ Constants.UserIdClaim }' claim.");
            }

            var response = await _customerService.EditCustomerAsync(request, customerId);

            return(Ok(response));
        }
        public async Task EditCustomerAsync_EditingCustomerSucceeds__ReturnsAEditCustomerResponse()
        {
            //Arrange
            var request = new EditCustomerRequest
            {
                Email            = "*****@*****.**",
                Name             = "Axel",
                Password         = "******",
                RepeatedPassword = "******",
                PhoneNumber      = "66666666",
                OldPassword      = "******",
                ChangePassword   = true
            };

            var customer = new Customer
            {
                Id          = "SomeId",
                Email       = "*****@*****.**",
                PhoneNumber = "11111111",
                Name        = "Hans"
            };

            _unitOfWork.IdentityUserRepository.AddIdentityUserAsync(customer, request.OldPassword)
            .ReturnsForAnyArgs(IdentityResult.Success);

            _unitOfWork.IdentityUserRepository.SignInAsync(customer.Email, request.OldPassword)
            .ReturnsForAnyArgs(SignInResult.Success);

            var customerDto = new CustomerDto
            {
                Email       = request.Email,
                Name        = request.Name,
                PhoneNumber = request.PhoneNumber
            };

            var editCustomerResponse = new EditCustomerResponse
            {
                Customer = customerDto
            };

            _unitOfWork.CustomerRepository.FindByIDAsync(null).ReturnsForAnyArgs(customer);
            _mapper.Map <CustomerDto>(null).ReturnsForAnyArgs(customerDto);

            //Act
            var response = await _customerService.EditCustomerAsync(request, customer.Id);

            //Assert
            Assert.That(response.Customer, Is.EqualTo(editCustomerResponse.Customer));
        }
        public void Edit_CustomerIdEmpty_ThrowsUserIdInvalidException()
        {
            var request = new EditCustomerRequest();

            _customerController.ControllerContext = new ControllerContext
            {
                HttpContext = new DefaultHttpContext
                {
                    User = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
                    {
                        new Claim(Constants.UserIdClaim, "")
                    }))
                }
            };

            Assert.ThrowsAsync <UserIdInvalidException>(async() => await _customerController.Edit(null, request));
        }
        public async Task Edit_Success_ReturnsOkResponse()
        {
            _customerController.ControllerContext = new ControllerContext
            {
                HttpContext = new DefaultHttpContext
                {
                    User = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
                    {
                        new Claim(Constants.UserIdClaim, "SomeCustomerId")
                    }))
                }
            };

            var request = new EditCustomerRequest();

            var response = await _customerController.Edit(null, request) as ObjectResult;

            Assert.That(response.StatusCode, Is.EqualTo(StatusCodes.Status200OK));
        }