public async Task <IActionResult> Update([FromRoute] int addressId, [FromBody] UpdateAddressRequest updateModel) { var addressEntity = await _addressService.GetByIdAsync(addressId); var userId = int.Parse(HttpContext.GetUserIdFromRequest()); if (addressEntity == null) { return(NotFound()); } // validate customer valid to update address var isCustomerValidUpdate = await _addressService.IsCustomerOwnAddress(userId, addressId); if (!isCustomerValidUpdate) { return(Forbid()); } _mapper.Map <UpdateAddressRequest, Address>(updateModel, addressEntity); var isAddressUpdated = await _addressService.UpdateAsync(addressEntity, userId); var addressResponse = _mapper.Map <AddressResponse>(addressEntity); if (isAddressUpdated) { return(Ok(new Response <AddressResponse>(addressResponse))); } return(NotFound()); }
public ResultJsonModel <AddressByPageResponse> AddressAdd(UpdateAddressRequest request) { ResultJsonModel <AddressByPageResponse> result = new ResultJsonModel <AddressByPageResponse>(); var userGuid = CookieOper.Instance.GetUserGuid(); var user = MemCacheHelper2.Instance.Cache.GetModel <User>("UserGuID_" + userGuid); if (user == null) { user = new DbOpertion.Models.User(); } var Addressresult = AddressFunc.Instance.AdressAdd(new DbOpertion.Models.Address { UserId = user.Id, ContactName = request.ContactName, ContactPhone = request.ContactPhone, AddrArea = request.AddrArea, AddrDetail = request.AddrDetail, DefaultTime = DateTime.Now }); if (Addressresult > 0) { result.HttpCode = 200; result.Message = "联系人信息添加成功!"; result.Model1 = new AddressByPageResponse(AddressFunc.Instance.SelectAddrById(Addressresult)); } else { result.HttpCode = 300; result.Message = "联系人信息添加失败!"; } return(result); }
public async Task <IActionResult> UpdateAddressAsync(AddressId addressId, [FromBody] UpdateAddressRequest request) { var user = await _userService.GetUserAsync(User); var address = await _addressService.FindUserAddressAsync(user, addressId); if (address == null) { return(this.NotFound("Address not found.")); } var result = await _addressService.UpdateAddressAsync( address, request.Line1, request.Line2, request.City, request.State, request.PostalCode); if (result.IsValid) { return(this.Ok(_mapper.Map <AddressDto>(result.Response))); } result.AddToModelState(ModelState); return(this.BadRequest(new ValidationProblemDetails(ModelState))); }
public async Task <Address> UpdateAddressAsync(long id, UpdateAddressRequest updateAddressRequest) { ValidateModel(updateAddressRequest); var response = await PutAsJsonAsync($"/addresses/{id}", JsonConvert.SerializeObject(updateAddressRequest)).ConfigureAwait(false); return(JsonConvert.DeserializeObject <AddressResponse>( await response.Content.ReadAsStringAsync().ConfigureAwait(false)).Address); }
internal static UpdateAddressRequest BuildUpdateAddressRequest() { var request = new UpdateAddressRequest() { Complement = "New complement", Number = "222" }; return(request); }
public IHttpActionResult Put( [FromUri] UpdateAddressRequest request, [FromBody] Delta <WriteAddressPayload> payload) { request.Payload = payload; var address = _updateAddressProcessor.Process(request); return(Ok(address)); }
public UpdateAddressResponse EditAddress(UpdateAddressRequest updateAddressRequest) { UpdateAddressResponse updateAddressResponse = null; if (updateAddressRequest.Id == updateAddressRequest.Address.Id) { var address = _messageMapper.MapToAddress(updateAddressRequest.Address); _addressRepository.UpdateAddress(address); var addressDto = _messageMapper.MapToAddressDto(address); updateAddressResponse = new UpdateAddressResponse { }; } return(updateAddressResponse); }
/// <summary> /// Upserts the standard mailing address. /// </summary> /// <param name="bpId">The bp identifier.</param> /// <param name="address">The address.</param> /// <param name="jwt">The JWT.</param> /// <returns></returns> public async Task <long> UpsertStandardMailingAddressAsync(long bpId, UpdateMailingAddressModel address, string jwt) { _logger.LogInformation($"UpsertStandardMailingAddress({nameof(bpId)}: {bpId}," + $"{nameof(address)}: {address.ToJson()})"); //Format To SaP Address From Cassandra var addressFormatRequest = Mapper.Map <AddressDefinedTypeRequest>(address); var addressResponse = await _addressApi.ToMcfMailingAddressAsync(addressFormatRequest); if (addressResponse != null) { var addressInfo = addressResponse.Data; var response = _mcfClient.GetStandardMailingAddress(jwt, bpId); var addressId = response.Result?.AddressID; if (addressId != null) { var request = new UpdateAddressRequest { AccountID = bpId, AddressID = addressId.Value, AddressInfo = addressInfo }; UpdateStandardAddress(jwt, request); } else { var request = new CreateAddressRequest { AccountID = bpId, AddressInfo = addressInfo }; addressId = CreateStandardAddress(jwt, request).Result.AddressID; } return(addressId.Value); } return(default(long)); }
public virtual async Task <Address> UpdateAddressAsync(Guid customerId, Address address) { var request = new UpdateAddressRequest(address) { RelatedEntityId = customerId.ToString(), RelatedEntityType = "Customer" }; var result = await OvertureClient.SendAsync(request).ConfigureAwait(false); var cacheKey = new CacheKey(CacheConfigurationCategoryNames.Address); cacheKey.AppendKeyParts(result.Id); //3.8 upgrade //CacheProvider.Replace(cacheKey, result); await CacheProvider.SetAsync(cacheKey, result).ConfigureAwait(false); return(result); }
public ResultJsonModel <AddressByPageResponse> UpdateAddr(UpdateAddressRequest request) { ResultJsonModel <AddressByPageResponse> result = new ResultJsonModel <AddressByPageResponse>(); var Addressresult = AddressFunc.Instance.Update(new Address { Id = request.Id, ContactName = request.ContactName, ContactPhone = request.ContactPhone, AddrArea = request.AddrArea, AddrDetail = request.AddrDetail }); if (Addressresult) { result.HttpCode = 200; result.Message = "联系人信息修改成功!"; result.Model1 = new AddressByPageResponse(AddressFunc.Instance.SelectAddrById(request.Id)); } else { result.HttpCode = 300; result.Message = "联系人信息修改失败!"; } return(result); }
public async Task <IActionResult> Update(string id, [FromBody] UpdateAddressRequest updateAddressRequest) { try { //request validation should be here // ... var command = new UpdateAddressCommand(id, updateAddressRequest.Name, updateAddressRequest.City, updateAddressRequest.Street); await _mediator.Send(command); return(Ok()); } catch (Exception e) { return(BadRequest(new ErrorResponse() { ShortInfo = e.Message, AdditionalInfo = e.StackTrace })); } }
public ResponseDto UpdateAddress(UpdateAddressRequest request) { ResponseDto response = new ResponseDto(); Consumer consumer = null; response.has_resource = 0; try { using (UserDao dao = new UserDao()) { consumer = GetAuthUser(dao, request.user_id, request.auth_token, true); if (consumer == null) { MakeNouserResponse(response); return(response); } ConsumerAddress address = dao.FindAddressById(request.address_id); if (address == null) { response.code = 1; response.message = MessagesSource.GetMessage("no.addr"); return(response); } if (Convert.ToBoolean(request.is_default)) { foreach (var item in consumer.ConsumerAddresses.Where(x => x.IsDefault).ToList()) { item.IsDefault = false; } UsersHelper.CopyToEntity(consumer.ConsumerAddresses.Where(x => x.AddrID == request.address_id).FirstOrDefault(), request); dao.Update(consumer); } else { if (consumer.ConsumerAddresses.Where(x => x.IsDefault && x.AddrID != request.address_id).Count() == 0) { UsersHelper.CopyToEntity(consumer.ConsumerAddresses.Where(x => x.AddrID == request.address_id).FirstOrDefault(), request); address.IsDefault = true; dao.Update(consumer); } else { UsersHelper.CopyToEntity(consumer.ConsumerAddresses.Where(x => x.AddrID == request.address_id).FirstOrDefault(), request); dao.Update(consumer); } } //UsersHelper.CopyToEntity(address, request); // dao.UpdateAddress(address); response.code = 0; response.message = MessagesSource.GetMessage("addr.updated"); return(response); } } catch (Exception ex) { response.MakeExceptionResponse(ex); } return(response); }
// TEST /// <summary> /// Метод необходим для обновления адреса контрагента отправителя/получателя. /// </summary> /// <param name="properties">Свойства метода.</param> /// <returns>Ответ от API новой почты.</returns> public Task <ApiResponse <UpdatedAddress> > UpdateAddressAsync(UpdateAddressRequest properties) { var request = _creator.CreateUpdateAddress(_config.ApiKey, properties); return(_client.RequestForResponseAsync <UpdatedAddress>(request)); }
public ApiRequest CreateUpdateAddress(string apiKey, UpdateAddressRequest properties) => CreateAddress(apiKey, "update", properties);
public ActionResult <UpdateAddressResponse> PutAddress(UpdateAddressRequest updateAddressRequest) { var updateAddressResponse = _addressService.EditAddress(updateAddressRequest); return(updateAddressResponse); }
public Address Put(UpdateAddressRequest request) { return(new Address()); }
public async Task UpdateAddressAsync_ShouldBeOkObjectResult() { // Arrange var user = new User { Id = Guid.NewGuid() }; var address = new Address( UserId.FromGuid(user.Id), Country.Canada, "Line1", null, "City", "State", "PostalCode"); TestMock.UserService.Setup(userManager => userManager.GetUserAsync(It.IsAny <ClaimsPrincipal>())).ReturnsAsync(user).Verifiable(); TestMock.AddressService.Setup(addressService => addressService.FindUserAddressAsync(It.IsAny <User>(), It.IsAny <AddressId>())) .ReturnsAsync(address) .Verifiable(); TestMock.AddressService.Setup( addressService => addressService.UpdateAddressAsync( It.IsAny <Address>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())) .ReturnsAsync(DomainValidationResult <Address> .Succeeded(address)) .Verifiable(); var controller = new AddressBookController(TestMock.UserService.Object, TestMock.AddressService.Object, TestMapper); var request = new UpdateAddressRequest { Line1 = "1234 Test Street", Line2 = null, City = "Toronto", State = "Ontario", PostalCode = "A1A1A1" }; // Act var result = await controller.UpdateAddressAsync(address.Id, request); // Assert result.Should().BeOfType <OkObjectResult>(); TestMock.UserService.Verify(userManager => userManager.GetUserAsync(It.IsAny <ClaimsPrincipal>()), Times.Once); TestMock.AddressService.Verify(addressService => addressService.FindUserAddressAsync(It.IsAny <User>(), It.IsAny <AddressId>()), Times.Once); TestMock.AddressService.Verify( addressService => addressService.UpdateAddressAsync( It.IsAny <Address>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()), Times.Once); }
private void UpdateStandardAddress(string jwt, UpdateAddressRequest request) { request.AddressInfo.StandardFlag = "X"; _mcfClient.UpdateAddress(jwt, request); }
[Ignore] // Wait For MCF Fix public async Task UpdateAddress_ValidUser() { //Arrange var user = TestHelper.ActivePaUser; var loginResponse = await AuthClient.GetJwtToken(user.Username, "Start@123"); user.SetJwtEncodedString(loginResponse.Data.JwtAccessToken); var addressResponse = McfClient.GetStandardMailingAddress(user.JwtEncodedString, user.BPNumber).Result; addressResponse.AddressID.ShouldNotBeNull(); var request = new UpdateAddressRequest { AccountID = user.BPNumber, AddressID = addressResponse.AddressID.Value, AddressInfo = new McfAddressinfo { StandardFlag = "X", City = "Bellevue", PostalCode = "98004", POBoxPostalCode = "", POBox = "", Street = "110th Ave NE", HouseNo = "355", CountryID = "US", Region = "WA", HouseNo2 = "" } }; // Act McfClient.UpdateAddress(user.JwtEncodedString, request); var requestAddress = request.AddressInfo; var newAddressResponse = McfClient.GetStandardMailingAddress(user.JwtEncodedString, user.BPNumber).Result.AddressInfo; //Assert newAddressResponse.StandardFlag.ShouldBe(requestAddress.StandardFlag); newAddressResponse.City.ShouldBe(requestAddress.City); newAddressResponse.PostalCode.ShouldBe(requestAddress.PostalCode); newAddressResponse.Street.ShouldBe(requestAddress.Street); newAddressResponse.HouseNo.ShouldBe(requestAddress.HouseNo); newAddressResponse.CountryID.ShouldBe(requestAddress.CountryID); newAddressResponse.Region.ShouldBe(requestAddress.Region); // Restore the environment var restoreRequest = new UpdateAddressRequest { AccountID = addressResponse.AccountID, AddressID = addressResponse.AddressID.Value, AddressInfo = new McfAddressinfo { StandardFlag = addressResponse.AddressInfo.StandardFlag, City = addressResponse.AddressInfo.City, PostalCode = addressResponse.AddressInfo.PostalCode, POBoxPostalCode = addressResponse.AddressInfo.POBoxPostalCode, POBox = addressResponse.AddressInfo.POBox, Street = addressResponse.AddressInfo.Street, HouseNo = addressResponse.AddressInfo.HouseNo, CountryID = addressResponse.AddressInfo.CountryID, Region = addressResponse.AddressInfo.Region, } }; McfClient.UpdateAddress(user.JwtEncodedString, restoreRequest); }
public async Task <ActionResult <GetAddressResponse> > UpdateAddress(Guid customerId, Guid addressId, [FromBody] UpdateAddressRequest dto) { var customerAddress = await _customerService.GetAddressById(customerId, addressId); // validate if (customerAddress is null) { return(NotFound(new { message = "Customer's address does not exist" })); } if (customerAddress.Customer.AccountId != Account.Id && Account.Role != Role.Manager) { return(Unauthorized(new { message = "Unauthorized" })); } await _customerService.UpdateAddress(customerId, addressId, dto); return(NoContent()); }
public async Task <UpdateAddressResponseModel> UpdateAddres(string query, UpdateAddressRequest createAddressReequest) { var res = await PostAsynGraphql <UpdateAddressRequest, UpdateAddressResponseModel>(query, createAddressReequest); return(res); }
private async Task <HttpResponseMessage> ExecuteAsync(Guid addressId, UpdateAddressRequest request) { return(await _httpClient.PutAsJsonAsync($"api/address-book/{addressId}", request)); }
public async Task <GetCustomerAddressWithCustomerResponse> UpdateAddress(Guid customerId, Guid addressId, UpdateAddressRequest dto) { var customerAddress = await _unitOfWork.CustomerAddresses.GetWithCustomerAndAddress(customerId, addressId); // validate if (customerAddress is null) { throw new KeyNotFoundException(); } if (!string.IsNullOrEmpty(dto.Name) && customerAddress.Name != dto.Name) { customerAddress.Name = dto.Name; } if (!string.IsNullOrEmpty(dto.Street) && customerAddress.Address.Street != dto.Street) { customerAddress.Address.Street = dto.Street; } if (!string.IsNullOrEmpty(dto.City) && customerAddress.Address.City != dto.City) { customerAddress.Address.City = dto.City; } if (!string.IsNullOrEmpty(dto.ZipCode) && customerAddress.Address.ZipCode != dto.ZipCode) { customerAddress.Address.ZipCode = dto.ZipCode; } if (!string.IsNullOrEmpty(dto.PhoneNumber) && customerAddress.Address.PhoneNumber != dto.PhoneNumber) { customerAddress.Address.PhoneNumber = dto.PhoneNumber; } _unitOfWork.Commit(); return(_mapper.Map <GetCustomerAddressWithCustomerResponse>(customerAddress)); }
public BaseResponse <GetAddressResponse, MundipaggErrorsResponse> UpdateAddress(string customerId, string addressId, UpdateAddressRequest request) { var method = HttpMethod.Put; var endpoint = $"/customers/{customerId}/addresses/{addressId}"; return(this.SendRequest <GetAddressResponse>(method, endpoint, request)); }
public NegotiatedContentResult <ResponseDto> PostUpdateAddress([FromBody] UpdateAddressRequest request) { ResponseDto resp = _userServices.UpdateAddress(request); return(Content(HttpStatusCode.OK, resp)); }