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

package/cjs/services/IntegrationService.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntegrationService = 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 IntegrationService extends BaseServiceAbstract_1.BaseServiceAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`IntegrationService(${this.config.url})`);
+    }
+    getStatus() {
+        return true;
+    }
+    getError(e) {
+        return new models_1.RocosError(e, models_1.errorCodes.INTEGRATIONS_SERVICE_ERROR);
+    }
+    /**
+     * Gets latest plans from the project linked to the provided project ID
+     * @param projectId Project ID
+     * @returns Plans list (limited to 50)
+     */
+    async getPlans(projectId) {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_DD_INTEGRATION_PLANS_URL, { url: this.config.url, projectId }, this.config.insecure), 'Failed to get plans.');
+    }
+    /**
+     * Gets the plans from the project linked to the provided project ID
+     * @param projectId Project ID
+     * @param pageStart Page start
+     * @returns Plans list (limited to 50) with cursor to next page when available
+     */
+    async getPlansPaged(projectId, pageStart) {
+        const params = pageStart ? { page_start: pageStart } : undefined;
+        const response = await this.callGet((0, formatServiceUrl_1.formatServiceUrl)(`${api_1.API_DD_INTEGRATION_PLANS_URL}`, { url: this.config.url, projectId }, this.config.insecure), 'Failed to get plans.', params, { responseType: 'raw' });
+        const pageNext = response.headers.get('x-dd-page-next') ?? undefined;
+        const plans = await response.json();
+        return {
+            plans,
+            pageNext,
+        };
+    }
+    /**
+     * Gets a plan for a given project (using its linked project)
+     * @param projectId Project ID
+     * @param planId Requested plan
+     * @returns A single plan
+     */
+    async getPlanById(projectId, planId) {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_DD_INTEGRATION_PLAN_BY_ID_URL, { url: this.config.url, projectId, planId }, this.config.insecure), 'Failed to get plan.');
+    }
+    /**
+     * Returns raster overlays such as drawings to be used for mission planning
+     * @param projectId Project ID
+     * @returns A list of overlays in the project
+     */
+    async getOverlays(projectId) {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_DD_INTEGRATION_OVERLAYS_URL, { url: this.config.url, projectId }, this.config.insecure), 'Failed to get overlays.');
+    }
+    /**
+     * Creates a blank issue in the latest ortho plan available
+     * @param projectId Project ID
+     * @param location Location of the issue
+     */
+    async createIssue(projectId, location) {
+        return this.callPost((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_DD_INTEGRATION_ISSUES_URL, { url: this.config.url, projectId }, this.config.insecure), {
+            lat: location.lat,
+            lng: location.lng,
+        }, 'Failed to create issue.');
+    }
+}
+exports.IntegrationService = IntegrationService;

package/cjs/services/MapService.d.ts

@@ -0,0 +1,142 @@
+import { IBaseService, IRocosSDKConfig, Map, RocosError } from '../models';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { Observation } from '../models/maps/Panorama';
+/**
+ * Maps service for managing robot maps in the cloud and on robots
+ */
+export declare class MapService extends BaseServiceAbstract implements IBaseService {
+    constructor(config: IRocosSDKConfig);
+    getStatus(): boolean;
+    protected getError(e: Error): RocosError;
+    /**
+     * List maps from the cloud
+     *
+     * @param projectId Project ID
+     * @returns All maps in the cloud
+     */
+    list(projectId: string): Promise<Map[]>;
+    /**
+     * List maps from the robot and the cloud
+     *
+     * @param projectId Project ID
+     * @param callsign Robot callsign
+     * @returns All maps in the cloud
+     */
+    list(projectId: string, callsign: string): Promise<Map[]>;
+    /** List maps to be deployed to a callsign
+     *
+     * @param projectId
+     * @param callsign
+     */
+    listDeployedMaps(projectId: string, callsign: string): Promise<Map[]>;
+    /**
+     * 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
+     */
+    merge(projectId: string, maps: [string, string], options: {
+        name: string;
+        description?: string;
+        callsign: string;
+    }): Promise<void>;
+    /** Returns a map in its canonical form
+     *
+     * @param projectId Project ID
+     * @param mapId Map ID
+     */
+    get(projectId: string, mapId: string): Promise<Map>;
+    /**
+     * Updates a maps metadata
+     * @param projectId Project ID
+     * @param mapId Map ID
+     * @param options New metadata
+     */
+    update(projectId: string, mapId: string, options: {
+        description?: string;
+        callsign?: string;
+    }): Promise<void>;
+    /**
+     * Begins uploading a map from the agent
+     *
+     * @param projectId Project ID
+     * @param mapId Map ID
+     * @param callsign Robot callsign
+     * @param hash Map hash
+     */
+    sendToCloud(projectId: string, mapId: string, callsign: string, hash: string): Promise<void>;
+    /**
+     * Deletes a map from the cloud and all agents
+     * @param projectId
+     * @param mapId
+     */
+    delete(projectId: string, mapId: string): Promise<void>;
+    /**
+     * Deletes a map from a single agent.
+     *
+     * If the callsign does not have the map deployed, any local copy of the map will be deleted.
+     *
+     * @param projectId
+     * @param mapId
+     * @param callsign
+     * @param hash
+     */
+    delete(projectId: string, mapId: string, callsign: string, hash: string): Promise<void>;
+    /**
+     * Makes a copy of an uploaded map
+     *
+     * @param projectId Project ID
+     * @param mapId Map ID
+     * @param options Options to create the new map
+     */
+    copy(projectId: string, mapId: string, options: {
+        description?: string;
+    }): Promise<void>;
+    /** Deploy a map from the cloud to a robot
+     *
+     * @param projectId Project ID
+     * @param mapId Map ID
+     * @param callsign Robot callsign
+     */
+    deploy(projectId: string, mapId: string, callsign: string): Promise<void>;
+    /** Get a GeoJSON representation of a map
+     *
+     * @param projectId Project ID
+     * @param mapId Map ID
+     * @param frameId Frame ID (optional)
+     */
+    getGeoJSON(projectId: string, mapId: string, frameId?: string): Promise<unknown>;
+    /**
+     * 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: string, panoramaId: string): Promise<Observation[]>;
+    /**
+     * 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: string, panoramaId: string, observations: Observation[]): Promise<void>;
+    /**
+     * 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: string, key?: string, frameID?: string): Promise<Observation[]>;
+    /**
+     * 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: string): Promise<string[]>;
+}

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");
+/**
+ * Maps service for managing robot maps in the cloud and on robots
+ */
+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;