|
| 1 | +import { Injectable } from '@angular/core'; |
| 2 | +import { HttpClient, HttpParams } from '@angular/common/http'; |
| 3 | +import { Observable } from 'rxjs'; |
| 4 | +import { environment } from '../../../environments/environment'; |
| 5 | +import { catchError, map, take } from 'rxjs/operators'; |
| 6 | +import { hasValue } from '../../shared/empty.util'; |
| 7 | + |
| 8 | +export interface LocationCoordinates { |
| 9 | + latitude: number, |
| 10 | + longitude: number, |
| 11 | +} |
| 12 | + |
| 13 | +export interface LocationPlace { |
| 14 | + coordinates?: LocationCoordinates, |
| 15 | + displayName?: string, |
| 16 | +} |
| 17 | + |
| 18 | +export enum LocationErrorCodes { |
| 19 | + // define a `location.error.*` i18n label for each error code |
| 20 | + INVALID_COORDINATES = 'invalid-coordinates', |
| 21 | + LOCATION_NOT_FOUND = 'location-not-found', |
| 22 | + API_ERROR = 'api-error', |
| 23 | +} |
| 24 | + |
| 25 | +const IS_COORDINATE_PAIR_REGEXP = /^\d+\.?\d*,\d+\.?\d*$/; |
| 26 | + |
| 27 | +const NOMINATIM_RESPONSE_FORMAT = 'jsonv2'; |
| 28 | + |
| 29 | +@Injectable({ |
| 30 | + providedIn: 'root' |
| 31 | +}) |
| 32 | +export class LocationService { |
| 33 | + |
| 34 | + searchEndpoint = environment.location.nominatimApi.searchEndpoint; |
| 35 | + reverseSearchEndpoint = environment.location.nominatimApi.reverseSearchEndpoint; |
| 36 | + |
| 37 | + constructor( |
| 38 | + protected http: HttpClient, |
| 39 | + ) { } |
| 40 | + |
| 41 | + /** |
| 42 | + * Search a place (address or POI) with Nominatim, and return the coordinates and the display name of the most relevant search result |
| 43 | + * @param address the place to be searched |
| 44 | + * @returns {LocationPlace} the information related to the searched place |
| 45 | + */ |
| 46 | + public searchPlace(address: string): Observable<LocationPlace> { |
| 47 | + let params = new HttpParams().append('q', address).append('format', NOMINATIM_RESPONSE_FORMAT); |
| 48 | + |
| 49 | + return this.http.get<Record<string,any>[]>(this.searchEndpoint, { params: params }).pipe( |
| 50 | + catchError((err) => { |
| 51 | + console.error('Location service', err); |
| 52 | + throw Error(LocationErrorCodes.API_ERROR); |
| 53 | + }), |
| 54 | + take(1), |
| 55 | + map((searchResults) => { |
| 56 | + if (searchResults.length > 1) { |
| 57 | + console.warn('Location service', `Multiple locations found for address "${address}"`, 'Showing top matches', searchResults.slice(0,5)); |
| 58 | + } |
| 59 | + if (searchResults.length > 0) { |
| 60 | + const firstMatch = searchResults[0]; |
| 61 | + const coordinates: LocationCoordinates = { |
| 62 | + latitude: parseFloat(firstMatch.lat), |
| 63 | + longitude: parseFloat(firstMatch.lon), |
| 64 | + }; |
| 65 | + const info: LocationPlace = { |
| 66 | + coordinates: coordinates, |
| 67 | + displayName: firstMatch.display_name, |
| 68 | + }; |
| 69 | + return info; |
| 70 | + } else { |
| 71 | + console.warn('Location service', `Location "${address}" not found`); |
| 72 | + throw Error(LocationErrorCodes.LOCATION_NOT_FOUND); |
| 73 | + } |
| 74 | + }), |
| 75 | + ); |
| 76 | + } |
| 77 | + |
| 78 | + /** |
| 79 | + * Search coordinates with Nominatim and return the display name |
| 80 | + * @param coordinates |
| 81 | + * @returns {Observable<string>} the display name for the coordinates |
| 82 | + */ |
| 83 | + public searchCoordinates(coordinates: LocationCoordinates): Observable<string> { |
| 84 | + let params = new HttpParams() |
| 85 | + .append('lat', coordinates.latitude) |
| 86 | + .append('lon', coordinates.longitude) |
| 87 | + .append('format', NOMINATIM_RESPONSE_FORMAT); |
| 88 | + |
| 89 | + return this.http.get<Record<string,any>>(this.reverseSearchEndpoint, { params: params }).pipe( |
| 90 | + catchError((err) => { |
| 91 | + throw Error(LocationErrorCodes.API_ERROR); |
| 92 | + }), |
| 93 | + take(1), |
| 94 | + map((searchResults) => { |
| 95 | + if (hasValue(searchResults.error)) { |
| 96 | + throw Error(searchResults.error); |
| 97 | + } else { |
| 98 | + return searchResults.display_name; |
| 99 | + } |
| 100 | + }), |
| 101 | + ); |
| 102 | + } |
| 103 | + |
| 104 | + /** |
| 105 | + * Check if the provided pair of coordinates is valid |
| 106 | + * @param latitude the latitude as float number |
| 107 | + * @param longitude the longitude as float number |
| 108 | + * @returns {boolean} whether the coordinates are valid |
| 109 | + */ |
| 110 | + public isValidCoordinatePair(latitude: number, longitude: number): boolean { |
| 111 | + return !(isNaN(latitude) || isNaN(longitude) || latitude > 90 || latitude < -90 || longitude > 180 || longitude < -180); |
| 112 | + } |
| 113 | + |
| 114 | + /** |
| 115 | + * Check if a string is in the format `latitude,longitude` |
| 116 | + * @param coordinateString the string to be checked |
| 117 | + * @returns {boolean} whether the string has a valid format |
| 118 | + */ |
| 119 | + public isCoordinateString(coordinateString: string): boolean { |
| 120 | + return IS_COORDINATE_PAIR_REGEXP.test(coordinateString) && coordinateString.split(',').length === 2; |
| 121 | + } |
| 122 | + |
| 123 | + /** |
| 124 | + * Check if a string contains valid coordinateString in the format `latitude,longitude` |
| 125 | + * @param coordinateString the string to be checked |
| 126 | + * @returns {boolean} whether the string is valid and it contains valid coordinateString |
| 127 | + */ |
| 128 | + public isValidCoordinateString(coordinateString: string): boolean { |
| 129 | + if (this.isCoordinateString(coordinateString)) { |
| 130 | + const coordinateArray = coordinateString.split(','); |
| 131 | + const latitude = parseFloat(coordinateArray[0]); |
| 132 | + const longitude = parseFloat(coordinateArray[1]); |
| 133 | + return !isNaN(latitude) && !isNaN(longitude) && this.isValidCoordinatePair(latitude, longitude); |
| 134 | + } else { |
| 135 | + return false; |
| 136 | + } |
| 137 | + } |
| 138 | + |
| 139 | + /** |
| 140 | + * Parse a string containing location coordinates, and return an object containing latitude and longitude as numbers |
| 141 | + * @param coordinates a string in the format `latitude,longitude` |
| 142 | + * @returns {LocationCoordinates} the parsed coordinates |
| 143 | + */ |
| 144 | + public parseCoordinates(coordinates: string): LocationCoordinates { |
| 145 | + const coordinateArr = coordinates.split(','); |
| 146 | + if (this.isValidCoordinateString(coordinates)) { |
| 147 | + const latitude = parseFloat(coordinateArr[0]); |
| 148 | + const longitude = parseFloat(coordinateArr[1]); |
| 149 | + return { latitude, longitude }; |
| 150 | + } else { |
| 151 | + console.warn('Location service', `Invalid coordinates "${coordinates}"`); |
| 152 | + throw Error(LocationErrorCodes.INVALID_COORDINATES); |
| 153 | + } |
| 154 | + } |
| 155 | +} |
0 commit comments