public IActionResult GetAddress(string addressKey)
{
try
{
var request = new GetAddressRequest {
addressID = addressKey
};
var response = _getAddressUseCase.ExecuteAsync(request);
if (response?.Address == null)
{
return(new NotFoundObjectResult(new ErrorResponse(404, new List <Error>
{
new Error("An address could not be found for the given key")
})));
}
return(new OkObjectResult(new APIResponse <GetAddressResponse>(response)));
}
catch (BadRequestException)
{
return(new BadRequestObjectResult(new ErrorResponse(400, new List <Error>
{
new Error("Address Key is invalid. It should by 14 characters long string.")
})));
}
}
public GetAddressResponse GetAddress(GetAddressRequest request)
{
GetAddressResponse response = new GetAddressResponse();
Consumer consumer = null;
try
{
using (UserDao dao = new UserDao())
{
consumer = GetAuthUser(dao, request.user_id, request.auth_token, true);
if (consumer == null)
{
MakeNouserResponse(response);
return(response);
}
ConsumerAddress consAddr = consumer.ConsumerAddresses.Where(a => a.AddrID == request.address_id).First();
UserAddressesDto addrDto = new UserAddressesDto();
UsersHelper.CopyFromEntity(addrDto, consAddr, consumer.Name);
response.user_address = addrDto;
response.has_resource = 1;
response.code = 0;
response.message = MessagesSource.GetMessage("addr.details");
return(response);
}
}
catch (Exception ex)
{
response.MakeExceptionResponse(ex);
}
return(response);
}
public async Task <GetExpandedAddressResponse> GetExpanded(GetAddressRequest request, ApiKey apiKey = null, HttpClient httpClient = null)
{
using (var api = new GetAddesssApi(apiKey ?? ApiKey, HttpClient ?? httpClient))
{
return(await api.Address.GetExpanded(request));
}
}
/// <summary>
/// Looks up an address by id.
/// </summary>
/// <param name="addressId">the address id</param>
/// <returns>the address record</returns>
public Task <AddressRecord> GetAddress(string addressId)
{
var request = new GetAddressRequest {
AddressId = addressId
};
return(gateway(authenticateOnBehalfOf()).GetAddressAsync(request)
.ToTask(response => response.Address));
}
public IActionResult GetAddress(string addressId)
{
var request = new GetAddressRequest {
addressID = addressId
};
var response = _getAddressUseCase.ExecuteAsync(request);
return(HandleResponse(response));
}
public ActionResult <GetAddressResponse> GetAddress(long id)
{
var getAddressRequest = new GetAddressRequest
{
Id = id
};
var getAddressResponse = _addressService.GetAddress(getAddressRequest);
return(getAddressResponse);
}
public void GivenString13Characters_WhenExecuteAsync_TheShouldThrowException()
{
var request = new GetAddressRequest {
addressID = "ABCDEFGHIJKLM"
};
//act & assert
_classUnderTest.ShouldHaveValidationErrorFor(x => x.addressID, request)
.WithErrorMessage("addressID must be 14 characters");
}
public void GivenBlankStringInput_WhenExecuteAsync_ThenShouldThrowException()
{
//arrange
var request = new GetAddressRequest {
addressID = string.Empty
};
//act & assert
_classUnderTest.ShouldHaveValidationErrorFor(x => x.addressID, request)
.WithErrorMessage("addressID must be provided");
}
public void GivenValidInput_WhenExecuteAsync_GatewayReceivesCorrectInputLength()
{
var lpi_key = "ABCDEFGHIJKLMN"; //14 characters
_fakeGateway.Setup(s => s.GetSingleAddress("ABCDEFGHIJKLMN")).Returns(new Address()).Verifiable();
SetupValidatorToReturnValid();
var request = new GetAddressRequest
{
addressID = lpi_key
};
_classUnderTest.ExecuteAsync(request);
_fakeGateway.Verify();
}
public override Task <GetAddressResponse> GetAddress(
GetAddressRequest request, ServerCallContext context)
{
var location = GetBreakpointLocation(request.BreakpointLocation);
var response = new GetAddressResponse();
var address = location.GetAddress();
if (address != null)
{
response.Address = new GrpcSbAddress
{
Id = addressStore.AddObject(address)
};
}
return(Task.FromResult(response));
}
/// <summary>Snippet for Get</summary>
public void GetRequestObject()
{
// Snippet: Get(GetAddressRequest, CallSettings)
// Create client
AddressesClient addressesClient = AddressesClient.Create();
// Initialize request argument(s)
GetAddressRequest request = new GetAddressRequest
{
Region = "",
Project = "",
Address = "",
};
// Make the request
Address response = addressesClient.Get(request);
// End snippet
}
public GetAddressResponse GetAddress(GetAddressRequest getAddressRequest)
{
GetAddressResponse getAddressResponse = null;
if (getAddressRequest.Id > 0)
{
var address = _addressRepository.FindAddressById(getAddressRequest.Id);
var addressDto = _messageMapper.MapToAddressDto(address);
getAddressResponse = new GetAddressResponse
{
Address = addressDto
};
}
return(getAddressResponse);
}
public void GivenValidLPIKey_WhenExecuteAsync_ThenAddressShouldBeReturned()
{
SetupValidatorToReturnValid();
var address = new Address
{
AddressKey = "ABCDEFGHIJKLMN",
UPRN = 10024389298,
USRN = 21320239,
ParentUPRN = 10024389282,
AddressStatus = "Historical",
UnitName = "FLAT 16",
UnitNumber = "",
BuildingName = "HAZELNUT COURT",
BuildingNumber = "1",
Street = "FIRWOOD LANE",
Postcode = "RM3 0FS",
Locality = "",
Gazetteer = "NATIONAL",
CommercialOccupier = "",
UsageDescription = "Unclassified, Awaiting Classification",
UsagePrimary = "Unclassified",
UsageCode = "UC",
PropertyShell = false,
OutOfBoroughAddress = false,
Easting = 554189.4500,
Northing = 190281.1000,
Longitude = 0.2244347,
Latitude = 51.590289
};
var lpi_key = "ABCDEFGHIJKLMN";
var request = new GetAddressRequest
{
addressID = lpi_key
};
_fakeGateway.Setup(s => s.GetSingleAddress(lpi_key))
.Returns(address);
var response = _classUnderTest.ExecuteAsync(request);
response.Should().NotBeNull();
response.Address.AddressShouldEqual(address);
}
/// <summary>
/// Gets a single Address based on it's unique identifier
/// </summary>
/// <param name="addressId">The unique Id for the address to find</param>
/// <returns>
/// The Address matching the requested ID, or null
/// </returns>
public Task <Address> GetAddressByIdAsync(Guid addressId)
{
if (addressId == Guid.Empty)
{
throw new ArgumentNullException("addressId");
}
var request = new GetAddressRequest
{
AddressId = addressId
};
var cacheKey = new CacheKey(CacheConfigurationCategoryNames.Address);
cacheKey.AppendKeyParts(addressId);
return(CacheProvider.GetOrAddAsync(cacheKey, () => OvertureClient.SendAsync(request)));
}
public void GivenValidInput_WhenGatewayRespondsWithNull_ThenResponseShouldBeNull()
{
//arrange
var lpi_key = "ABCDEFGHIJKLMN";
SetupValidatorToReturnValid();
_fakeGateway.Setup(s => s.GetSingleAddress("ABCDEFGHIJKLMN"))
.Returns((Address)null);
var request = new GetAddressRequest
{
addressID = lpi_key
};
//act
var response = _classUnderTest.ExecuteAsync(request);
//assert
response.Address.Should().BeNull();
}
/// <summary>Snippet for GetAsync</summary>
public async Task GetRequestObjectAsync()
{
// Snippet: GetAsync(GetAddressRequest, CallSettings)
// Additional: GetAsync(GetAddressRequest, CancellationToken)
// Create client
AddressesClient addressesClient = await AddressesClient.CreateAsync();
// Initialize request argument(s)
GetAddressRequest request = new GetAddressRequest
{
Region = "",
Project = "",
Address = "",
};
// Make the request
Address response = await addressesClient.GetAsync(request);
// End snippet
}
public async stt::Task GetRequestObjectAsync()
{
moq::Mock <Addresses.AddressesClient> mockGrpcClient = new moq::Mock <Addresses.AddressesClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClientForRegionOperations()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
GetAddressRequest request = new GetAddressRequest
{
Region = "regionedb20d96",
Project = "projectaa6ff846",
Address = "address04984d88",
};
Address expectedResponse = new Address
{
Id = 11672635353343658936UL,
Kind = "kindf7aa39d9",
Name = "name1c9368b0",
CreationTimestamp = "creation_timestamp235e59a1",
Users = { "users2a5cc69b", },
Region = "regionedb20d96",
Status = Address.Types.Status.Reserved,
Network = "networkd22ce091",
AddressType = Address.Types.AddressType.Internal,
IpVersion = Address.Types.IpVersion.UndefinedIpVersion,
Subnetwork = "subnetworkf55bf572",
Purpose = Address.Types.Purpose.IpsecInterconnect,
Description = "description2cf9da67",
PrefixLength = -686118004,
SelfLink = "self_link7e87f12d",
Address_ = "address04984d88",
NetworkTier = Address.Types.NetworkTier.Standard,
};
mockGrpcClient.Setup(x => x.GetAsync(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(new grpccore::AsyncUnaryCall <Address>(stt::Task.FromResult(expectedResponse), null, null, null, null));
AddressesClient client = new AddressesClientImpl(mockGrpcClient.Object, null);
Address responseCallSettings = await client.GetAsync(request, gaxgrpc::CallSettings.FromCancellationToken(st::CancellationToken.None));
xunit::Assert.Same(expectedResponse, responseCallSettings);
Address responseCancellationToken = await client.GetAsync(request, st::CancellationToken.None);
xunit::Assert.Same(expectedResponse, responseCancellationToken);
mockGrpcClient.VerifyAll();
}
public void GetRequestObject()
{
moq::Mock <Addresses.AddressesClient> mockGrpcClient = new moq::Mock <Addresses.AddressesClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClientForRegionOperations()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
GetAddressRequest request = new GetAddressRequest
{
Region = "regionedb20d96",
Project = "projectaa6ff846",
Address = "address04984d88",
};
Address expectedResponse = new Address
{
Id = 11672635353343658936UL,
Kind = "kindf7aa39d9",
Name = "name1c9368b0",
CreationTimestamp = "creation_timestamp235e59a1",
Users = { "users2a5cc69b", },
Region = "regionedb20d96",
Status = "status5444cb9a",
Network = "networkd22ce091",
AddressType = "address_type6c7d490a",
IpVersion = "ip_versionde91b460",
Subnetwork = "subnetworkf55bf572",
Purpose = "purposebb6b064d",
Description = "description2cf9da67",
PrefixLength = -686118004,
SelfLink = "self_link7e87f12d",
Address_ = "address04984d88",
NetworkTier = "network_tiere6fea951",
};
mockGrpcClient.Setup(x => x.Get(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
AddressesClient client = new AddressesClientImpl(mockGrpcClient.Object, null);
Address response = client.Get(request);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public async Task <AddressCheckViewModel> GetAddressViewModel(GetAddressRequest request)
{
_logger.LogInformation($"Retrieving address check details for application {request.ApplicationId}");
var model = new AddressCheckViewModel();
await model.PopulatePageCommonDetails(_applyApiClient, request.ApplicationId, GatewaySequences.OrganisationChecks,
GatewayPageIds.Address,
request.UserId,
request.UserName,
RoatpGatewayConstants.Captions.OrganisationChecks,
RoatpGatewayConstants.Headings.AddressCheck,
NoSelectionErrorMessages.Errors[GatewayPageIds.Address]);
var organisationAddress = await _applyApiClient.GetOrganisationAddress(request.ApplicationId);
if (organisationAddress != null)
{
var AddressArray = new[] { organisationAddress.Address1, organisationAddress.Address2, organisationAddress.Address3, organisationAddress.Address4, organisationAddress.Town, organisationAddress.PostCode };
model.SubmittedApplicationAddress = string.Join(", ", AddressArray.Where(s => !string.IsNullOrEmpty(s)));
}
var ukrlpDetails = await _applyApiClient.GetUkrlpDetails(request.ApplicationId);
if (ukrlpDetails != null)
{
var ukrlpAddressLine1 = ukrlpDetails.ContactDetails.FirstOrDefault().ContactAddress.Address1;
var ukrlpAddressLine2 = ukrlpDetails.ContactDetails.FirstOrDefault().ContactAddress.Address2;
var ukrlpAddressLine3 = ukrlpDetails.ContactDetails.FirstOrDefault().ContactAddress.Address3;
var ukrlpAddressLine4 = ukrlpDetails.ContactDetails.FirstOrDefault().ContactAddress.Address4;
var ukrlpTown = ukrlpDetails.ContactDetails.FirstOrDefault().ContactAddress.Town;
var ukrlpPostCode = ukrlpDetails.ContactDetails.FirstOrDefault().ContactAddress.PostCode;
var ukrlpAarray = new[] { ukrlpAddressLine1, ukrlpAddressLine2, ukrlpAddressLine3, ukrlpAddressLine4, ukrlpTown, ukrlpPostCode };
var ukrlpAddress = string.Join(", ", ukrlpAarray.Where(s => !string.IsNullOrEmpty(s)));
model.UkrlpAddress = ukrlpAddress;
}
return(model);
}
public GetAddressResponse ExecuteAsync(GetAddressRequest request)
{
var validationResponse = _getAddressValidator.Validate(request);
if (!validationResponse.IsValid)
{
throw new BadRequestException(validationResponse);
}
var response = _addressGateway.GetSingleAddress(request.addressID);
if (response == null)
{
return(new GetAddressResponse());
}
var useCaseResponse = new GetAddressResponse
{
Address = response.ToResponse()
};
return(useCaseResponse);
}
public void Get()
{
moq::Mock <Addresses.AddressesClient> mockGrpcClient = new moq::Mock <Addresses.AddressesClient>(moq::MockBehavior.Strict);
GetAddressRequest request = new GetAddressRequest
{
Region = "regionedb20d96",
Project = "projectaa6ff846",
Address = "address04984d88",
};
Address expectedResponse = new Address
{
Id = 11672635353343658936UL,
Kind = "kindf7aa39d9",
Name = "name1c9368b0",
CreationTimestamp = "creation_timestamp235e59a1",
Users = { "users2a5cc69b", },
Region = "regionedb20d96",
Status = Address.Types.Status.Reserved,
Network = "networkd22ce091",
AddressType = Address.Types.AddressType.Internal,
IpVersion = Address.Types.IpVersion.UndefinedIpVersion,
Subnetwork = "subnetworkf55bf572",
Purpose = Address.Types.Purpose.IpsecInterconnect,
Description = "description2cf9da67",
PrefixLength = -686118004,
SelfLink = "self_link7e87f12d",
Address_ = "address04984d88",
NetworkTier = Address.Types.NetworkTier.Standard,
};
mockGrpcClient.Setup(x => x.Get(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
AddressesClient client = new AddressesClientImpl(mockGrpcClient.Object, null);
Address response = client.Get(request.Project, request.Region, request.Address);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public async Task <GetAddressResponse> Get(GetAddressRequest request)
{
return(await Get(Api, Path, this.ApiKey, request));
}
public async static Task <GetAddressResponse> Get(GetAddesssApi api, string path, ApiKey apiKey, GetAddressRequest request)
{
if (api == null)
{
throw new ArgumentNullException(nameof(api));
}
if (path == null)
{
throw new ArgumentNullException(nameof(path));
}
if (apiKey == null)
{
throw new ArgumentNullException(nameof(apiKey));
}
if (request == null)
{
throw new ArgumentNullException(nameof(request));
}
var fullPath = $"{path}{request.Postcode}/{request.House}?sort={request.Sort}";
api.SetAuthorizationKey(apiKey);
var response = await api.Get(fullPath);
var body = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
var addressesBody = GetAddressBody(body);
double latitude = addressesBody.Item1;
double longitude = addressesBody.Item2;
var addresses = addressesBody.Item3;
return(new GetAddressResponse.Success((int)response.StatusCode, response.ReasonPhrase, body, latitude, longitude, addresses));
}
return(new GetAddressResponse.Failed((int)response.StatusCode, response.ReasonPhrase, body));//todo: move failed responses
}
public void check_orchestrator_builds_with_both_addresses_details()
{
var applicationId = Guid.NewGuid();
var commonDetails = new GatewayCommonDetails
{
ApplicationSubmittedOn = DateTime.Now.AddDays(-3),
SourcesCheckedOn = DateTime.Now,
LegalName = UKRLPLegalName,
Ukprn = ukprn
};
_applyApiClient.Setup(x => x.GetPageCommonDetails(It.IsAny <Guid>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(commonDetails);
// SubmittedApplicationAddress
var SubmittedApplicationAddress = "1 QnA Street, Second Address, Third Address, Forth Address, Coventry, CV2 1WT";
var organisationAddressResult = new ContactAddress
{
Address1 = "1 QnA Street",
Address2 = "Second Address",
Address3 = "Third Address",
Address4 = "Forth Address",
Town = "Coventry",
PostCode = "CV2 1WT"
};
_applyApiClient.Setup(x => x.GetOrganisationAddress(It.IsAny <Guid>())).ReturnsAsync(organisationAddressResult);
// UkrlpAddress
var UkrlpAddress = "1 First Street, Second Address, Third Address, Forth Address, Coventry, CV1 2WT";
var ukrlpDetails = new ProviderDetails
{
ContactDetails = new List <ProviderContact>
{
new ProviderContact {
ContactAddress = new ContactAddress {
Address1 = "1 First Street",
Address2 = "Second Address",
Address3 = "Third Address",
Address4 = "Forth Address",
Town = "Coventry",
PostCode = "CV1 2WT"
}
}
}
};
_applyApiClient.Setup(x => x.GetUkrlpDetails(It.IsAny <Guid>())).ReturnsAsync(ukrlpDetails);
var request = new GetAddressRequest(applicationId, UserId, UserName);
var response = _orchestrator.GetAddressViewModel(request);
var viewModel = response.Result;
Assert.AreEqual(UKRLPLegalName, viewModel.ApplyLegalName);
Assert.AreEqual(ukprn, viewModel.Ukprn);
Assert.AreEqual(SubmittedApplicationAddress, viewModel.SubmittedApplicationAddress);
Assert.AreEqual(UkrlpAddress, viewModel.UkrlpAddress);
}
/// <summary> /// Returns the specified address resource. /// </summary> /// <param name="request">The request object containing all of the parameters for the API call.</param> /// <param name="callSettings">If not null, applies overrides to this RPC call.</param> /// <returns>The RPC response.</returns> public virtual Address Get(GetAddressRequest request, gaxgrpc::CallSettings callSettings = null) => throw new sys::NotImplementedException();
/// <summary> /// Returns the specified address resource. /// </summary> /// <param name="request">The request object containing all of the parameters for the API call.</param> /// <param name="callSettings">If not null, applies overrides to this RPC call.</param> /// <returns>A Task containing the RPC response.</returns> public virtual stt::Task <Address> GetAsync(GetAddressRequest request, gaxgrpc::CallSettings callSettings = null) => throw new sys::NotImplementedException();
/// <summary> /// Returns the specified address resource. /// </summary> /// <param name="request">The request object containing all of the parameters for the API call.</param> /// <param name="cancellationToken">A <see cref="st::CancellationToken"/> to use for this RPC.</param> /// <returns>A Task containing the RPC response.</returns> public virtual stt::Task <Address> GetAsync(GetAddressRequest request, st::CancellationToken cancellationToken) => GetAsync(request, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken));
/// <summary>
/// Returns the specified address resource.
/// </summary>
/// <param name="request">The request object containing all of the parameters for the API call.</param>
/// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
/// <returns>A Task containing the RPC response.</returns>
public override stt::Task <Address> GetAsync(GetAddressRequest request, gaxgrpc::CallSettings callSettings = null)
{
Modify_GetAddressRequest(ref request, ref callSettings);
return(_callGet.Async(request, callSettings));
}
/// <summary>
/// Returns the specified address resource.
/// </summary>
/// <param name="request">The request object containing all of the parameters for the API call.</param>
/// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
/// <returns>The RPC response.</returns>
public override Address Get(GetAddressRequest request, gaxgrpc::CallSettings callSettings = null)
{
Modify_GetAddressRequest(ref request, ref callSettings);
return(_callGet.Sync(request, callSettings));
}
partial void Modify_GetAddressRequest(ref GetAddressRequest request, ref gaxgrpc::CallSettings settings);
