public async Task <IEnumerable <PostcodeDto> > GetPostcodesAsync(IEnumerable <string> postcodes, CancellationToken cancellationToken) { // format postcodes postcodes = postcodes.Select(x => PostcodeFormatter.FormatPostcode(x)).ToList(); // get postcodes from database IEnumerable <PostcodeDto> postcodesFromDb = await _repository.GetPostcodesAsync(postcodes); // find missing postcodes ImmutableHashSet <string> postcodesFromDbHashSet = postcodesFromDb.Select(x => x.Postcode).ToImmutableHashSet(); IEnumerable <string> missingPostcodes = postcodes.Where(x => !postcodesFromDbHashSet.Contains(x)).ToList(); if (!missingPostcodes.Any()) { return(postcodesFromDb); } // filter out postcodes that have no addresses so needless QAS calls aren't made missingPostcodes = missingPostcodes.Where(x => !_postcodesWithoutAddressesCache.PostcodesWithoutAddresses.Contains(x)); IEnumerable <PostcodeDto> missingPostcodeDtos = await _qasAddressGetter.GetPostCodesAndAddressesFromQasAsync(missingPostcodes, cancellationToken); // add postcodes that QAS says have no addresses to cache to postcodes without addresses cache HashSet <string> postcodesFromQas = missingPostcodeDtos.Select(x => x.Postcode).ToHashSet(); IEnumerable <string> postcodesThatHaveNoAddressess = missingPostcodes.Where(x => !postcodesFromQas.Contains(x)); _postcodesWithoutAddressesCache.AddRange(postcodesThatHaveNoAddressess); // add missing postcodes to those originally taken from the DB IEnumerable <PostcodeDto> allPostcodeDtos = postcodesFromDb.Concat(missingPostcodeDtos); return(allPostcodeDtos); }
public void returns_a_formatted_postcode(string postcode, string expected) { var postcodeFormatter = new PostcodeFormatter(); var formattedPostcode = postcodeFormatter.FormatPostcode(postcode); Assert.Equal(formattedPostcode, expected); }
public async Task <GetNearbyPostcodesResponse> Handle(GetNearbyPostcodesRequest request, CancellationToken cancellationToken) { string postcode = PostcodeFormatter.FormatPostcode(request.Postcode); // get nearest postcodes IReadOnlyList <NearestPostcodeDto> nearestPostcodeDtos = await _nearestPostcodeGetter.GetNearestPostcodesAsync(postcode, request.RadiusInMetres, request.MaxNumberOfResults); IEnumerable <string> nearestPostcodes = nearestPostcodeDtos.Select(x => x.Postcode).ToList(); // get postcodes IEnumerable <PostcodeDto> postcodeDtos = await _postcodeAndAddressGetter.GetPostcodesAsync(nearestPostcodes, cancellationToken); // create response GetNearbyPostcodesResponse getNearbyPostcodesResponse = new GetNearbyPostcodesResponse(); IEnumerable <GetNearbyPostCodeResponse> getNearbyPostCodeResponses = _mapper.Map <IEnumerable <PostcodeDto>, IEnumerable <GetNearbyPostCodeResponse> >(postcodeDtos); getNearbyPostcodesResponse.Postcodes = (from getNearbyPostCodeResponse in getNearbyPostCodeResponses join nearestPostcodeDto in nearestPostcodeDtos on getNearbyPostCodeResponse.Postcode equals nearestPostcodeDto.Postcode select new GetNearbyPostCodeResponse { Postcode = getNearbyPostCodeResponse.Postcode, AddressDetails = _addressDetailsSorter.OrderAddressDetailsResponse(getNearbyPostCodeResponse.AddressDetails), DistanceInMetres = nearestPostcodeDto.DistanceInMetres, FriendlyName = getNearbyPostCodeResponse.FriendlyName }) .OrderBy(x => x.DistanceInMetres) .ToList(); return(getNearbyPostcodesResponse); }
public async Task <GetPostCodeResponse> CheckPostCode(string postcode) { postcode = PostcodeFormatter.FormatPostcode(postcode); var response = await Client.GetAsync($"/api/getpostcode?postcode={postcode}"); var str = await response.Content.ReadAsStringAsync(); return(JsonConvert.DeserializeObject <GetPostCodeResponse>(str)); }
public ListByPostCodeRequest BuildListByPostCodeRequest(string postcode) { var formattedPostcode = _postcodeFormatter.FormatPostcode(postcode); return new ListByPostCodeRequest { PostCode = formattedPostcode, DirectUser = GetUserCredentials(), SourceSystem = GetUhSourceSystem() }; }
public void FormatPostcode(string postcodeToTest, string expected) { string postcodeInput = new String(postcodeToTest.ToArray()); string result = PostcodeFormatter.FormatPostcode(postcodeInput); Assert.AreEqual(expected, result); // check input was not modified Assert.AreEqual(postcodeToTest, postcodeInput); }
public async Task <GetPostcodeResponse> Handle(GetPostcodeRequest request, CancellationToken cancellationToken) { request.Postcode = PostcodeFormatter.FormatPostcode(request.Postcode); PostcodeDto postcodeDto = await _postcodeAndAddressGetter.GetPostcodeAsync(request.Postcode, cancellationToken); GetPostcodeResponse getNearbyGetPostcodesResponse = _mapper.Map <PostcodeDto, GetPostcodeResponse>(postcodeDto); getNearbyGetPostcodesResponse.AddressDetails = _addressDetailsSorter.OrderAddressDetailsResponse(getNearbyGetPostcodesResponse.AddressDetails); return(getNearbyGetPostcodesResponse); }
public async Task <GetHelpersByPostcodeResponse> Handle(GetHelpersByPostcodeRequest request, CancellationToken cancellationToken) { request.Postcode = PostcodeFormatter.FormatPostcode(request.Postcode); var helpers = await _helperService.GetHelpersWithinRadius(request.Postcode, null, cancellationToken); GetHelpersByPostcodeResponse response = new GetHelpersByPostcodeResponse() { Users = helpers.Select(x => x.User).ToList() }; return(response); }
public async Task <GetChampionsByPostcodeResponse> Handle(GetChampionsByPostcodeRequest request, CancellationToken cancellationToken) { request.PostCode = PostcodeFormatter.FormatPostcode(request.PostCode); IReadOnlyList <HelpMyStreet.Utils.Models.User> result = await _repository.GetChampionsByPostCodeAsync(request.PostCode); GetChampionsByPostcodeResponse response = new GetChampionsByPostcodeResponse() { Users = result }; return(response); }
public async Task <GetPostCodeCoverageResponse> GetPostcodeCoverage(string postcode) { postcode = PostcodeFormatter.FormatPostcode(postcode); GetPostCodeCoverageResponse response = new GetPostCodeCoverageResponse(); response.PostCodeResponse = await CheckPostCode(postcode); if (response.PostCodeResponse.HasContent && response.PostCodeResponse.IsSuccessful) { response.VolunteerCount = await _userRepository.GetVolunteerCountByPostcode(postcode); } return(response); }
public async Task <List <JobHeader> > AttachedDistanceToJobHeaders(string volunteerPostCode, List <JobHeader> jobHeaders, CancellationToken cancellationToken) { if (jobHeaders.Count == 0) { return(null); } volunteerPostCode = PostcodeFormatter.FormatPostcode(volunteerPostCode); foreach (JobHeader jobHeader in jobHeaders) { jobHeader.PostCode = PostcodeFormatter.FormatPostcode(jobHeader.PostCode); } List <string> distinctPostCodes = jobHeaders.Select(d => d.PostCode).Distinct().ToList(); if (!distinctPostCodes.Contains(volunteerPostCode)) { distinctPostCodes.Add(volunteerPostCode); } var postcodeCoordinatesResponse = await _repository.GetLatitudeAndLongitudes(distinctPostCodes, cancellationToken); if (postcodeCoordinatesResponse == null) { return(null); } var volunteerPostcodeCoordinates = postcodeCoordinatesResponse.Where(w => w.Postcode == volunteerPostCode).FirstOrDefault(); if (volunteerPostcodeCoordinates == null) { return(null); } foreach (JobHeader jobHeader in jobHeaders) { var jobPostcodeCoordinates = postcodeCoordinatesResponse.Where(w => w.Postcode == jobHeader.PostCode).FirstOrDefault(); if (jobPostcodeCoordinates != null) { jobHeader.DistanceInMiles = _distanceCalculator.GetDistanceInMiles(volunteerPostcodeCoordinates.Latitude, volunteerPostcodeCoordinates.Longitude, jobPostcodeCoordinates.Latitude, jobPostcodeCoordinates.Longitude); } else { jobHeader.DistanceInMiles = double.MaxValue; } } return(jobHeaders); }
public async Task <GetNearbyPostcodesWithoutAddressesResponse> Handle(GetNearbyPostcodesWithoutAddressesRequest request, CancellationToken cancellationToken) { request.Postcode = PostcodeFormatter.FormatPostcode(request.Postcode); IEnumerable <NearestPostcodeDto> nearestPostcodeDtos = await _nearestPostcodeGetter.GetNearestPostcodesAsync(request.Postcode, request.RadiusInMetres, request.MaxNumberOfResults); IEnumerable <NearestPostcodeWithoutAddress> nearestPostcodes = _mapper.Map <IEnumerable <NearestPostcodeDto>, IEnumerable <NearestPostcodeWithoutAddress> >(nearestPostcodeDtos); GetNearbyPostcodesWithoutAddressesResponse getNearbyPostcodesWithoutAddressesResponse = new GetNearbyPostcodesWithoutAddressesResponse() { NearestPostcodes = nearestPostcodes.ToList() }; return(getNearbyPostcodesWithoutAddressesResponse); }
/// <summary> /// Validates postcode using Regex and aims to produce no false negatives. /// </summary> /// <param name="postcode">Postcode to validate</param>\ /// <returns>Whether postcode is valid using regex</returns> public bool IsPostcodeValid(string postcode) { if (String.IsNullOrWhiteSpace(postcode)) { return(false); } postcode = PostcodeFormatter.FormatPostcode(postcode); if (!_postCodeRegex.IsMatch(postcode)) { return(false); } return(true); }
public async Task <List <PostcodeCoordinate> > GetPostcodeCoordinates(string postcode) { postcode = PostcodeFormatter.FormatPostcode(postcode); GetPostcodeCoordinatesRequest getPostcodeCoordinatesRequest = new GetPostcodeCoordinatesRequest() { Postcodes = new List <string>() { postcode } }; var response = await _addressRepository.GetPostcodeCoordinates(getPostcodeCoordinatesRequest); return(response.PostcodeCoordinates.ToList()); }
public PostcodeDto MapToPostcodeDto(string postcode, IEnumerable <QasFormatRootResponse> qasFormatRootResponses) { DateTime timeNow = DateTime.UtcNow; postcode = PostcodeFormatter.FormatPostcode(postcode); PostcodeDto postcodeDto = new PostcodeDto(); postcodeDto.Postcode = postcode; postcodeDto.LastUpdated = timeNow; foreach (var qasFormatRootResponse in qasFormatRootResponses) { AddressDetailsDto addressDetailsDto = new AddressDetailsDto(); foreach (QasFormatAddressReponse address in qasFormatRootResponse.Address) // to deal with strange way results are returned ... { if (!String.IsNullOrWhiteSpace(address.AddressLine1)) { addressDetailsDto.AddressLine1 = address.AddressLine1; } else if (!String.IsNullOrWhiteSpace(address.AddressLine2)) { addressDetailsDto.AddressLine2 = address.AddressLine2; } else if (!String.IsNullOrWhiteSpace(address.AddressLine3)) { addressDetailsDto.AddressLine3 = address.AddressLine3; } else if (!String.IsNullOrWhiteSpace(address.Locality)) { addressDetailsDto.Locality = address.Locality; } else if (!String.IsNullOrWhiteSpace(address.PostalCode)) { addressDetailsDto.Postcode = PostcodeFormatter.FormatPostcode(address.PostalCode); } } // filter out postcodes that weren't returned or don't have the expected postcode if (!String.IsNullOrWhiteSpace(addressDetailsDto.Postcode) && addressDetailsDto.Postcode == postcode) { addressDetailsDto.LastUpdated = timeNow; postcodeDto.AddressDetails.Add(addressDetailsDto); } } return(postcodeDto); }
public async Task <GetVolunteersByPostcodeAndActivityResponse> Handle(GetVolunteersByPostcodeAndActivityRequest request, CancellationToken cancellationToken) { request.VolunteerFilter.Postcode = PostcodeFormatter.FormatPostcode(request.VolunteerFilter.Postcode); var users = await _helperService.GetHelpersWithinRadius(request.VolunteerFilter.Postcode, request.VolunteerFilter.OverrideVolunteerRadius, cancellationToken); GetVolunteersByPostcodeAndActivityResponse response = new GetVolunteersByPostcodeAndActivityResponse { Volunteers = users.Where(x => x.User.SupportActivities.Any(sa => request.VolunteerFilter.Activities.Any(ra => sa == ra))) .Select(x => new VolunteerSummary { UserID = x.User.ID, DistanceInMiles = x.Distance }).ToList() }; return(response); }
public async Task <IEnumerable <PostcodeWithNumberOfAddressesDto> > GetNumberOfAddressesPerPostcodeAsync(IEnumerable <string> postcodes, CancellationToken cancellationToken) { // format postcodes postcodes = postcodes.Select(x => PostcodeFormatter.FormatPostcode(x)).ToList(); // filter out postcodes that have no addresses postcodes = postcodes.Where(x => !_postcodesWithoutAddressesCache.PostcodesWithoutAddresses.Contains(x)); // get postcodes with number of addresses from database IEnumerable <PostcodeWithNumberOfAddressesDto> postCodesWithNumberOfAddresses = await _repository.GetNumberOfAddressesPerPostcodeAsync(postcodes); // find missing postcodes ImmutableHashSet <string> postcodesFromDbHashSet = postCodesWithNumberOfAddresses.Select(x => x.Postcode).ToImmutableHashSet(); List <string> postcodesWithoutAddresses = postcodes.Where(x => !postcodesFromDbHashSet.Contains(x)).ToList(); if (!postcodesWithoutAddresses.Any()) { return(postCodesWithNumberOfAddresses); } // get and save addresses for postcodes without addresses IEnumerable <PostcodeDto> missingPostcodeDtos = await _qasAddressGetter.GetPostCodesAndAddressesFromQasAsync(postcodesWithoutAddresses, cancellationToken); // add postcodes that QAS says have no addresses to cache HashSet <string> postcodesFromQas = missingPostcodeDtos.Select(x => x.Postcode).ToHashSet(); IEnumerable <string> postcodesThatHaveNoAddressess = postcodesWithoutAddresses.Where(x => !postcodesFromQas.Contains(x)); _postcodesWithoutAddressesCache.AddRange(postcodesThatHaveNoAddressess); IEnumerable <PostcodeWithNumberOfAddressesDto> missingPostCodesWithNumberOfAddresses = missingPostcodeDtos.GroupBy(x => x.Postcode) .Select(x => new PostcodeWithNumberOfAddressesDto() { Postcode = x.Key, NumberOfAddresses = x.Sum(y => y.AddressDetails.Count) }); IEnumerable <PostcodeWithNumberOfAddressesDto> postCodesWithNumberOfAddresses2 = postCodesWithNumberOfAddresses.Where(x => x.NumberOfAddresses >= 0).Concat(missingPostCodesWithNumberOfAddresses); return(postCodesWithNumberOfAddresses2); }
/// <summary> /// Validates postcode by checking using Regex. If this says it's valid, it checks the DB to see if the postcode is active. /// </summary> /// <param name="postcode"></param> /// <returns></returns> public async Task <bool> IsPostcodeValidAsync(string postcode) { if (!_regexPostcodeValidator.IsPostcodeValid(postcode)) { return(false); } postcode = PostcodeFormatter.FormatPostcode(postcode); try { bool isPostcodeInDbAndActive = await _repository.IsPostcodeInDbAndActive(postcode); return(isPostcodeInDbAndActive); } catch (Exception ex) { _logger.LogWarning("Error calling PostcodeIO to validate postcode. Returning that postcode is valid since it passes Regex", ex); return(true); } }
public async Task <QasSearchRootResponse> GetGlobalIntuitiveSearchResponseAsync(string postcode, CancellationToken cancellationToken) { postcode = postcode.Replace(" ", ""); string path = $"capture/address/v2/search"; string query = $"query={postcode}&country=GBR&take=100"; string absolutePath = $"{path}?{query}"; QasSearchRootResponse qasSearchRootResponse; using (HttpResponseMessage response = await _httpClientWrapper.GetAsync(HttpClientConfigName.Qas, absolutePath, cancellationToken).ConfigureAwait(false)) { response.EnsureSuccessStatusCode(); Stream stream = await response.Content.ReadAsStreamAsync(); qasSearchRootResponse = stream.ReadAndDeserializeFromJson <QasSearchRootResponse>(); } qasSearchRootResponse.Postcode = PostcodeFormatter.FormatPostcode(postcode); return(qasSearchRootResponse); }
public async Task <GetDistanceBetweenPostcodesResponse> Handle(GetDistanceBetweenPostcodesRequest request, CancellationToken cancellationToken) { request.Postcode1 = PostcodeFormatter.FormatPostcode(request.Postcode1); request.Postcode2 = PostcodeFormatter.FormatPostcode(request.Postcode2); var postcodeDetails = await _repository.GetPostcodeCoordinatesAsync(new List <string>() { request.Postcode1, request.Postcode2 }); if (postcodeDetails == null) { throw new Exception($"Unable to retrieve post code details for {request.Postcode1} or {request.Postcode2}"); } if (postcodeDetails.Count() != 2) { throw new Exception($"Only expecting 2 row in collection for {request.Postcode1} and {request.Postcode2}. {postcodeDetails.Count()} rows returned"); } var postcodeDetails1 = postcodeDetails.FirstOrDefault(x => x.Postcode == request.Postcode1); var postcodeDetails2 = postcodeDetails.FirstOrDefault(x => x.Postcode == request.Postcode2); if (postcodeDetails1 == null || postcodeDetails2 == null) { throw new Exception($"Either postcode details not returned for {request.Postcode1} and {request.Postcode2}."); } var distanceInMiles = _distanceCalculator.GetDistanceInMiles( postcodeDetails1.Latitude, postcodeDetails1.Longitude, postcodeDetails2.Latitude, postcodeDetails2.Longitude ); return(new GetDistanceBetweenPostcodesResponse() { DistanceInMiles = distanceInMiles }); }
private void AddDataRowToDataTable(DataTable dataTable, string input) { string[] split = input.Split(','); bool rowHasEnoughColumns = split.Length > 43; if (!rowHasEnoughColumns) { Console.WriteLine("CS row doesn't have enough columns"); return; } string postcode = split[0]; if (postcode != null) { postcode = postcode.Replace("\"", ""); postcode = PostcodeFormatter.FormatPostcode(postcode); } bool postcodeIsValid = _regexPostcodeValidator.IsPostcodeValid(postcode); bool latitudeIsValid = decimal.TryParse(split[42], out decimal latitude); if (latitudeIsValid) { latitudeIsValid = latitude >= -90 && latitude <= 90; } bool longitudeIsValid = decimal.TryParse(split[43], out decimal longitude); if (longitudeIsValid) { longitudeIsValid = longitude >= -180 && longitude <= 180; } var introductionDateString = split[3]; var terminationDateString = split[4]; var isPostCodeActive = OnsActivePostcodeDeterminer.IsPostcodeActive(introductionDateString, terminationDateString, DateTime.UtcNow); if (!postcodeIsValid) { _invalidPostcodes.Add(postcode); _numberOfInvalidPostcodes++; } if (!latitudeIsValid) { _numberOfInvalidLatitudes++; } if (!longitudeIsValid) { _numberOfInvalidLongitudes++; } if (!isPostCodeActive) { _numberOfTerminatedPostcodes++; } if (!postcodeIsValid || !latitudeIsValid || !longitudeIsValid) { _numberOfInvalidRows++; } else { DataRow dataRow = dataTable.NewRow(); dataRow["Postcode"] = postcode; dataRow["Latitude"] = latitude; dataRow["Longitude"] = longitude; dataRow["IsActive"] = isPostCodeActive; dataTable.Rows.Add(dataRow); } }
public void ThrowExceptionOnNullInput() { Assert.Throws <ArgumentNullException>(() => PostcodeFormatter.FormatPostcode(null)); }
public void MapToPostcodeDto() { QasMapper qasMapper = new QasMapper(); var postCode = "ng1 5fs"; var expectedPostcode = PostcodeFormatter.FormatPostcode(postCode); IEnumerable <QasFormatRootResponse> qasFormatRootResponses = new List <QasFormatRootResponse>() { new QasFormatRootResponse() { Address = new List <QasFormatAddressReponse>() { new QasFormatAddressReponse() { PostalCode = postCode }, new QasFormatAddressReponse() { AddressLine1 = "line1" }, new QasFormatAddressReponse() { AddressLine2 = "line2" }, new QasFormatAddressReponse() { AddressLine3 = "line3" }, new QasFormatAddressReponse() { Locality = "loc" }, } }, new QasFormatRootResponse() { Address = new List <QasFormatAddressReponse>() { new QasFormatAddressReponse() { PostalCode = "FilterMeOut" }, new QasFormatAddressReponse() { AddressLine1 = "line1" }, new QasFormatAddressReponse() { AddressLine2 = "line2" }, new QasFormatAddressReponse() { AddressLine3 = "line3" }, new QasFormatAddressReponse() { Locality = "loc" } } }, new QasFormatRootResponse() { Address = new List <QasFormatAddressReponse>() { new QasFormatAddressReponse() { PostalCode = null }, new QasFormatAddressReponse() { AddressLine1 = "line1" }, new QasFormatAddressReponse() { AddressLine2 = "line2" }, new QasFormatAddressReponse() { AddressLine3 = "line3" }, new QasFormatAddressReponse() { Locality = "loc" } } } }; PostcodeDto result = qasMapper.MapToPostcodeDto(postCode, qasFormatRootResponses); Assert.AreEqual(1, result.AddressDetails.Count); Assert.AreEqual(expectedPostcode, result.Postcode); Assert.AreNotEqual(DateTime.MinValue, result.LastUpdated); AddressDetailsDto addressResult = result.AddressDetails.FirstOrDefault(); Assert.AreEqual(expectedPostcode, addressResult.Postcode); Assert.AreEqual("line1", addressResult.AddressLine1); Assert.AreEqual("line2", addressResult.AddressLine2); Assert.AreEqual("line3", addressResult.AddressLine3); Assert.AreEqual("loc", addressResult.Locality); Assert.AreNotEqual(DateTime.MinValue, addressResult.LastUpdated); }
public async Task <IEnumerable <PostcodeDto> > GetPostCodesAndAddressesFromQasAsync(IEnumerable <string> missingPostcodes, CancellationToken cancellationToken) { // call QAS for missing postcodes and addresses List <Task <QasSearchRootResponse> > qasSearchResponseTasks = new List <Task <QasSearchRootResponse> >(); List <QasSearchRootResponse> qasSearchResponses = new List <QasSearchRootResponse>(); foreach (string missingPostcode in missingPostcodes) { Task <QasSearchRootResponse> qasResponseTask = _qasService.GetGlobalIntuitiveSearchResponseAsync(PostcodeFormatter.FormatPostcode(missingPostcode), cancellationToken); qasSearchResponseTasks.Add(qasResponseTask); } while (qasSearchResponseTasks.Count > 0) { Task <QasSearchRootResponse> finishedQasResponseTask = await Task.WhenAny(qasSearchResponseTasks); qasSearchResponseTasks.Remove(finishedQasResponseTask); QasSearchRootResponse qasSearchResponse = await finishedQasResponseTask; qasSearchResponses.Add(qasSearchResponse); } // call QAS for address details (grouped by postcode to avoid sending 1000s of request at once and to map a single PostcodeDto at a time) ILookup <string, string> missingQasFormatIdsGroupedByPostCode = _qasMapper.GetFormatIds(qasSearchResponses); List <PostcodeDto> missingPostcodeDtos = new List <PostcodeDto>(); foreach (IGrouping <string, string> missingQasFormatIds in missingQasFormatIdsGroupedByPostCode) { List <Task <QasFormatRootResponse> > qasFormatResponseTasks = new List <Task <QasFormatRootResponse> >(); foreach (string missingQasFormatId in missingQasFormatIds) { Task <QasFormatRootResponse> qasFormatResponseTask = _qasService.GetGlobalIntuitiveFormatResponseAsync(missingQasFormatId, cancellationToken); qasFormatResponseTasks.Add(qasFormatResponseTask); } List <QasFormatRootResponse> qasFormatResponses = new List <QasFormatRootResponse>(); while (qasFormatResponseTasks.Count > 0) { Task <QasFormatRootResponse> finishedQasFormatResponseTask = await Task.WhenAny(qasFormatResponseTasks); qasFormatResponseTasks.Remove(finishedQasFormatResponseTask); QasFormatRootResponse qasFormatResponse = await finishedQasFormatResponseTask; qasFormatResponses.Add(qasFormatResponse); } PostcodeDto missingPostcodeDtosForThisBatch = _qasMapper.MapToPostcodeDto(missingQasFormatIds.Key, qasFormatResponses); try { //new addresses need a friendly name _friendlyNameGenerator.GenerateFriendlyName(missingPostcodeDtosForThisBatch); } catch (Exception ex) { _logger.LogWarning("Error generating friendly name", ex); } missingPostcodeDtos.Add(missingPostcodeDtosForThisBatch); } if (missingPostcodeDtos.Any()) { await _repository.SaveAddressesAndFriendlyNameAsync(missingPostcodeDtos); } return(missingPostcodeDtos); }
public async Task <GetPostcodesResponse> Handle(GetPostcodesRequest request, CancellationToken cancellationToken) { GetPostcodesResponse getPostcodesResponse = new GetPostcodesResponse() { PostcodesResponse = new System.Collections.Generic.Dictionary <string, GetPostcodeResponse>() }; request.PostcodeList.Postcodes = request.PostcodeList.Postcodes.Select(x => PostcodeFormatter.FormatPostcode(x)).ToList(); System.Collections.Generic.IEnumerable <PostcodeDto> postcodesDto = await _repository.GetPostcodesAsync(request.PostcodeList.Postcodes); if (!request.IncludeAddressDetails) { foreach (PostcodeDto postcodeDto in postcodesDto) { postcodeDto.AddressDetails = null; } } foreach (PostcodeDto postcodeDto in postcodesDto) { getPostcodesResponse.PostcodesResponse.Add(postcodeDto.Postcode, _mapper.Map <PostcodeDto, GetPostcodeResponse>(postcodeDto)); } return(getPostcodesResponse); }