ng-kinintel 0.0.317

package/src/lib/services/alert.service.ts

@@ -0,0 +1,49 @@
+import {Injectable} from '@angular/core';
+import {KinintelModuleConfig} from '../ng-kinintel.module';
+import {HttpClient} from '@angular/common/http';
+import {ProjectService} from './project.service';
+
+@Injectable({
+    providedIn: 'root'
+})
+export class AlertService {
+
+    constructor(private config: KinintelModuleConfig,
+                private http: HttpClient,
+                private projectService: ProjectService) {
+    }
+
+    public getAlertGroup(id) {
+        return this.http.get(`${this.config.backendURL}/alert/group/${id}`)
+            .toPromise();
+    }
+
+    public getAlertGroups(filterString = '', limit = '10', offset = '0', accountId = '') {
+        const projectKey = this.projectService.activeProject.getValue() ? this.projectService.activeProject.getValue().projectKey : '';
+
+        return this.http.get(this.config.backendURL + '/alert/group', {
+            params: {
+                filterString, limit, offset, projectKey, accountId
+            }
+        });
+    }
+
+    public saveAlertGroup(alertGroup) {
+        const projectKey = this.projectService.activeProject.getValue() ? this.projectService.activeProject.getValue().projectKey : '';
+        return this.http.post(`${this.config.backendURL}/alert/group?projectKey=${projectKey}`, alertGroup)
+            .toPromise();
+    }
+
+    public deleteAlertGroup(id) {
+        return this.http.delete(`${this.config.backendURL}/alert/group/${id}`)
+            .toPromise();
+    }
+
+    public processAlertsForDashboardDatasetInstance(dashboardDataSetInstance, index = null) {
+        let url = this.config.backendURL + '/alert/dashboardDataSetInstance';
+        if (index !== null) {
+            url = url + '?alertIndex=' + index;
+        }
+        return this.http.post(url, dashboardDataSetInstance).toPromise();
+    }
+}

package/src/lib/services/dashboard.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { DashboardService } from './dashboard.service';
+
+describe('DashboardService', () => {
+  let service: DashboardService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(DashboardService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/src/lib/services/dashboard.service.ts

@@ -0,0 +1,79 @@
+import {Injectable} from '@angular/core';
+import {HttpClient} from '@angular/common/http';
+import {TagService} from './tag.service';
+import {ProjectService} from './project.service';
+import {KinintelModuleConfig} from '../ng-kinintel.module';
+import {BehaviorSubject} from 'rxjs';
+
+@Injectable({
+    providedIn: 'root'
+})
+export class DashboardService {
+
+    public dashboardItems = new BehaviorSubject({});
+    public dirtyDashboard = new BehaviorSubject(false);
+
+    constructor(private config: KinintelModuleConfig,
+                private http: HttpClient,
+                private tagService: TagService,
+                private projectService: ProjectService) {
+    }
+
+    public getDashboard(id) {
+        return this.http.get(`${this.config.backendURL}/dashboard/${id}`).toPromise();
+    }
+
+    public copyDashboard(id) {
+        return this.http.get(`${this.config.backendURL}/dashboard/copy/${id}`).toPromise();
+    }
+
+    public extendDashboard(id) {
+        return this.http.get(`${this.config.backendURL}/dashboard/extend/${id}`).toPromise();
+    }
+
+    public getDashboards(filterString = '', limit = '10', offset = '0', accountId: any = '', categories = [], tags?) {
+        tags = tags || (this.tagService.activeTag.getValue() ? this.tagService.activeTag.getValue().key : 'NONE');
+        const projectKey = this.projectService.activeProject.getValue() ? this.projectService.activeProject.getValue().projectKey : '';
+        const suffix = this.config.backendURL.indexOf('/account') && accountId === null ? '/shared/all' : '';
+        return this.http.get(this.config.backendURL + '/dashboard' + suffix, {
+            params: {
+                filterString, limit, offset, tags, projectKey, accountId, categories: categories.join(',')
+            }
+        });
+    }
+
+    public saveDashboard(dashboardSummary, accountId = null) {
+        const tags = this.tagService.activeTag.getValue() || null;
+        const projectKey = this.projectService.activeProject.getValue() ? this.projectService.activeProject.getValue().projectKey : '';
+
+        if (tags) {
+            dashboardSummary.tags = [tags];
+        }
+
+        const url = this.config.backendURL + '/dashboard?projectKey=' + projectKey + '&accountId=' + accountId;
+
+        return this.http.post(url, dashboardSummary).toPromise();
+    }
+
+    public updateMetadata(dashboardSearchResult) {
+        return this.http.patch(this.config.backendURL + '/dashboard', dashboardSearchResult).toPromise();
+    }
+
+    public getDashboardCategories(shared?) {
+        const tag = this.tagService.activeTag.getValue() || null;
+        const projectKey = this.projectService.activeProject.getValue() ? this.projectService.activeProject.getValue().projectKey : '';
+        let tags = '';
+
+        if (tag) {
+            tags = tag.key;
+        }
+        const url = shared ? '/dashboard/shared/inUseCategories' : '/dashboard/inUseCategories';
+        return this.http.get(this.config.backendURL + url, {
+            params: {projectKey, tags}
+        }).toPromise();
+    }
+
+    public removeDashboard(id) {
+        return this.http.delete(this.config.backendURL + '/dashboard/' + id).toPromise();
+    }
+}

package/src/lib/services/data-processor.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { DataProcessorService } from './data-processor.service';
+
+describe('DataProcessorService', () => {
+  let service: DataProcessorService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(DataProcessorService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/src/lib/services/data-processor.service.ts

@@ -0,0 +1,61 @@
+import {Injectable} from '@angular/core';
+import {KinintelModuleConfig} from '../../lib/ng-kinintel.module';
+import {HttpClient} from '@angular/common/http';
+import {ProjectService} from '../services/project.service';
+import * as lodash from 'lodash';
+const _ = lodash.default;
+
+@Injectable({
+    providedIn: 'root'
+})
+export class DataProcessorService {
+
+    constructor(private config: KinintelModuleConfig,
+                private http: HttpClient,
+                private projectService: ProjectService) {
+    }
+
+
+    public filterProcessorsByType(type: string = '', searchTerm = '', limit = '10', offset = '0', tags?) {
+        const projectKey = this.projectService.activeProject.getValue() ? this.projectService.activeProject.getValue().projectKey : '';
+
+        return this.http.get(this.config.backendURL + '/dataprocessor/type/' + type, {
+            params: _.omitBy({searchTerm, projectKey, limit, offset}, _.isNil)
+        });
+    }
+
+    public getProcessor(key: string) {
+        return this.http.get(this.config.backendURL + '/dataprocessor/' + key)
+            .toPromise();
+    }
+
+    public filterProcessorsByRelatedItem(type: string = '', relatedType = '', itemId: number, promise = true): any {
+        const request = this.http.get(this.config.backendURL + '/dataprocessor/relatedobject/' + type + '/' + relatedType + '/' + itemId);
+        return promise ? request.toPromise() : request;
+    }
+
+    public saveProcessor(processorSummary, autoStart = false) {
+        const projectKey = this.projectService.activeProject.getValue() ? this.projectService.activeProject.getValue().projectKey : '';
+
+        let url = this.config.backendURL + '/dataprocessor?projectKey=' + projectKey;
+
+        if (autoStart) {
+            url += '&autoStart=true';
+        }
+
+        return this.http.post(url, processorSummary).toPromise();
+    }
+
+    public removeProcessor(processorKey) {
+        return this.http.delete(this.config.backendURL + '/dataprocessor',
+            {body: JSON.stringify(processorKey)})
+            .toPromise();
+    }
+
+    public triggerProcessor(processorKey) {
+        return this.http.patch(this.config.backendURL + '/dataprocessor/' + processorKey, null)
+            .toPromise();
+    }
+
+
+}

package/src/lib/services/data-search.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { DataSearchService } from './data-search.service';
+
+describe('DataSearchService', () => {
+  let service: DataSearchService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(DataSearchService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/src/lib/services/data-search.service.ts

@@ -0,0 +1,31 @@
+import {Injectable} from '@angular/core';
+import {KinintelModuleConfig} from '../ng-kinintel.module';
+import {HttpClient} from '@angular/common/http';
+import {ProjectService} from './project.service';
+
+@Injectable({
+    providedIn: 'root'
+})
+export class DataSearchService {
+
+    constructor(private config: KinintelModuleConfig,
+                private http: HttpClient,
+                private projectService: ProjectService) {
+    }
+
+    public searchForDataItems(filters: {}, limit = 100, offset = 0) {
+        const projectKey = this.projectService.activeProject.getValue() ? this.projectService.activeProject.getValue().projectKey : '';
+
+        return this.http.post(this.config.backendURL + '/datasearch', filters, {
+            params: {offset, limit, projectKey}
+        });
+    }
+
+    public getMatchingDataItemTypesForSearchTerm(searchTerm = '') {
+        const projectKey = this.projectService.activeProject.getValue() ? this.projectService.activeProject.getValue().projectKey : '';
+
+        return this.http.get(this.config.backendURL + '/datasearch/types', {
+            params: {searchTerm, projectKey}
+        }).toPromise();
+    }
+}

package/src/lib/services/dataset.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { DatasetService } from './dataset.service';
+
+describe('DatasetService', () => {
+  let service: DatasetService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(DatasetService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/src/lib/services/dataset.service.ts

@@ -0,0 +1,234 @@
+import {Injectable} from '@angular/core';
+import {HttpClient} from '@angular/common/http';
+import {TagService} from './tag.service';
+import {ProjectService} from './project.service';
+import {KinintelModuleConfig} from '../ng-kinintel.module';
+import * as lodash from 'lodash';
+
+const _ = lodash.default;
+import {map, switchMap} from 'rxjs/operators';
+import {interval} from 'rxjs';
+
+@Injectable({
+    providedIn: 'root'
+})
+export class DatasetService {
+
+    constructor(private config: KinintelModuleConfig,
+                private http: HttpClient,
+                private tagService: TagService,
+                private projectService: ProjectService) {
+    }
+
+    public getDatasets(filterString = '', limit = '10', offset = '0', accountId = '', type = '', categories = [], tags?) {
+        tags = tags || (this.tagService.activeTag.getValue() ? this.tagService.activeTag.getValue().key : 'NONE');
+        const projectKey = this.projectService.activeProject.getValue() ? this.projectService.activeProject.getValue().projectKey : '';
+        const suffix = this.config.backendURL.indexOf('/account') && accountId === null ? '/shared/all' : '';
+        return this.http.get(this.config.backendURL + '/dataset' + suffix, {
+            params: {
+                filterString, limit, offset, tags, projectKey, accountId, type, categories: categories.join(',')
+            }
+        });
+    }
+
+
+    /**
+     * Get account shared datasets
+     *
+     * @param filterString
+     * @param limit
+     * @param offset
+     */
+    public getAccountSharedDatasets(filterString = '', limit = 10, offset = 0) {
+
+        return this.http.get(this.config.backendURL + '/dataset/shared', {
+            params: {
+                filterString, limit, offset
+            }
+        });
+    }
+
+
+    public getDataset(id) {
+        return this.http.get(`${this.config.backendURL}/dataset/${id}`).toPromise()
+            .then((dataset: any) => {
+                if (dataset.readOnly) {
+                    dataset.id = dataset.title = null;
+                    return dataset;
+                }
+                return dataset;
+            });
+    }
+
+    public getExtendedDataset(id) {
+        return this.http.get(`${this.config.backendURL}/dataset/extended/${id}`).toPromise();
+    }
+
+    public saveDataset(datasetInstanceSummary, accountId = null): Promise<number> {
+        const projectKey = this.projectService.activeProject.getValue() ? this.projectService.activeProject.getValue().projectKey : null;
+        const activeTag = this.tagService.activeTag.getValue() || null;
+        if (activeTag) {
+            datasetInstanceSummary.tags = [activeTag];
+        }
+        return this.http.post(this.config.backendURL + '/dataset/' + (projectKey ? '?projectKey=' + projectKey + '&' : '?') + 'accountId=' + accountId,
+            datasetInstanceSummary).toPromise().then((id: number) => {
+            return id;
+        });
+    }
+
+    public removeDataset(id) {
+        return this.http.delete(this.config.backendURL + '/dataset/' + id).toPromise();
+    }
+
+    public getEvaluatedParameters(datasetInstanceSummary) {
+        return this.http.post(this.config.backendURL + '/dataset/parameters', datasetInstanceSummary)
+            .toPromise().catch(err => []);
+    }
+
+    public evaluateDataset(datasetInstanceSummary, offset = '0', limit = '25') {
+        const projectKey = this.projectService.activeProject.getValue() ? this.projectService.activeProject.getValue().projectKey : '';
+        return this.http.post(this.config.backendURL + `/dataset/evaluate?limit=${limit}&offset=${offset}&projectKey=${projectKey}`,
+            datasetInstanceSummary).toPromise();
+    }
+
+    public evaluateDatasetWithTracking(datasetInstanceSummary, offset = '0', limit = '25', trackingKey = '') {
+        const projectKey = this.projectService.activeProject.getValue() ? this.projectService.activeProject.getValue().projectKey : '';
+        return this.http.post(this.config.backendURL + `/dataset/evaluate?limit=${limit}&offset=${offset}&trackingKey=${trackingKey}&projectKey=${projectKey}`,
+            datasetInstanceSummary);
+    }
+
+    public getDataTrackingResults(trackingKey) {
+        return interval(2000)
+            .pipe(
+                switchMap(() =>
+                    this.http.get(this.config.backendURL + `/dataset/results/${trackingKey}`).pipe(
+                        map(result => {
+                            return result;
+                        }))
+                )
+            );
+    }
+
+    public exportDataset(exportDataset) {
+        return this.http.post(this.config.backendURL + `/dataset/export`, exportDataset,
+            {responseType: 'blob'})
+            .toPromise();
+    }
+
+
+    /**
+     * Set shared access for a dataset instance for the logged in account
+     *
+     * @param datasetInstanceId
+     * @param shared
+     */
+    public async setSharedAccessForDatasetInstanceForLoggedInAccount(datasetInstanceId, shared) {
+        return this.http.post(this.config.backendURL + `/dataset/shareWithCurrentAccount/${datasetInstanceId}/${shared}`, {}).toPromise();
+    }
+
+
+    public async getSharedAccessGroupsForDatasetInstance(datasetInstanceId) {
+        return this.http.get(this.config.backendURL + `/dataset/sharedAccessGroups/${datasetInstanceId}`).toPromise();
+    }
+
+    public async revokeAccessToGroupForDatasetInstance(datasetInstanceId, accessGroup) {
+        return this.http.delete(this.config.backendURL + `/dataset/sharedAccessGroups/${datasetInstanceId}`,
+            {body: JSON.stringify(accessGroup)}).toPromise();
+    }
+
+
+    public async getInvitedAccessGroupsForDatasetInstance(datasetInstanceId) {
+        return this.http.get(this.config.backendURL + `/dataset/invitedAccessGroups/${datasetInstanceId}`).toPromise();
+    }
+
+
+    public async inviteAccountToShareDatasetInstance(datasetInstanceId, accountExternalIdentifier, expiryDate = null) {
+        let path = `/dataset/invitedAccessGroups/${datasetInstanceId}/${accountExternalIdentifier}`;
+        if (expiryDate) path += '?expiryDate=' + expiryDate;
+        return this.http.get(this.config.backendURL + path).toPromise();
+    }
+
+
+    public async cancelInvitationForAccessGroupForDatasetInstance(datasetInstanceId, accessGroup) {
+        return this.http.delete(this.config.backendURL + `/dataset/invitedAccessGroups/${datasetInstanceId}`,
+            {body: JSON.stringify(accessGroup)}).toPromise();
+    }
+
+
+    // Get a sharable item for an invitation
+    public async getSharableItemForInvitation(invitationCode) {
+        return this.http.get(this.config.guestURL + `/sharing/${invitationCode}`).toPromise();
+    }
+
+
+    // Accept a sharing invitation using an invitation code.
+    public async acceptSharingInvitation(invitationCode) {
+        this.http.post(this.config.guestURL + `/sharing/${invitationCode}`, {}).toPromise();
+    }
+
+    // Accept a sharing invitation using an invitation code.
+    public async cancelSharingInvitation(invitationCode) {
+        this.http.delete(this.config.guestURL + `/sharing/${invitationCode}`).toPromise();
+    }
+
+
+    public listSnapshotProfiles(filterString = '', limit = '10', offset = '0', tags?) {
+        const projectKey = this.projectService.activeProject.getValue() ? this.projectService.activeProject.getValue().projectKey : '';
+        const activeTag = tags || (this.tagService.activeTag.getValue() ? this.tagService.activeTag.getValue().key : '');
+
+        return this.http.get(this.config.backendURL + '/dataset/snapshotprofile', {
+            params: _.omitBy({filterString, limit, offset, tags: activeTag, projectKey}, _.isNil)
+        });
+    }
+
+    public getSnapshotProfile(id: number) {
+        return this.http.get(this.config.backendURL + '/dataset/snapshotprofile/' + id)
+            .toPromise();
+    }
+
+    public getSnapshotProfilesForDataset(datasetInstanceId: number) {
+        return this.http.get(this.config.backendURL + '/dataset/snapshotprofile/dataset/' + datasetInstanceId)
+            .toPromise();
+    }
+
+    public saveSnapshotProfile(snapshotProfileSummary, datasetInstanceId) {
+        return this.http.post(this.config.backendURL + '/dataset/snapshotprofile/' + datasetInstanceId,
+            snapshotProfileSummary)
+            .toPromise();
+    }
+
+    public removeSnapshotProfile(snapshotProfileId, datasetInstanceId) {
+        return this.http.delete(this.config.backendURL + '/dataset/snapshotprofile/' + datasetInstanceId,
+            {params: {snapshotProfileId}})
+            .toPromise();
+    }
+
+    public triggerSnapshot(snapshotProfileId, datasetInstanceId) {
+        return this.http.patch(this.config.backendURL + '/dataset/snapshotprofile/' + datasetInstanceId,
+            snapshotProfileId)
+            .toPromise();
+    }
+
+    public updateMetadata(dashboardSearchResult) {
+        return this.http.patch(this.config.backendURL + '/dataset', dashboardSearchResult).toPromise();
+    }
+
+    public getDatasetCategories(shared?) {
+        const tag = this.tagService.activeTag.getValue() || null;
+        const projectKey = this.projectService.activeProject.getValue() ? this.projectService.activeProject.getValue().projectKey : '';
+        let tags = '';
+
+        if (tag) {
+            tags = tag.key;
+        }
+        const url = shared ? '/dataset/shared/inUseCategories' : '/dataset/inUseCategories';
+        return this.http.get(this.config.backendURL + url, {
+            params: {projectKey, tags}
+        }).toPromise();
+    }
+
+    public getWhiteListedSQLFunctions() {
+        return this.http.get(this.config.backendURL + '/dataset/whitelistedsqlfunctions')
+            .toPromise();
+    }
+}

package/src/lib/services/datasource.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { DatasourceService } from './datasource.service';
+
+describe('DatasourceService', () => {
+  let service: DatasourceService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(DatasourceService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});

package/src/lib/services/datasource.service.ts

@@ -0,0 +1,116 @@
+import {Injectable} from '@angular/core';
+import {HttpClient, HttpHeaders} from '@angular/common/http';
+import {KinintelModuleConfig} from '../ng-kinintel.module';
+import {ProjectService} from '../services/project.service';
+import {interval, of} from 'rxjs';
+import {catchError, map, switchMap} from 'rxjs/operators';
+
+export interface DatasourceUpdate {
+    title: string;
+    instanceImportKey?: string;
+    fields: any[];
+    adds: any[];
+    updates: any[];
+    deletes: any[];
+}
+
+@Injectable({
+    providedIn: 'root'
+})
+export class DatasourceService {
+
+    constructor(private config: KinintelModuleConfig,
+                private http: HttpClient,
+                private projectService: ProjectService) {
+    }
+
+    public createCustomDatasource(datasourceUpdate: DatasourceUpdate): Promise<any> {
+        const projectKey = this.projectService.activeProject.getValue() ? this.projectService.activeProject.getValue().projectKey : '';
+        return this.http.post(this.config.backendURL + '/datasource/custom?projectKey=' + projectKey, datasourceUpdate)
+            .toPromise();
+    }
+
+    public updateCustomDatasource(datasourceInstanceKey, datasourceUpdate: DatasourceUpdate | any) {
+        return this.http.put(this.config.backendURL + '/datasource/custom/' + datasourceInstanceKey, datasourceUpdate)
+            .toPromise();
+    }
+
+    public getDatasources(filterString = '', limit = '10', offset = '0', noProject = false) {
+        const project = this.projectService.activeProject.getValue() ? this.projectService.activeProject.getValue().projectKey : '';
+        const projectKey = noProject ? '' : project;
+        return this.http.get(this.config.backendURL + '/datasource?projectKey=' + projectKey, {
+            params: {
+                filterString, limit, offset
+            }
+        });
+    }
+
+    public getDatasource(key) {
+        return this.http.get(this.config.backendURL + '/datasource/' + key).toPromise();
+    }
+
+    public deleteDatasource(key) {
+        return this.http.delete(this.config.backendURL + '/datasource/' + key).toPromise();
+    }
+
+    public deleteFromDatasource(datasourceInstanceKey: string, filter: any = []) {
+        return this.http.delete(this.config.backendURL + '/datasource/custom/' + datasourceInstanceKey, {
+            body: filter
+        }).toPromise();
+    }
+
+    public getEvaluatedParameters(evaluatedDatasource) {
+        return this.http.get(this.config.backendURL + '/datasource/parameters/' +
+            (evaluatedDatasource.key || evaluatedDatasource.datasourceInstanceKey)).toPromise();
+    }
+
+    public evaluateDatasource(evaluatedDatasource) {
+        return this.http.post(this.config.backendURL + '/datasource/evaluate', evaluatedDatasource).toPromise();
+    }
+
+    public exportData(evaluatedDatasource) {
+        return this.http.post(this.config.backendURL + '/datasource/parameters/' +
+            (evaluatedDatasource.key || evaluatedDatasource.datasourceInstanceKey),
+            {transformationInstances: evaluatedDatasource.transformationInstances}).toPromise();
+    }
+
+    public createDocumentDatasource(config) {
+        const projectKey = this.projectService.activeProject.getValue() ? this.projectService.activeProject.getValue().projectKey : '';
+        return this.http.post(this.config.backendURL + '/datasource/document?projectKey=' + projectKey,
+            config)
+            .toPromise();
+    }
+
+    public updateDatasourceInstance(key, config) {
+        return this.http.put(this.config.backendURL + '/datasource/' + key, config).toPromise();
+    }
+
+    public updateCustomDatasourceInstance(key, config) {
+        return this.http.patch(this.config.backendURL + '/datasource/custom/' + key, config).toPromise();
+    }
+
+    public uploadDatasourceDocuments(key, uploadedFiles, trackingKey) {
+        const HttpUploadOptions = {
+            headers: new HttpHeaders({ 'Content-Type': 'file' })
+        };
+        return this.http.post(this.config.backendURL + '/datasource/document/upload/' + key + '?trackingKey=' + trackingKey,
+            uploadedFiles, HttpUploadOptions).toPromise();
+    }
+
+    public getDataTrackingResults(trackingKey) {
+        return interval(2000)
+            .pipe(
+                switchMap(() =>
+                    this.http.get(this.config.backendURL + `/datasource/document/upload/tracking`, {
+                        params: {trackingKey}
+                    }).pipe(
+                        map(result => {
+                            return result;
+                        }),
+                        catchError(err => {
+                            return of(null);
+                        }))
+                )
+            );
+    }
+}

package/src/lib/services/external.service.spec.ts

@@ -0,0 +1,16 @@
+import { TestBed } from '@angular/core/testing';
+
+import { ExternalService } from './external.service';
+
+describe('ExternalService', () => {
+  let service: ExternalService;
+
+  beforeEach(() => {
+    TestBed.configureTestingModule({});
+    service = TestBed.inject(ExternalService);
+  });
+
+  it('should be created', () => {
+    expect(service).toBeTruthy();
+  });
+});