File

libs/core/src/lib/dataset-api/dataset-impl-api-interface.service.ts

Extends

DatasetApiInterface

Index

Methods

Constructor

constructor(httpservice: HttpService, internalDatasetId: InternalIdHandler, translate: TranslateService)
Parameters :
Name Type Optional
httpservice HttpService No
internalDatasetId InternalIdHandler No
translate TranslateService No

Methods

Public getCategories
getCategories(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Parameters :
Name Type Optional
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public getCategory
getCategory(id: string, apiUrl: string, params?: ParameterFilter)
Parameters :
Name Type Optional
id string No
apiUrl string No
params ParameterFilter Yes
Public getData
getData(id: string, apiUrl: string, timespan: Timespan, params: DataParameterFilter, options: HttpRequestOptions)
Type parameters :
  • T
Parameters :
Name Type Optional Default value
id string No
apiUrl string No
timespan Timespan No
params DataParameterFilter No {}
options HttpRequestOptions No
Public getDataset
getDataset(id: string, apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Parameters :
Name Type Optional
id string No
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public getDatasetByInternalId
getDatasetByInternalId(internalId: string, params?: ParameterFilter, options?: HttpRequestOptions)
Parameters :
Name Type Optional
internalId string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public getDatasets
getDatasets(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Parameters :
Name Type Optional
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public getFeature
getFeature(id: string, apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Parameters :
Name Type Optional
id string No
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public getFeatures
getFeatures(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Parameters :
Name Type Optional
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public getOffering
getOffering(id: string, apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Parameters :
Name Type Optional
id string No
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public getOfferings
getOfferings(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Parameters :
Name Type Optional
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public getPhenomena
getPhenomena(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Parameters :
Name Type Optional
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public getPhenomenon
getPhenomenon(id: string, apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Parameters :
Name Type Optional
id string No
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public getPlatform
getPlatform(id: string, apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Parameters :
Name Type Optional
id string No
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public getPlatforms
getPlatforms(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Parameters :
Name Type Optional
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public getProcedure
getProcedure(id: string, apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Parameters :
Name Type Optional
id string No
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public getProcedures
getProcedures(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Parameters :
Name Type Optional
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public getService
getService(id: string, apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Parameters :
Name Type Optional
id string No
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public getServices
getServices(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Parameters :
Name Type Optional
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public getSingleTimeseries
getSingleTimeseries(id: string, apiUrl: string, params?: ParameterFilter)
Parameters :
Name Type Optional
id string No
apiUrl string No
params ParameterFilter Yes
Public getSingleTimeseriesByInternalId
getSingleTimeseriesByInternalId(internalId: string, params?: ParameterFilter)
Parameters :
Name Type Optional
internalId string No
params ParameterFilter Yes
Public getStation
getStation(id: string, apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Parameters :
Name Type Optional
id string No
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public getStations
getStations(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Parameters :
Name Type Optional
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public getTimeseries
getTimeseries(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Parameters :
Name Type Optional
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public getTimeseriesData
getTimeseriesData(apiUrl: string, ids: string[], timespan: Timespan, options?: HttpRequestOptions)
Parameters :
Name Type Optional
apiUrl string No
ids string[] No
timespan Timespan No
options HttpRequestOptions Yes
Public getTimeseriesExtras
getTimeseriesExtras(id: string, apiUrl: string)
Parameters :
Name Type Optional
id string No
apiUrl string No
Public getTsData
getTsData(id: string, apiUrl: string, timespan: Timespan, params: DataParameterFilter, options: HttpRequestOptions)
Type parameters :
  • T
Parameters :
Name Type Optional Default value
id string No
apiUrl string No
timespan Timespan No
params DataParameterFilter No {}
options HttpRequestOptions No
Private prepareDataset
prepareDataset(datasetObj: Dataset, apiUrl: string)
Parameters :
Name Type Optional
datasetObj Dataset No
apiUrl string No
Returns : any
Private requestApiTexted
requestApiTexted(url: string, params: ParameterFilter, options: HttpRequestOptions)
Parameters :
Name Type Optional Default value
url string No
params ParameterFilter No {}
options HttpRequestOptions No {}
Returns : Observable<string>
Private requestApiTextedPost
requestApiTextedPost(url: string, params: ParameterFilter, options: HttpRequestOptions)
Parameters :
Name Type Optional Default value
url string No
params ParameterFilter No {}
options HttpRequestOptions No {}
Returns : Observable<Object>
Public Abstract getCategories
getCategories(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Inherited from DatasetApiInterface
Parameters :
Name Type Optional
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public Abstract getCategory
getCategory(id: string, apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Inherited from DatasetApiInterface
Parameters :
Name Type Optional
id string No
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public Abstract getData
getData(id: string, apiUrl: string, timespan: Timespan, params?: DataParameterFilter, options?: HttpRequestOptions)
Inherited from DatasetApiInterface
Type parameters :
  • T
Parameters :
Name Type Optional
id string No
apiUrl string No
timespan Timespan No
params DataParameterFilter Yes
options HttpRequestOptions Yes
Public Abstract getDataset
getDataset(id: string, apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Inherited from DatasetApiInterface
Parameters :
Name Type Optional
id string No
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public Abstract getDatasetByInternalId
getDatasetByInternalId(internalId: string, params?: ParameterFilter, options?: HttpRequestOptions)
Inherited from DatasetApiInterface
Parameters :
Name Type Optional
internalId string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public Abstract getDatasets
getDatasets(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Inherited from DatasetApiInterface
Parameters :
Name Type Optional
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public Abstract getFeature
getFeature(id: string, apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Inherited from DatasetApiInterface
Parameters :
Name Type Optional
id string No
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public Abstract getFeatures
getFeatures(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Inherited from DatasetApiInterface
Parameters :
Name Type Optional
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public Abstract getOffering
getOffering(id: string, apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Inherited from DatasetApiInterface
Parameters :
Name Type Optional
id string No
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public Abstract getOfferings
getOfferings(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Inherited from DatasetApiInterface
Parameters :
Name Type Optional
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public Abstract getPhenomena
getPhenomena(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Inherited from DatasetApiInterface
Parameters :
Name Type Optional
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public Abstract getPhenomenon
getPhenomenon(id: string, apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Inherited from DatasetApiInterface
Parameters :
Name Type Optional
id string No
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public Abstract getPlatform
getPlatform(id: string, apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Inherited from DatasetApiInterface
Parameters :
Name Type Optional
id string No
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public Abstract getPlatforms
getPlatforms(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Inherited from DatasetApiInterface
Parameters :
Name Type Optional
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public Abstract getProcedure
getProcedure(id: string, apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Inherited from DatasetApiInterface
Parameters :
Name Type Optional
id string No
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public Abstract getProcedures
getProcedures(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Inherited from DatasetApiInterface
Parameters :
Name Type Optional
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public Abstract getService
getService(id: string, apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Inherited from DatasetApiInterface
Parameters :
Name Type Optional
id string No
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public Abstract getServices
getServices(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Inherited from DatasetApiInterface
Parameters :
Name Type Optional
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public Abstract getSingleTimeseries
getSingleTimeseries(id: string, apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Inherited from DatasetApiInterface
Parameters :
Name Type Optional
id string No
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public Abstract getSingleTimeseriesByInternalId
getSingleTimeseriesByInternalId(internalId: string, params?: ParameterFilter, options?: HttpRequestOptions)
Inherited from DatasetApiInterface
Parameters :
Name Type Optional
internalId string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public Abstract getStation
getStation(id: string, apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Inherited from DatasetApiInterface
Parameters :
Name Type Optional
id string No
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public Abstract getStations
getStations(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Inherited from DatasetApiInterface
Parameters :
Name Type Optional
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public Abstract getTimeseries
getTimeseries(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions)
Inherited from DatasetApiInterface
Parameters :
Name Type Optional
apiUrl string No
params ParameterFilter Yes
options HttpRequestOptions Yes
Public Abstract getTimeseriesData
getTimeseriesData(apiUrl: string, ids: string[], timespan: Timespan, options?: HttpRequestOptions)
Inherited from DatasetApiInterface
Parameters :
Name Type Optional
apiUrl string No
ids string[] No
timespan Timespan No
options HttpRequestOptions Yes
Public Abstract getTimeseriesExtras
getTimeseriesExtras(id: string, apiUrl: string)
Inherited from DatasetApiInterface
Parameters :
Name Type Optional
id string No
apiUrl string No
Public Abstract getTsData
getTsData(id: string, apiUrl: string, timespan: Timespan, params?: DataParameterFilter, options?: HttpRequestOptions)
Inherited from DatasetApiInterface
Type parameters :
  • T
Parameters :
Name Type Optional
id string No
apiUrl string No
timespan Timespan No
params DataParameterFilter Yes
options HttpRequestOptions Yes
Protected prepareParams
prepareParams(params: ParameterFilter)
Inherited from DatasetApiInterface
Parameters :
Name Type Optional
params ParameterFilter No
Returns : HttpParams
Protected requestApi
requestApi(url: string, params: ParameterFilter, options: HttpRequestOptions)
Inherited from DatasetApiInterface
Type parameters :
  • T
Parameters :
Name Type Optional Default value
url string No
params ParameterFilter No {}
options HttpRequestOptions No {}
Returns : Observable<T>
Protected createBasicAuthHeader
createBasicAuthHeader(token: string)
Inherited from DatasetApiInterface
Parameters :
Name Type Optional
token string No
Returns : HttpHeaders
Protected createRequestTimespan
createRequestTimespan(timespan: Timespan)
Inherited from DatasetApiInterface
Parameters :
Name Type Optional
timespan Timespan No
Returns : string
Protected createRequestUrl
createRequestUrl(apiUrl: string, endpoint: string, id?: string)
Inherited from DatasetApiInterface
Parameters :
Name Type Optional
apiUrl string No
endpoint string No
id string Yes
Returns : string
Protected createBasicAuthHeader
createBasicAuthHeader(token: string)
Inherited from ApiInterface
Defined in ApiInterface:19
Parameters :
Name Type Optional
token string No
Returns : HttpHeaders
Protected createRequestTimespan
createRequestTimespan(timespan: Timespan)
Inherited from ApiInterface
Defined in ApiInterface:15
Parameters :
Name Type Optional
timespan Timespan No
Returns : string
Protected createRequestUrl
createRequestUrl(apiUrl: string, endpoint: string, id?: string)
Inherited from ApiInterface
Defined in ApiInterface:8
Parameters :
Name Type Optional
apiUrl string No
endpoint string No
id string Yes
Returns : string
import { Injectable } from '@angular/core';
import { TranslateService } from '@ngx-translate/core';
import { deserialize, deserializeArray } from 'class-transformer';
import { Observable, Observer } from 'rxjs';
import { map } from 'rxjs/operators';

import { Category } from '../model/dataset-api/category';
import { Data } from '../model/dataset-api/data';
import { Dataset, Timeseries, TimeseriesData, TimeseriesExtras } from '../model/dataset-api/dataset';
import { Feature } from '../model/dataset-api/feature';
import { Offering } from '../model/dataset-api/offering';
import { Phenomenon } from '../model/dataset-api/phenomenon';
import { Platform } from '../model/dataset-api/platform';
import { Procedure } from '../model/dataset-api/procedure';
import { Service } from '../model/dataset-api/service';
import { Station } from '../model/dataset-api/station';
import { DataParameterFilter, HttpRequestOptions, ParameterFilter } from '../model/internal/http-requests';
import { Timespan } from '../model/internal/timeInterval';
import { DatasetApiInterface } from './api-interface';
import { HttpService } from './http.service';
import { InternalIdHandler } from './internal-id-handler.service';

@Injectable()
export class DatasetImplApiInterface extends DatasetApiInterface {

    constructor(
        protected httpservice: HttpService,
        protected internalDatasetId: InternalIdHandler,
        protected translate: TranslateService
    ) {
        super(httpservice, translate);
    }

    public getServices(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions): Observable<Service[]> {
        const url = this.createRequestUrl(apiUrl, 'services');
        if (params) {
            params.expanded = true;
        } else {
            params = { expanded: true };
        }
        return this.requestApi<Service[]>(url, params, options).pipe(
            map((result) => {
                result.forEach((entry) => entry.apiUrl = apiUrl);
                return result;
            }));
    }

    public getService(
        id: string,
        apiUrl: string,
        params?: ParameterFilter,
        options?: HttpRequestOptions
    ): Observable<Service> {
        const url = this.createRequestUrl(apiUrl, 'services', id);
        return this.requestApi<Service>(url, params, options).pipe(
            map((result) => {
                result.apiUrl = apiUrl;
                return result;
            }));
    }

    public getStations(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions): Observable<Station[]> {
        const url = this.createRequestUrl(apiUrl, 'stations');
        return this.requestApi<Station[]>(url, params, options);
    }

    public getStation(
        id: string,
        apiUrl: string,
        params?: ParameterFilter,
        options?: HttpRequestOptions
    ): Observable<Station> {
        const url = this.createRequestUrl(apiUrl, 'stations', id);
        return this.requestApi<Station>(url, params, options);
    }

    public getTimeseries(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions): Observable<Timeseries[]> {
        const url = this.createRequestUrl(apiUrl, 'timeseries');
        return new Observable<Timeseries[]>((observer: Observer<Timeseries[]>) => {
            this.requestApiTexted(url, params, options).subscribe(
                (result) => {
                    const timeseriesList = deserializeArray<Timeseries>(Timeseries, result);
                    timeseriesList.forEach((entry) => {
                        entry.url = apiUrl;
                        this.internalDatasetId.generateInternalId(entry);
                        if (!entry.station.id) {
                            entry.station.id = entry.station.properties.id;
                        }
                    });
                    observer.next(timeseriesList);
                },
                (error) => observer.error(error),
                () => observer.complete()
            );
        });
    }

    public getTimeseriesData(apiUrl: string, ids: string[], timespan: Timespan, options?: HttpRequestOptions): Observable<TimeseriesData[]> {
        const url = this.createRequestUrl(apiUrl, 'timeseries/getData');
        return new Observable<TimeseriesData[]>((observer: Observer<Object>) => {
            this.requestApiTextedPost(url, {
                timespan: this.createRequestTimespan(timespan),
                timeseries: ids
            }, options).subscribe(
                (result) => {
                    const timeseriesList: TimeseriesData[] = [];
                    for (const id in result) {
                        if (id) {
                            timeseriesList.push(
                                {
                                    id: id,
                                    url: apiUrl,
                                    data: result[id].values
                                }
                            );
                        }
                    }
                    observer.next(timeseriesList);
                },
                (error) => observer.error(error),
                () => observer.complete()
            );
        });
    }

    public getSingleTimeseries(id: string, apiUrl: string, params?: ParameterFilter): Observable<Timeseries> {
        const url = this.createRequestUrl(apiUrl, 'timeseries', id);
        return this.requestApiTexted(url, params).pipe(map((result) => {
            const timeseries = deserialize<Timeseries>(Timeseries, result);
            timeseries.url = apiUrl;
            this.internalDatasetId.generateInternalId(timeseries);
            return timeseries;
        }));
    }

    public getSingleTimeseriesByInternalId(internalId: string, params?: ParameterFilter): Observable<Timeseries> {
        const resolvedId = this.internalDatasetId.resolveInternalId(internalId);
        return this.getSingleTimeseries(resolvedId.id, resolvedId.url, params);
    }

    public getTimeseriesExtras(id: string, apiUrl: string): Observable<TimeseriesExtras> {
        const url = this.createRequestUrl(apiUrl, 'timeseries', id);
        return this.requestApi<TimeseriesExtras>(url + '/extras');
    }

    public getTsData<T>(
        id: string,
        apiUrl: string,
        timespan: Timespan,
        params: DataParameterFilter = {},
        options: HttpRequestOptions
    ): Observable<Data<T>> {
        const url = this.createRequestUrl(apiUrl, 'timeseries', id) + '/getData';
        params.timespan = this.createRequestTimespan(timespan);
        return this.requestApi<Data<T>>(url, params, options).pipe(
            map((res: any) => {
                if (params.expanded) { res = res[id]; }
                return res;
            }));
    }

    public getCategories(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions): Observable<Category[]> {
        const url = this.createRequestUrl(apiUrl, 'categories');
        return this.requestApi<Category[]>(url, params, options);
    }

    public getCategory(id: string, apiUrl: string, params?: ParameterFilter): Observable<Category> {
        const url = this.createRequestUrl(apiUrl, 'categories', id);
        return this.requestApi(url, params);
    }

    public getPhenomena(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions): Observable<Phenomenon[]> {
        const url = this.createRequestUrl(apiUrl, 'phenomena');
        return this.requestApi<Phenomenon[]>(url, params, options);
    }

    public getPhenomenon(
        id: string,
        apiUrl: string,
        params?: ParameterFilter,
        options?: HttpRequestOptions
    ): Observable<Phenomenon> {
        const url = this.createRequestUrl(apiUrl, 'phenomena', id);
        return this.requestApi<Phenomenon>(url, params, options);
    }

    public getOfferings(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions): Observable<Offering[]> {
        const url = this.createRequestUrl(apiUrl, 'offerings');
        return this.requestApi<Offering[]>(url, params, options);
    }

    public getOffering(
        id: string,
        apiUrl: string,
        params?: ParameterFilter,
        options?: HttpRequestOptions
    ): Observable<Offering> {
        const url = this.createRequestUrl(apiUrl, 'offerings', id);
        return this.requestApi<Offering>(url, params, options);
    }

    public getFeatures(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions): Observable<Feature[]> {
        const url = this.createRequestUrl(apiUrl, 'features');
        return this.requestApi<Feature[]>(url, params, options);
    }

    public getFeature(
        id: string,
        apiUrl: string,
        params?: ParameterFilter,
        options?: HttpRequestOptions
    ): Observable<Feature> {
        const url = this.createRequestUrl(apiUrl, 'features', id);
        return this.requestApi<Feature>(url, params, options);
    }

    public getProcedures(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions): Observable<Procedure[]> {
        const url = this.createRequestUrl(apiUrl, 'procedures');
        return this.requestApi<Procedure[]>(url, params, options);
    }

    public getProcedure(
        id: string,
        apiUrl: string,
        params?: ParameterFilter,
        options?: HttpRequestOptions
    ): Observable<Procedure> {
        const url = this.createRequestUrl(apiUrl, 'procedures', id);
        return this.requestApi<Procedure>(url, params, options);
    }

    public getPlatforms(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions): Observable<Platform[]> {
        const url = this.createRequestUrl(apiUrl, 'platforms');
        return this.requestApi<Platform[]>(url, params, options);
    }

    public getPlatform(
        id: string,
        apiUrl: string,
        params?: ParameterFilter,
        options?: HttpRequestOptions
    ): Observable<Platform> {
        const url = this.createRequestUrl(apiUrl, 'platforms', id);
        return this.requestApi<Platform>(url, params, options);
    }

    public getDatasets(apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions): Observable<Dataset[]> {
        const url = this.createRequestUrl(apiUrl, 'datasets');
        return this.requestApi<Dataset[]>(url, params, options).pipe(
            map((list) => list.map((entry) => this.prepareDataset(entry, apiUrl)))
        );
    }

    public getDataset(id: string, apiUrl: string, params?: ParameterFilter, options?: HttpRequestOptions): Observable<Dataset> {
        const url = this.createRequestUrl(apiUrl, 'datasets', id);
        return this.requestApi<Dataset>(url, params, options).pipe(
            map((res) => this.prepareDataset(res, apiUrl))
        );
    }

    public getDatasetByInternalId(internalId: string, params?: ParameterFilter, options?: HttpRequestOptions): Observable<Dataset> {
        const resolvedId = this.internalDatasetId.resolveInternalId(internalId);
        return this.getDataset(resolvedId.id, resolvedId.url, params, options);
    }

    public getData<T>(
        id: string,
        apiUrl: string,
        timespan: Timespan,
        params: DataParameterFilter = {},
        options: HttpRequestOptions
    ): Observable<Data<T>> {
        const url = this.createRequestUrl(apiUrl, 'datasets', id) + '/data';
        params.timespan = this.createRequestTimespan(timespan);
        return this.requestApi<Data<T>>(url, params, options);
    }

    // public getGeometries(id: string, apiUrl: string, params?): Observable<> {
    //     throw new Error('Not implemented');
    // }

    // protected createRequestTimespan(timespan: Timespan): string {
    //     return encodeURI(moment(timespan.from).format() + '/' + moment(timespan.to).format());
    // }

    private requestApiTexted(url: string, params: ParameterFilter = {}, options: HttpRequestOptions = {}): Observable<string> {
        return this.httpservice.client(options).get(url, {
            params: this.prepareParams(params),
            responseType: 'text'
        });
    }

    private requestApiTextedPost(url: string, params: ParameterFilter = {}, options: HttpRequestOptions = {}): Observable<Object> {
        return this.httpservice.client().post(url, params, {
            responseType: 'json'
        });
    }

    private prepareDataset(datasetObj: Dataset, apiUrl: string) {
        const dataset = deserialize<Dataset>(Dataset, JSON.stringify(datasetObj));
        dataset.url = apiUrl;
        this.internalDatasetId.generateInternalId(dataset);
        if (dataset.seriesParameters) {
            dataset.parameters = dataset.seriesParameters;
            delete dataset.seriesParameters;
        }
        return dataset;
    }
}

result-matching ""

    No results matching ""