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));
}
