@dronedeploy/rocos-js-sdk 3.0.1-alpha.2 → 3.0.1-alpha.5

package/cjs/services/MapService.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MapService = void 0;
+const api_1 = require("../constants/api");
+const models_1 = require("../models");
+const BaseServiceAbstract_1 = require("./BaseServiceAbstract");
+const RocosLogger_1 = require("../logger/RocosLogger");
+const formatServiceUrl_1 = require("../helpers/formatServiceUrl");
+/**
+ * Integrations to retrieve data from the linked project in DroneDeploy
+ */
+class MapService extends BaseServiceAbstract_1.BaseServiceAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`MapService(${this.config.url})`);
+    }
+    getStatus() {
+        return true;
+    }
+    getError(e) {
+        return new models_1.RocosError(e, models_1.errorCodes.MAPS_SERVICE_ERROR);
+    }
+    async list(projectId, callsign) {
+        const resp = await this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_MAPS_URL, {
+            url: this.config.url,
+            projectId,
+        }, this.config.insecure), 'Failed to get maps.', callsign ? { callsign } : undefined);
+        return resp.maps;
+    }
+    /** List maps to be deployed to a callsign
+     *
+     * @param projectId
+     * @param callsign
+     */
+    async listDeployedMaps(projectId, callsign) {
+        const safeCallsign = encodeURIComponent(callsign);
+        const resp = await this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_MAPS_DEPLOYED_URL, {
+            url: this.config.url,
+            projectId,
+            callsign: safeCallsign,
+        }, this.config.insecure), 'Failed to get deployed maps.');
+        return resp.maps;
+    }
+    /**
+     * Creates a new map by merging two existing maps
+     * @param projectId Project ID
+     * @param maps Array of two map IDs to merge
+     * @param options Options to create the new map
+     */
+    async merge(projectId, maps, options) {
+        if (maps.length !== 2)
+            throw new Error('You must provide two maps to merge.');
+        const payload = {
+            projectID: projectId,
+            mapIDLeft: maps[0],
+            mapIDRight: maps[1],
+            name: options.name,
+            description: options.description,
+            callsign: options.callsign,
+        };
+        return this.callPost((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_MAPS_MERGE_URL, {
+            url: this.config.url,
+            projectId,
+        }, this.config.insecure), payload, 'Failed to merge maps.');
+    }
+    /** Returns a map in its canonical form
+     *
+     * @param projectId Project ID
+     * @param mapId Map ID
+     */
+    async get(projectId, mapId) {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_MAP_ID_URL, {
+            url: this.config.url,
+            projectId,
+            mapId,
+        }, this.config.insecure), 'Failed to get map.');
+    }
+    /**
+     * Updates a maps metadata
+     * @param projectId Project ID
+     * @param mapId Map ID
+     * @param options New metadata
+     */
+    async update(projectId, mapId, options) {
+        return this.callPut((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_MAP_ID_URL, {
+            url: this.config.url,
+            projectId,
+            mapId,
+        }, this.config.insecure), options, 'Failed to update map.');
+    }
+    /**
+     * Begins uploading a map from the agent
+     *
+     * @param projectId Project ID
+     * @param mapId Map ID
+     * @param callsign Robot callsign
+     * @param hash Map hash
+     */
+    async sendToCloud(projectId, mapId, callsign, hash) {
+        return this.callPost((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_MAP_ID_URL, {
+            url: this.config.url,
+            projectId,
+            mapId,
+        }, this.config.insecure), { callsign, hash }, 'Failed to start map upload.');
+    }
+    async delete(projectId, mapId, callsign, hash) {
+        return this.callDelete((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_MAP_ID_URL, {
+            url: this.config.url,
+            projectId,
+            mapId,
+        }, this.config.insecure), 'Failed to delete map.', callsign ? { callsign, hash } : {});
+    }
+    /**
+     * Makes a copy of an uploaded map
+     *
+     * @param projectId Project ID
+     * @param mapId Map ID
+     * @param options Options to create the new map
+     */
+    async copy(projectId, mapId, options) {
+        return this.callPost((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_MAPS_COPY_URL, {
+            url: this.config.url,
+            projectId,
+            mapId,
+        }, this.config.insecure), options, 'Failed to copy map.');
+    }
+    /** Deploy a map from the cloud to a robot
+     *
+     * @param projectId Project ID
+     * @param mapId Map ID
+     * @param callsign Robot callsign
+     */
+    async deploy(projectId, mapId, callsign) {
+        return this.callPost((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_MAPS_DEPLOY_URL, {
+            url: this.config.url,
+            projectId,
+            mapId,
+        }, this.config.insecure), { callsign }, 'Failed to deploy map.');
+    }
+    /** Get a GeoJSON representation of a map
+     *
+     * @param projectId Project ID
+     * @param mapId Map ID
+     * @param frameId Frame ID (optional)
+     */
+    async getGeoJSON(projectId, mapId, frameId) {
+        const params = {
+            url: this.config.url,
+            projectId,
+            mapId,
+        };
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_MAPS_GEOJSON_URL, params, this.config.insecure), 'Failed to get map GeoJSON.', frameId ? { frameID: frameId } : undefined);
+    }
+    /**
+     * Returns a Promise that resolves to an array of Observation objects for the given panorama ID.
+     *
+     * @param projectId The ID of the project the panorama belongs to.
+     * @param panoramaId The ID of the panorama to retrieve observations for.
+     * @returns A Promise that resolves to an array of Observation objects.
+     */
+    listObservations(projectId, panoramaId) {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_MAPS_PANORAMA_OBSERVATIONS_URL, { url: this.config.url, projectId, panoramaId }, this.config.insecure), 'Failed to list observations.');
+    }
+    /**
+     * Creates new observations on a panorama.
+     *
+     * @param projectId The ID of the project the panorama belongs to.
+     * @param panoramaId The ID of the panorama to create observations for.
+     * @param observations An array of Observation objects to create.
+     * @returns A Promise that resolves when the observations have been created.
+     */
+    createObservations(projectId, panoramaId, observations) {
+        return this.callPut((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_MAPS_PANORAMA_OBSERVATIONS_URL, { url: this.config.url, projectId, panoramaId }, this.config.insecure), observations, 'Failed to update observations.');
+    }
+    /**
+     * Gets observations for a project.
+     *
+     * @param projectId The ID of the project the observations belongs to.
+     * @param key (optional) Filters on a key defined on the observation
+     * @param frameID (optional) Transforms on a seed frame
+     * @returns A list of observations
+     */
+    getObservations(projectId, key = '', frameID = '') {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_OBSERVATIONS_URL, { url: this.config.url, projectId }, this.config.insecure), 'Failed to get observations.', { key, frameID });
+    }
+    /**
+     * Lists available keys for all observations in a project.
+     *
+     * @param projectId The ID of the project the observations belongs to.
+     * @returns A list of observations
+     */
+    getObservationsKeys(projectId) {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_OBSERVATION_KEYS_URL, { url: this.config.url, projectId }, this.config.insecure), 'Failed to get observation keys.');
+    }
+}
+exports.MapService = MapService;

package/cjs/services/PlatformTimeService.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlatFormTimeService = void 0;
+const RocosLogger_1 = require("../logger/RocosLogger");
+const standardDeviation_1 = require("../helpers/standardDeviation");
+const NUMBER_OF_SERVER_TIME_USED_TO_CALIBRATE = 5;
+const MAX_CLIENT_WAITING_TIME_STANDARD_DEVIATION_ALLOWED = 100; // 100 miliseconds
+const KEY_GR_PLATFORM_TIME_OFFSET = 'gr_platformTimeOffset';
+const KEY_GR_LAST_PLATFORM_TIME_SYNCED_AT = 'gr_lastPlatformTimeSyncedAt';
+const GR_PLATFORM_TIME_TTL = 30 * 60 * 1000; // 30 minutes
+class PlatFormTimeService {
+    // Make this a singleton, so that we don't have multi platform time
+    constructor(timeSyncerService) {
+        this.backoffTimeouts = [5 * 1000, 30 * 1000, 60 * 1000, 300 * 1000]; // in miliseconds
+        this.isSyncing = false;
+        this.backoffFailCount = 0;
+        this.serverTimeOffset = 0;
+        this.lastPlatformTimeSyncedAt = 0;
+        this.logger = RocosLogger_1.RocosLogger.getInstance('PlatformTimeService');
+        if (window?.localStorage) {
+            this.lastPlatformTimeSyncedAt = Number(window.localStorage.getItem(KEY_GR_LAST_PLATFORM_TIME_SYNCED_AT)) || 0;
+            this.serverTimeOffset = Number(window.localStorage.getItem(KEY_GR_PLATFORM_TIME_OFFSET)) || 0;
+        }
+        this.timeSyncerService = timeSyncerService;
+        this.logger.debug('stored platform time: ', this.platformTime);
+        setTimeout(() => {
+            void this.getClockOffsetBetweenClientAndServer();
+        }, 2000);
+    }
+    static getInstance(timeSyncerService) {
+        if (!PlatFormTimeService.instance) {
+            if (!timeSyncerService) {
+                throw new Error('platform time service object is not instantiated yet, please pass timeSyncerService to create it');
+            }
+            PlatFormTimeService.instance = new PlatFormTimeService(timeSyncerService);
+        }
+        return PlatFormTimeService.instance;
+    }
+    get platformTimeOffset() {
+        return this.serverTimeOffset;
+    }
+    get platformTime() {
+        const now = Date.now();
+        return now - this.serverTimeOffset;
+    }
+    async getClockOffsetBetweenClientAndServer() {
+        let serverTimeOffsets = [];
+        if (this.isSyncing) {
+            return;
+        }
+        this.isSyncing = true;
+        for (let count = 0; count < NUMBER_OF_SERVER_TIME_USED_TO_CALIBRATE; count++) {
+            try {
+                const platformTime = await this.getPlatformTime();
+                serverTimeOffsets.push(platformTime);
+            }
+            catch (e) {
+                this.handleGetServerTimeError(e);
+                return;
+            }
+        }
+        if (this.isReliableServerTime(serverTimeOffsets)) {
+            serverTimeOffsets = this.removeLongestAndShortest(serverTimeOffsets);
+            const serverTimeOffset = this.calculateOffset(serverTimeOffsets);
+            this.saveOffset(serverTimeOffset);
+        }
+        else {
+            this.handleServerTimeNotReliable();
+        }
+    }
+    async getPlatformTime() {
+        const clientTimeStampStart = Date.now();
+        // exception should be handled by the caller
+        const serverTime = await this.getServerTime();
+        const clientTimeStampEnd = Date.now();
+        return {
+            clientTimeStampEnd,
+            clientTimeStampStart,
+            serverTime,
+        };
+    }
+    handleServerTimeNotReliable() {
+        this.logger.error('not able to get reliable server time, will try again...');
+        this.isSyncing = false;
+        this.backoff();
+    }
+    backoff() {
+        this.backoffFailCount++;
+        this.logger.debug('backoff count: ', this.backoffFailCount);
+        const backoffTimeoutIndex = this.backoffFailCount - 1;
+        let delay;
+        if (backoffTimeoutIndex >= this.backoffTimeouts.length) {
+            // Use the longest delay if backoff failed too many times
+            delay = this.backoffTimeouts[this.backoffTimeouts.length - 1];
+        }
+        else {
+            delay = this.backoffTimeouts[backoffTimeoutIndex];
+        }
+        setTimeout(() => {
+            void this.getClockOffsetBetweenClientAndServer();
+        }, delay);
+    }
+    isReliableServerTime(platformTimeMeasurements) {
+        const stdDeviation = (0, standardDeviation_1.standardDeviation)(
+        // get the standardDeviation of the client waiting time
+        platformTimeMeasurements.map((x) => x.clientTimeStampEnd - x.clientTimeStampStart));
+        this.logger.debug('standard deviation', stdDeviation);
+        // We judge server time is reliable only the standard deviation of client waiting time is less
+        // than the threshold
+        return stdDeviation < MAX_CLIENT_WAITING_TIME_STANDARD_DEVIATION_ALLOWED;
+    }
+    handleGetServerTimeError(e) {
+        this.logger.error('Fail to get server time, will try again...', { e });
+        this.isSyncing = false;
+        this.backoff();
+    }
+    calculateOffset(platformTimeMeasurements) {
+        //  Timestamp when Received the Response - Time Request Duration / 2 - Timestamp within the Response .
+        let totalServerTimeOffset = 0;
+        const measurementsWithValues = platformTimeMeasurements.filter((x) => !!x?.serverTime);
+        measurementsWithValues.forEach((x) => {
+            // eslint-disable-next-line operator-linebreak
+            totalServerTimeOffset +=
+                // eslint-disable-next-line no-mixed-operators
+                x.clientTimeStampEnd - (x.clientTimeStampEnd - x.clientTimeStampStart) / 2 - x.serverTime.now / 10 ** 6;
+        });
+        // final platformTimeOffset is in miliseconds
+        return Math.round(totalServerTimeOffset / measurementsWithValues.length);
+    }
+    saveOffset(timeOffset) {
+        this.backoffFailCount = 0;
+        this.isSyncing = false;
+        this.serverTimeOffset = timeOffset;
+        this.lastPlatformTimeSyncedAt = Date.now();
+        if (window?.localStorage) {
+            window.localStorage.setItem(KEY_GR_PLATFORM_TIME_OFFSET, String(this.serverTimeOffset));
+            window.localStorage.setItem(KEY_GR_LAST_PLATFORM_TIME_SYNCED_AT, String(this.lastPlatformTimeSyncedAt));
+        }
+        this.logger.debug('calibrated server time offset', timeOffset);
+        // resync the time in 30 minutes
+        setTimeout(() => {
+            void this.getClockOffsetBetweenClientAndServer();
+        }, GR_PLATFORM_TIME_TTL);
+    }
+    removeLongestAndShortest(serverTimeMeasurements) {
+        let result = [];
+        if (serverTimeMeasurements.length > 2) {
+            // remove the server time responses with shortest/longest client waiting duration
+            serverTimeMeasurements.sort((a, b) => {
+                return a.clientTimeStampEnd - a.clientTimeStampStart - (b.clientTimeStampEnd - b.clientTimeStampStart);
+            });
+            result = serverTimeMeasurements.slice(1, serverTimeMeasurements.length - 1);
+        }
+        return result;
+    }
+    getServerTime() {
+        return this.timeSyncerService.getServerTime();
+    }
+}
+exports.PlatFormTimeService = PlatFormTimeService;

package/cjs/services/PlatformTimeService.spec.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const PlatformTimeService_1 = require("./PlatformTimeService");
+const TimeSyncerService_1 = require("./TimeSyncerService");
+const helpers_1 = require("../helpers");
+// Subclass PlatformTimeService so that we can test the protected methods
+class PlatformtimeServicePublic extends PlatformTimeService_1.PlatFormTimeService {
+    constructor(timeSyncerService) {
+        super(timeSyncerService);
+    }
+    isReliableServerTime(platformTimeMeasurement) {
+        return super.isReliableServerTime(platformTimeMeasurement);
+    }
+    calculateOffset(platformTimeMeasurement) {
+        return super.calculateOffset(platformTimeMeasurement);
+    }
+    removeLongestAndShortest(platformTimeMeasurement) {
+        return super.removeLongestAndShortest(platformTimeMeasurement);
+    }
+    static getInstance(timeSyncerService) {
+        const instance = super.getInstance(timeSyncerService);
+        return instance;
+    }
+}
+describe('platformTimeService', () => {
+    it('should calculate standard deviation correctly', () => {
+        let numbers = [10, 12, 23, 23, 16, 23, 21, 16];
+        let stdDev = (0, helpers_1.standardDeviation)(numbers);
+        expect(Math.abs(stdDev - 4.8989794855664)).toBeLessThan(0.000001);
+        numbers = [100, 12, 23, 23, 116, 23, 21, 162];
+        stdDev = (0, helpers_1.standardDeviation)(numbers);
+        expect(Math.abs(stdDev - 53.702886328394)).toBeLessThan(0.000001);
+    });
+    it('should be able to tell reliable server time response', () => {
+        jest.useFakeTimers();
+        const p = PlatformtimeServicePublic.getInstance(new TimeSyncerService_1.TimeSyncerService({}));
+        const mock = {
+            clientTimeStampEnd: 100,
+            clientTimeStampStart: 20,
+            serverTime: {
+                now: 0,
+                duration: 0,
+            },
+        };
+        const mocks = [];
+        mocks.push(mock);
+        let isReliableServerTime = p.isReliableServerTime(mocks);
+        expect(isReliableServerTime).toBeTruthy();
+        for (let i = 0; i < 4; i++) {
+            mocks.push({ ...mock });
+            isReliableServerTime = p.isReliableServerTime(mocks);
+            expect(isReliableServerTime).toBeTruthy();
+        }
+    });
+    it('should be able to tell unreliable server time response', () => {
+        jest.useFakeTimers();
+        const p = PlatformtimeServicePublic.getInstance(new TimeSyncerService_1.TimeSyncerService({}));
+        const mock = {
+            clientTimeStampEnd: 100,
+            clientTimeStampStart: 0,
+            serverTime: {
+                now: 0,
+                duration: 0,
+            },
+        };
+        const mocks = [];
+        let isReliableServerTime = false;
+        for (let i = 0; i < 5; i++) {
+            const mockClone = { ...mock };
+            mockClone.clientTimeStampEnd += i * 60;
+            mocks.push(mockClone);
+        }
+        isReliableServerTime = p.isReliableServerTime(mocks);
+        expect(isReliableServerTime).toBeTruthy();
+        for (let i = 0; i < 5; i++) {
+            const mockClone = { ...mock };
+            mockClone.clientTimeStampEnd += i * 70;
+            mocks.push(mockClone);
+        }
+        isReliableServerTime = p.isReliableServerTime(mocks);
+        expect(isReliableServerTime).toBeTruthy();
+        for (let i = 0; i < 5; i++) {
+            const mockClone = { ...mock };
+            mockClone.clientTimeStampEnd += i * 80;
+            mocks.push(mockClone);
+        }
+        isReliableServerTime = p.isReliableServerTime(mocks);
+        // std dev = 113.13708498985
+        expect(isReliableServerTime).toBeFalsy();
+        for (let i = 0; i < 5; i++) {
+            const mockClone = { ...mock };
+            mockClone.clientTimeStampEnd += i * 100;
+            mocks.push(mockClone);
+        }
+        isReliableServerTime = p.isReliableServerTime(mocks);
+        expect(isReliableServerTime).toBeFalsy();
+    });
+    it('should be able to remove shortest and longest correctly', () => {
+        jest.useFakeTimers();
+        const p = PlatformtimeServicePublic.getInstance(new TimeSyncerService_1.TimeSyncerService({}));
+        const mock = {
+            clientTimeStampEnd: 100,
+            clientTimeStampStart: 0,
+            serverTime: {
+                now: 0,
+                duration: 0,
+            },
+        };
+        const mocks = [];
+        let mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 100;
+        mocks.push(mockClone);
+        mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 200;
+        mocks.push(mockClone);
+        mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 500;
+        mocks.push(mockClone);
+        mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 400;
+        mocks.push(mockClone);
+        mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 300;
+        mocks.push(mockClone);
+        const platformTimeMeasurement = p.removeLongestAndShortest(mocks);
+        platformTimeMeasurement.forEach((p) => {
+            expect(p.clientTimeStampEnd).not.toEqual(100);
+            expect(p.clientTimeStampEnd).not.toEqual(500);
+        });
+    });
+    it('should be able to calculate the offset correctly', () => {
+        jest.useFakeTimers();
+        const p = PlatformtimeServicePublic.getInstance(new TimeSyncerService_1.TimeSyncerService({}));
+        const mock = {
+            clientTimeStampEnd: 100,
+            clientTimeStampStart: 0,
+            serverTime: {
+                now: 0,
+                duration: 0,
+            },
+        };
+        const mocks = [];
+        let mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 200;
+        mocks.push(mockClone);
+        mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 500;
+        mocks.push(mockClone);
+        mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 400;
+        mocks.push(mockClone);
+        const offset = p.calculateOffset(mocks);
+        // (200-(200)/2 + 500 - (500)/2 + 400 - (400)/2)/3 = 183.333333333, round to 183
+        expect(offset).toEqual(183);
+    });
+    it('should be able to filter where service time is not provided', () => {
+        jest.useFakeTimers();
+        const p = PlatformtimeServicePublic.getInstance(new TimeSyncerService_1.TimeSyncerService({}));
+        const mock = {
+            clientTimeStampEnd: 100,
+            clientTimeStampStart: 0,
+            serverTime: {
+                now: 0,
+                duration: 0,
+            },
+        };
+        const mocks = [];
+        let mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 200;
+        mockClone.serverTime = undefined;
+        mocks.push(mockClone);
+        mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 500;
+        mocks.push(mockClone);
+        mockClone = { ...mock };
+        mockClone.clientTimeStampEnd = 400;
+        mocks.push(mockClone);
+        const offset = p.calculateOffset(mocks);
+        // (500 - (500)/2 + 400 - (400)/2)/2 = 225
+        expect(offset).toEqual(225);
+    });
+});