wft-geodb-angular-client/fesm2015/wft-geodb-angular-client.mjs

Provides Angular client bindings to the GeoDB service.

import * as i1 from '@angular/common/http';
import { HttpParams, HttpClientModule, HTTP_INTERCEPTORS } from '@angular/common/http';
import * as i0 from '@angular/core';
import { Injectable, NgModule } from '@angular/core';

class CountrySummary {
}

class CountryDetails extends CountrySummary {
}

class Currency {
}

class GeoError {
}

class GeoLocation {
}

class GeoResponse {
    constructor() {
        this.errors = new Array();
    }
    static buildForData(data, metadata) {
        const response = new GeoResponse();
        response.data = data;
        response.metadata = metadata;
        return response;
    }
    static buildForError(error) {
        const response = new GeoResponse();
        response.errors.push(error);
        return response;
    }
    static buildForErrors(errors) {
        const response = new GeoResponse();
        for (const error of errors) {
            response.errors.push(error);
        }
        return response;
    }
}

class GeoDbConfig {
}

class Language {
}

class Locale {
}

class PlaceSummary {
    get displayName() {
        return this.region != null && this.region.trim().length > 0
            ? this.name + ', ' + this.region + ', ' + this.country
            : this.name + ', ' + this.country;
    }
}

class PlaceDetails extends PlaceSummary {
}

class RegionSummary {
}

class RegionDetails extends RegionSummary {
}

class TimeZone {
}

class GeoDbService {
    constructor(httpClient, config) {
        this.httpClient = httpClient;
        this.config = config;
        this.adminDivisionsEndpoint = config.serviceUri + '/v1/geo/adminDivisions';
        this.countriesEndpoint = config.serviceUri + '/v1/geo/countries';
        this.currenciesEndpoint = config.serviceUri + '/v1/locale/currencies';
        this.languagesEndpoint = config.serviceUri + '/v1/locale/languages';
        this.localesEndpoint = config.serviceUri + '/v1/locale/locales';
        this.placesEndpoint = config.serviceUri + '/v1/geo/places';
        this.timeZonesEndpoint = config.serviceUri + '/v1/locale/timezones';
    }
    static buildPagingParams(request) {
        return new HttpParams()
            .set('offset', '' + request.offset)
            .set('limit', '' + request.limit)
            .set('hateoasMode', 'false');
    }
    static toLocationString(nearLocation) {
        let locationString = '';
        if (nearLocation.latitude > 0) {
            locationString += '+';
        }
        locationString += nearLocation.latitude;
        if (nearLocation.longitude > 0) {
            locationString += '+';
        }
        locationString += nearLocation.longitude;
        return locationString;
    }
    findAdminDivisions(request) {
        let params = GeoDbService.buildPagingParams(request);
        if (request.countryIds) {
            params = params.set('countryIds', request.countryIds.join(','));
        }
        if (request.excludedCountryIds) {
            params = params.set('excludedCountryIds', request.excludedCountryIds.join(','));
        }
        if (request.namePrefix) {
            params = params.set('namePrefix', request.namePrefix);
        }
        if (request.namePrefixDefaultLangResults) {
            params = params.set('namePrefixDefaultLangResults', request.namePrefixDefaultLangResults);
        }
        if (request.minPopulation) {
            params = params.set('minPopulation', '' + request.minPopulation);
        }
        if (request.maxPopulation) {
            params = params.set('maxPopulation', '' + request.maxPopulation);
        }
        if (request.timeZoneIds) {
            params = params.set('timeZoneIds', request.timeZoneIds.join(','));
        }
        if (request.asciiMode) {
            params = params.set('asciiMode', '' + request.asciiMode);
        }
        if (request.languageCode) {
            params = params.set('languageCode', request.languageCode);
        }
        if (request.sortDirectives) {
            params = params.set('sort', request.sortDirectives.join(','));
        }
        if (request.includeDeleted) {
            params = params.set('includeDeleted', request.includeDeleted);
        }
        return this.httpClient.get(this.adminDivisionsEndpoint, {
            params: params
        });
    }
    findCountries(request) {
        let params = GeoDbService.buildPagingParams(request);
        if (request.currencyCode) {
            params = params.set('currencyCode', request.currencyCode);
        }
        if (request.namePrefix) {
            params = params.set('namePrefix', request.namePrefix);
        }
        if (request.namePrefixDefaultLangResults) {
            params = params.set('namePrefixDefaultLangResults', request.namePrefixDefaultLangResults);
        }
        if (request.asciiMode) {
            params = params.set('asciiMode', '' + request.asciiMode);
        }
        if (request.languageCode) {
            params = params.set('languageCode', request.languageCode);
        }
        return this.httpClient.get(this.countriesEndpoint, {
            params: params
        });
    }
    findCountryPlaces(request) {
        const endpoint = this.buildCountryEndpoint(request.countryId) + '/places';
        let params = GeoDbService.buildPagingParams(request);
        if (request.namePrefix) {
            params = params.set('namePrefix', request.namePrefix);
        }
        if (request.namePrefixDefaultLangResults) {
            params = params.set('namePrefixDefaultLangResults', request.namePrefixDefaultLangResults);
        }
        if (request.minPopulation) {
            params = params.set('minPopulation', '' + request.minPopulation);
        }
        if (request.maxPopulation) {
            params = params.set('maxPopulation', '' + request.maxPopulation);
        }
        if (request.types) {
            params = params.set('types', request.types.join(','));
        }
        if (request.asciiMode) {
            params = params.set('asciiMode', '' + request.asciiMode);
        }
        if (request.languageCode) {
            params = params.set('languageCode', request.languageCode);
        }
        if (request.sortDirectives) {
            params = params.set('sort', request.sortDirectives.join(','));
        }
        return this.httpClient.get(endpoint, {
            params: params
        });
    }
    findCountry(request) {
        const endpoint = this.countriesEndpoint + '/' + request.countryId;
        let params = new HttpParams();
        if (request.asciiMode) {
            params = params.set('asciiMode', '' + request.asciiMode);
        }
        if (request.languageCode) {
            params = params.set('languageCode', request.languageCode);
        }
        return this.httpClient.get(endpoint, {
            params: params
        });
    }
    findCurrencies(request) {
        let params = GeoDbService.buildPagingParams(request);
        if (request.countryId) {
            params = params.set('countryId', request.countryId);
        }
        return this.httpClient.get(this.currenciesEndpoint, {
            params: params
        });
    }
    findLanguages(request) {
        const params = GeoDbService.buildPagingParams(request);
        return this.httpClient.get(this.languagesEndpoint, {
            params: params
        });
    }
    findLocales(request) {
        const params = GeoDbService.buildPagingParams(request);
        return this.httpClient.get(this.localesEndpoint, {
            params: params
        });
    }
    findPlaces(request) {
        let params = GeoDbService.buildPagingParams(request);
        if (request.countryIds) {
            params = params.set('countryIds', request.countryIds.join(','));
        }
        if (request.excludedCountryIds) {
            params = params.set('excludedCountryIds', request.excludedCountryIds.join(','));
        }
        if (request.namePrefix) {
            params = params.set('namePrefix', request.namePrefix);
        }
        if (request.namePrefixDefaultLangResults) {
            params = params.set('namePrefixDefaultLangResults', request.namePrefixDefaultLangResults);
        }
        if (request.minPopulation) {
            params = params.set('minPopulation', '' + request.minPopulation);
        }
        if (request.maxPopulation) {
            params = params.set('maxPopulation', '' + request.maxPopulation);
        }
        if (request.timeZoneIds) {
            params = params.set('timeZoneIds', request.timeZoneIds.join(','));
        }
        if (request.types) {
            params = params.set('types', request.types.join(','));
        }
        if (request.asciiMode) {
            params = params.set('asciiMode', '' + request.asciiMode);
        }
        if (request.languageCode) {
            params = params.set('languageCode', request.languageCode);
        }
        if (request.sortDirectives) {
            params = params.set('sort', request.sortDirectives.join(','));
        }
        if (request.includeDeleted) {
            params = params.set('includeDeleted', request.includeDeleted);
        }
        return this.httpClient.get(this.placesEndpoint, {
            params: params
        });
    }
    findPlacesNearLocation(request) {
        let params = GeoDbService.buildPagingParams(request);
        params = params
            .set('radius', '' + request.location.radius)
            .set('distanceUnit', request.location.distanceUnit);
        if (request.namePrefix) {
            params = params.set('namePrefix', request.namePrefix);
        }
        if (request.namePrefixDefaultLangResults) {
            params = params.set('namePrefixDefaultLangResults', request.namePrefixDefaultLangResults);
        }
        if (request.minPopulation) {
            params = params.set('minPopulation', '' + request.minPopulation);
        }
        if (request.maxPopulation) {
            params = params.set('maxPopulation', '' + request.maxPopulation);
        }
        if (request.types) {
            params = params.set('types', request.types.join(','));
        }
        if (request.asciiMode) {
            params = params.set('asciiMode', '' + request.asciiMode);
        }
        if (request.languageCode) {
            params = params.set('languageCode', request.languageCode);
        }
        if (request.sortDirectives) {
            params = params.set('sort', request.sortDirectives.join(','));
        }
        if (request.includeDeleted) {
            params = params.set('includeDeleted', request.includeDeleted);
        }
        // Workaround for HttpClient '+' encoding bug.
        const locationId = GeoDbService
            .toLocationString(request.location)
            .replace(/\+/g, '%2B');
        const endpoint = this.placesEndpoint + '?location=' + locationId;
        return this.httpClient.get(endpoint, {
            params: params
        });
    }
    findPlacesNearPlace(request) {
        let params = GeoDbService.buildPagingParams(request);
        params = params
            .set('radius', '' + request.radius)
            .set('distanceUnit', request.distanceUnit);
        if (request.namePrefix) {
            params = params.set('namePrefix', request.namePrefix);
        }
        if (request.namePrefixDefaultLangResults) {
            params = params.set('namePrefixDefaultLangResults', request.namePrefixDefaultLangResults);
        }
        if (request.minPopulation) {
            params = params.set('minPopulation', '' + request.minPopulation);
        }
        if (request.maxPopulation) {
            params = params.set('maxPopulation', '' + request.maxPopulation);
        }
        if (request.types) {
            params = params.set('types', request.types.join(','));
        }
        if (request.asciiMode) {
            params = params.set('asciiMode', '' + request.asciiMode);
        }
        if (request.languageCode) {
            params = params.set('languageCode', request.languageCode);
        }
        if (request.sortDirectives) {
            params = params.set('sort', request.sortDirectives.join(','));
        }
        if (request.includeDeleted) {
            params = params.set('includeDeleted', request.includeDeleted);
        }
        const endpoint = this.placesEndpoint + '/' + request.placeId + '/nearbyPlaces';
        return this.httpClient.get(endpoint, {
            params: params
        });
    }
    findRegion(request) {
        const endpoint = this.buildRegionsEndpoint(request.countryId) + '/' + request.regionCode;
        let params = new HttpParams();
        if (request.asciiMode) {
            params = params.set('asciiMode', '' + request.asciiMode);
        }
        if (request.languageCode) {
            params = params.set('languageCode', request.languageCode);
        }
        return this.httpClient.get(endpoint, {
            params: params
        });
    }
    findRegionPlaces(request) {
        const endpoint = this.buildRegionEndpoint(request.countryId, request.regionId) + '/places';
        let params = GeoDbService.buildPagingParams(request);
        if (request.namePrefix) {
            params = params.set('namePrefix', request.namePrefix);
        }
        if (request.namePrefixDefaultLangResults) {
            params = params.set('namePrefixDefaultLangResults', request.namePrefixDefaultLangResults);
        }
        if (request.minPopulation) {
            params = params.set('minPopulation', '' + request.minPopulation);
        }
        if (request.maxPopulation) {
            params = params.set('maxPopulation', '' + request.maxPopulation);
        }
        if (request.types) {
            params = params.set('types', request.types.join(','));
        }
        if (request.asciiMode) {
            params = params.set('asciiMode', '' + request.asciiMode);
        }
        if (request.languageCode) {
            params = params.set('languageCode', request.languageCode);
        }
        if (request.sortDirectives) {
            params = params.set('sort', request.sortDirectives.join(','));
        }
        return this.httpClient.get(endpoint, {
            params: params
        });
    }
    findRegions(request) {
        const endpoint = this.buildRegionsEndpoint(request.countryId);
        let params = GeoDbService.buildPagingParams(request);
        if (request.namePrefix) {
            params = params.set('namePrefix', request.namePrefix);
        }
        if (request.namePrefixDefaultLangResults) {
            params = params.set('namePrefixDefaultLangResults', request.namePrefixDefaultLangResults);
        }
        if (request.asciiMode) {
            params = params.set('asciiMode', '' + request.asciiMode);
        }
        if (request.languageCode) {
            params = params.set('languageCode', request.languageCode);
        }
        return this.httpClient.get(endpoint, {
            params: params
        });
    }
    findTimeZones(request) {
        const params = GeoDbService.buildPagingParams(request);
        return this.httpClient.get(this.timeZonesEndpoint, {
            params: params
        });
    }
    get apiKey() {
        return this.config.apiKey;
    }
    setApiKey(apiKey) {
        this.config.apiKey = apiKey;
    }
    getPlace(request) {
        const endpoint = this.buildPlaceEndpoint(request.placeId);
        let params = new HttpParams();
        if (request.asciiMode) {
            params = params.set('asciiMode', '' + request.asciiMode);
        }
        if (request.languageCode) {
            params = params.set('languageCode', request.languageCode);
        }
        return this.httpClient.get(endpoint, {
            params: params
        });
    }
    getPlaceAdminRegion(request) {
        const endpoint = this.buildPlaceEndpoint(request.placeId) + '/locatedIn';
        let params = new HttpParams();
        if (request.asciiMode) {
            params = params.set('asciiMode', '' + request.asciiMode);
        }
        if (request.languageCode) {
            params = params.set('languageCode', request.languageCode);
        }
        return this.httpClient.get(endpoint, {
            params: params
        });
    }
    getPlaceDateTime(id) {
        const endpoint = this.buildPlaceEndpoint(id) + '/dateTime';
        return this.httpClient.get(endpoint);
    }
    getPlaceDistance(request) {
        const endpoint = this.buildPlaceEndpoint(request.fromPlaceId) + '/distance';
        const params = new HttpParams()
            .set('toPlaceId', '' + request.toPlaceId)
            .set('distanceUnit', '' + request.distanceUnit);
        return this.httpClient.get(endpoint, {
            params: params
        });
    }
    getPlaceTime(placeId) {
        const endpoint = this.buildPlaceEndpoint(placeId) + '/time';
        return this.httpClient.get(endpoint);
    }
    getTimeZoneDateTime(zoneId) {
        const endpoint = this.buildTimeZoneEndpoint(zoneId) + '/dateTime';
        return this.httpClient.get(endpoint);
    }
    getTimeZoneTime(zoneId) {
        const endpoint = this.buildTimeZoneEndpoint(zoneId) + '/time';
        return this.httpClient.get(endpoint);
    }
    buildCountryEndpoint(countryId) {
        return this.countriesEndpoint + '/' + countryId;
    }
    buildPlaceEndpoint(olaceId) {
        return this.placesEndpoint + '/' + olaceId;
    }
    buildRegionEndpoint(countryId, regionId) {
        return this.buildRegionsEndpoint(countryId) + '/' + regionId;
    }
    buildRegionsEndpoint(countryId) {
        return this.buildCountryEndpoint(countryId) + '/regions';
    }
    buildTimeZoneEndpoint(zoneId) {
        return this.timeZonesEndpoint + '/' + zoneId;
    }
}
GeoDbService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.5", ngImport: i0, type: GeoDbService, deps: [{ token: i1.HttpClient }, { token: GeoDbConfig }], target: i0.ɵɵFactoryTarget.Injectable });
GeoDbService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.5", ngImport: i0, type: GeoDbService });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.5", ngImport: i0, type: GeoDbService, decorators: [{
            type: Injectable
        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: GeoDbConfig }]; } });

class GeoDbFreeModule {
    static forRoot(config) {
        return {
            ngModule: GeoDbFreeModule,
            providers: [
                {
                    provide: GeoDbConfig,
                    useValue: config
                }
            ]
        };
    }
    constructor(config) {
    }
}
GeoDbFreeModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.5", ngImport: i0, type: GeoDbFreeModule, deps: [{ token: GeoDbConfig }], target: i0.ɵɵFactoryTarget.NgModule });
GeoDbFreeModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.5", ngImport: i0, type: GeoDbFreeModule, imports: [HttpClientModule] });
GeoDbFreeModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.5", ngImport: i0, type: GeoDbFreeModule, providers: [
        GeoDbService
    ], imports: [HttpClientModule] });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.5", ngImport: i0, type: GeoDbFreeModule, decorators: [{
            type: NgModule,
            args: [{
                    providers: [
                        GeoDbService
                    ],
                    imports: [
                        HttpClientModule
                    ]
                }]
        }], ctorParameters: function () { return [{ type: GeoDbConfig }]; } });

class AuthInterceptor {
    constructor(config) {
        this.config = config;
    }
    intercept(request, next) {
        if (request.url.startsWith(this.config.serviceUri)) {
            const headers = request
                .headers
                .set('X-Mashape-Key', this.config.apiKey);
            return next.handle(request.clone({ headers: headers }));
        }
        return next.handle(request);
    }
}
AuthInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.5", ngImport: i0, type: AuthInterceptor, deps: [{ token: GeoDbConfig }], target: i0.ɵɵFactoryTarget.Injectable });
AuthInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.5", ngImport: i0, type: AuthInterceptor });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.5", ngImport: i0, type: AuthInterceptor, decorators: [{
            type: Injectable
        }], ctorParameters: function () { return [{ type: GeoDbConfig }]; } });

class GeoDbProModule {
    static forRoot(config) {
        return {
            ngModule: GeoDbProModule,
            providers: [
                {
                    provide: GeoDbConfig,
                    useValue: config
                }
            ]
        };
    }
    constructor(config) {
    }
}
GeoDbProModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.5", ngImport: i0, type: GeoDbProModule, deps: [{ token: GeoDbConfig }], target: i0.ɵɵFactoryTarget.NgModule });
GeoDbProModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.2.5", ngImport: i0, type: GeoDbProModule, imports: [HttpClientModule] });
GeoDbProModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.2.5", ngImport: i0, type: GeoDbProModule, providers: [
        GeoDbService,
        {
            provide: HTTP_INTERCEPTORS,
            useClass: AuthInterceptor,
            multi: true
        }
    ], imports: [HttpClientModule] });
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.5", ngImport: i0, type: GeoDbProModule, decorators: [{
            type: NgModule,
            args: [{
                    providers: [
                        GeoDbService,
                        {
                            provide: HTTP_INTERCEPTORS,
                            useClass: AuthInterceptor,
                            multi: true
                        }
                    ],
                    imports: [
                        HttpClientModule
                    ]
                }]
        }], ctorParameters: function () { return [{ type: GeoDbConfig }]; } });

/*
 * Public API Surface of wft-geodb-angular-client
 */

/**
 * Generated bundle index. Do not edit.
 */

export { CountryDetails, CountrySummary, Currency, GeoDbConfig, GeoDbFreeModule, GeoDbProModule, GeoDbService, GeoError, GeoLocation, GeoResponse, Language, Locale, PlaceDetails, PlaceSummary, RegionDetails, RegionSummary, TimeZone };
//# sourceMappingURL=wft-geodb-angular-client.mjs.map