@dronedeploy/rocos-js-sdk 0.0.1 → 2.6.1

package/api/streams/command/CommandStreamNode.d.ts

@@ -0,0 +1,12 @@
+import { CommandRequest } from '../../../grpc/rambo/rambo.v1_pb';
+import { Observable } from 'rxjs';
+import { CommandStreamAbstract } from './CommandStreamAbstract';
+import { ICommandParams } from '../../../models/params/ICommandParams';
+import { IRocosCommandMessage } from '../../../models/message/IRocosCommandMessage';
+import { IStreamConfig } from '../../../models/IStreamConfig';
+export declare class CommandStreamNode extends CommandStreamAbstract {
+    private client;
+    constructor(config: IStreamConfig);
+    protected callStream(request: CommandRequest, params: ICommandParams): Observable<IRocosCommandMessage>;
+    private getMetadata;
+}

package/api/streams/command/CommandStreamNode.js

@@ -0,0 +1,93 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandStreamNode = void 0;
+const grpc = __importStar(require("@grpc/grpc-js"));
+const rxjs_1 = require("rxjs");
+const rambo_v1_grpc_pb_1 = require("../../../grpc/rambo/rambo.v1_grpc_pb");
+const CommandStreamAbstract_1 = require("./CommandStreamAbstract");
+const RocosCommandMessage_1 = require("../../../models/message/RocosCommandMessage");
+const RocosLogger_1 = require("../../../logger/RocosLogger");
+const SubscriberStatusEnum_1 = require("../../../models/SubscriberStatusEnum");
+class CommandStreamNode extends CommandStreamAbstract_1.CommandStreamAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`CommandStreamNode(${this.identifier})`);
+        const port = config.port || 443;
+        const credentials = config.insecure ? grpc.credentials.createInsecure() : grpc.credentials.createSsl();
+        this.client = new rambo_v1_grpc_pb_1.CommandClient(`${this.url}:${port}`, credentials);
+    }
+    callStream(request, params) {
+        const metadata = this.getMetadata(params.projectId, params.callsign);
+        let call;
+        return new rxjs_1.Observable((emitter) => {
+            call = this.client.callCommand(request, metadata);
+            this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.ALIVE;
+            this.statusStream$.next(this.subscriberStatus);
+            call.on('data', (update) => {
+                const message = RocosCommandMessage_1.RocosCommandMessage.fromModel(update);
+                emitter.next(message);
+                this.logger.debug('invokeRequest - on(data)', {
+                    message,
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    commandId: params.commandId,
+                });
+            });
+            call.on('end', () => {
+                this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug('invokeRequest - on(end)', {
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    commandId: params.commandId,
+                });
+                emitter.complete();
+            });
+            call.on('close', () => {
+                this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug('invokeRequest - on(close)');
+            });
+            call.on('error', (error) => {
+                this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.ERROR;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug('invokeRequest - on(error)', error);
+                emitter.error(error);
+            });
+            return () => {
+                this.logger.debug('unsubscribing commandStream');
+                call.cancel();
+            };
+        });
+    }
+    getMetadata(projectId, callsign, subsystem) {
+        const meta = new grpc.Metadata();
+        meta.add('authorization', this.token);
+        meta.add('r-p', projectId);
+        meta.add('r-cs', callsign);
+        if (subsystem) {
+            meta.add('r-s', subsystem);
+        }
+        return meta;
+    }
+}
+exports.CommandStreamNode = CommandStreamNode;

package/api/streams/control/ControlStream.d.ts

@@ -0,0 +1,14 @@
+import { ControlMessage } from '../../../grpc/robot-control/conker_pb';
+import { Observable } from 'rxjs';
+import { ControlStreamAbstract } from './ControlStreamAbstract';
+import { IControlParams } from '../../../models/params/IControlParams';
+import { IRocosControlMessage } from '../../../models/message/IRocosControlMessage';
+import { IStreamConfig } from '../../../models/IStreamConfig';
+export declare class ControlStream extends ControlStreamAbstract {
+    private client;
+    constructor(config: IStreamConfig);
+    protected controlRobotCall(request: ControlMessage, params: IControlParams): void;
+    protected controlRobotCallWithAckStream(request: ControlMessage, params: IControlParams): Observable<IRocosControlMessage>;
+    protected setPayload(request: ControlMessage, payload: string): void;
+    private getMetadata;
+}

package/api/streams/control/ControlStream.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControlStream = void 0;
+const rxjs_1 = require("rxjs");
+const conker_pb_service_1 = require("../../../grpc/robot-control/conker_pb_service");
+const ControlStreamAbstract_1 = require("./ControlStreamAbstract");
+const RocosControlMessage_1 = require("../../../models/message/RocosControlMessage");
+const RocosLogger_1 = require("../../../logger/RocosLogger");
+const SubscriberStatusEnum_1 = require("../../../models/SubscriberStatusEnum");
+const grpc_web_1 = require("@improbable-eng/grpc-web");
+const stringToUint8Array_1 = require("../../../helpers/stringToUint8Array");
+class ControlStream extends ControlStreamAbstract_1.ControlStreamAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`ControlStream(${this.identifier})`);
+        const protocol = config.insecure ? 'http' : 'https';
+        this.client = new conker_pb_service_1.RobotControlClient(`${protocol}://${this.url}`);
+    }
+    controlRobotCall(request, params) {
+        const metadata = this.getMetadata(params.projectId, params.callsign);
+        this.client.controlRobotCall(request, metadata, (err, ack) => {
+            return null;
+        });
+    }
+    controlRobotCallWithAckStream(request, params) {
+        const metadata = this.getMetadata(params.projectId, params.callsign);
+        let call;
+        return new rxjs_1.Observable((emitter) => {
+            // Send the message to back-end.
+            call = this.client.controlRobotCallWithAckStream(request, metadata);
+            this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.ALIVE;
+            this.statusStream$.next(this.subscriberStatus);
+            call.on('data', (update) => {
+                const message = RocosControlMessage_1.RocosControlMessage.fromMessage(update);
+                emitter.next(message);
+                this.logger.debug('controlRobotCallWithAckStream - on(data)', {
+                    message,
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    destination: params.destination,
+                });
+            });
+            call.on('end', () => {
+                this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug('controlRobotCallWithAckStream - on(end)', {
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    destination: params.destination,
+                });
+                emitter.complete();
+            });
+            call.on('status', (status) => {
+                this.logger.debug('controlRobotCallWithAckStream- on(status)', {
+                    status,
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    destination: params.destination,
+                });
+                if (status.code !== grpc_web_1.grpc.Code.OK) {
+                    emitter.error({ details: status.details, code: status.code });
+                }
+            });
+            return () => {
+                this.logger.debug('unsubscribing controlRobotCallWithAckStream');
+                call.cancel();
+            };
+        });
+    }
+    setPayload(request, payload) {
+        request.setPayload(stringToUint8Array_1.stringToUint8Array(payload));
+    }
+    getMetadata(projectId, callsign) {
+        return {
+            'authorization': this.token,
+            'r-p': projectId,
+            'r-cs': callsign,
+        };
+    }
+}
+exports.ControlStream = ControlStream;

package/api/streams/control/ControlStreamAbstract.d.ts

@@ -0,0 +1,28 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { ControlActionType, IControlParams } from '../../../models/params/IControlParams';
+import { ControlMessage } from '../../../grpc/robot-control/conker_pb';
+import { IControlStream } from '../../../models/stream/IControlStream';
+import { IRocosControlMessage } from '../../../models/message/IRocosControlMessage';
+import { IStreamConfig } from '../../../models/IStreamConfig';
+import { Logger } from 'loglevel';
+import { SubscriberStatusEnum } from '../../../models/SubscriberStatusEnum';
+export declare abstract class ControlStreamAbstract implements IControlStream {
+    identifier: string;
+    statusStream$: BehaviorSubject<SubscriberStatusEnum>;
+    protected token: string;
+    private scope;
+    protected url: string;
+    protected subscriberStatus: SubscriberStatusEnum;
+    protected logger: Logger;
+    constructor(config: IStreamConfig);
+    protected abstract controlRobotCall(request: ControlMessage, params: IControlParams): void;
+    protected abstract controlRobotCallWithAckStream(request: ControlMessage, params: IControlParams): Observable<IRocosControlMessage>;
+    protected abstract setPayload(request: ControlMessage, payload: string): void;
+    setToken(token: string): void;
+    stopStream(): void;
+    takeActionWithAck(action: ControlActionType, params: IControlParams, ackTimeoutInSeconds?: number): Observable<string>;
+    sendCommand(params: IControlParams): void;
+    sendCommandWithAck(params: IControlParams): Observable<IRocosControlMessage>;
+    private sendCommandToRobot;
+    private setRequestMeta;
+}

package/api/streams/control/ControlStreamAbstract.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControlStreamAbstract = void 0;
+const rxjs_1 = require("rxjs");
+const conker_pb_1 = require("../../../grpc/robot-control/conker_pb");
+const identifier_1 = require("../../../constants/identifier");
+const RocosStore_1 = require("../../../store/RocosStore");
+const StreamRegister_1 = require("../../StreamRegister");
+const SubscriberStatusEnum_1 = require("../../../models/SubscriberStatusEnum");
+const operators_1 = require("rxjs/operators");
+class ControlStreamAbstract {
+    constructor(config) {
+        this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED;
+        this.scope = config.scope;
+        this.identifier = StreamRegister_1.StreamRegister.getIdentifier(identifier_1.IDENTIFIER_NAME_CONTROL, this.scope);
+        this.token = config.token;
+        this.url = config.url;
+        this.statusStream$ = new rxjs_1.BehaviorSubject(SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED);
+        RocosStore_1.RocosStore.getChangeSubject()
+            .pipe(operators_1.filter((message) => {
+            return message.type === 'token' && message.url === this.url;
+        }))
+            .subscribe((msg) => {
+            this.token = msg.data;
+        });
+    }
+    setToken(token) {
+        this.token = token;
+    }
+    stopStream() {
+        // do nothing for now
+    }
+    takeActionWithAck(action, params, ackTimeoutInSeconds = 15) {
+        return new rxjs_1.Observable((emitter) => {
+            if (action && params) {
+                switch (action) {
+                    case 'rosbridge-control':
+                        if (!params.projectId || !params.callsign) {
+                            emitter.error(new Error('Cannot find the type or metadata.'));
+                            emitter.complete();
+                        }
+                        else {
+                            const timer = setTimeout(() => {
+                                emitter.error(new Error(`Timeout (${ackTimeoutInSeconds} seconds).`));
+                                emitter.complete();
+                                clearTimeout(timer);
+                            }, ackTimeoutInSeconds * 1000);
+                            this.sendCommandWithAck(params).subscribe((msg) => {
+                                const { message } = msg;
+                                if (msg.stage === 'final') {
+                                    if (msg.success) {
+                                        emitter.next(`${message}`);
+                                        emitter.complete();
+                                    }
+                                    else {
+                                        emitter.error(new Error('Failed!'));
+                                        emitter.complete();
+                                    }
+                                }
+                                clearTimeout(timer);
+                            }, (err) => {
+                                emitter.error(err);
+                                emitter.complete();
+                            });
+                        }
+                        break;
+                    default:
+                        emitter.error(new Error(`Cannot handle this type: ${action}.`));
+                        emitter.complete();
+                        break;
+                }
+            }
+            else {
+                emitter.error(new Error('Cannot find the type or metadata.'));
+                emitter.complete();
+            }
+        });
+    }
+    sendCommand(params) {
+        this.sendCommandToRobot(params);
+    }
+    sendCommandWithAck(params) {
+        const request = new conker_pb_1.ControlMessage();
+        this.setPayload(request, params.payload);
+        request.setDestination(params.destination);
+        this.setRequestMeta(request, params.meta);
+        return this.controlRobotCallWithAckStream(request, params);
+    }
+    sendCommandToRobot(params) {
+        // Compose the request message
+        const request = new conker_pb_1.ControlMessage();
+        request.setDestination(params.destination);
+        this.setPayload(request, params.payload);
+        this.setRequestMeta(request, params.meta);
+        // Send the message to back-end.
+        this.controlRobotCall(request, params);
+    }
+    setRequestMeta(request, meta) {
+        if (meta) {
+            Object.keys(meta).forEach((item) => {
+                if ((meta === null || meta === void 0 ? void 0 : meta[item]) !== undefined) {
+                    request.getMetaMap().set(item, meta[item]);
+                }
+            });
+        }
+    }
+}
+exports.ControlStreamAbstract = ControlStreamAbstract;

package/api/streams/control/ControlStreamNode.d.ts

@@ -0,0 +1,14 @@
+import { ControlMessage } from '../../../grpc/robot-control/conker_pb';
+import { Observable } from 'rxjs';
+import { ControlStreamAbstract } from './ControlStreamAbstract';
+import { IControlParams } from '../../../models/params/IControlParams';
+import { IRocosControlMessage } from '../../../models/message/IRocosControlMessage';
+import { IStreamConfig } from '../../../models/IStreamConfig';
+export declare class ControlStreamNode extends ControlStreamAbstract {
+    private client;
+    constructor(config: IStreamConfig);
+    protected controlRobotCall(request: ControlMessage, params: IControlParams): void;
+    protected controlRobotCallWithAckStream(request: ControlMessage, params: IControlParams): Observable<IRocosControlMessage>;
+    protected setPayload(request: ControlMessage, payload: string): void;
+    private getMetadata;
+}

package/api/streams/control/ControlStreamNode.js

@@ -0,0 +1,98 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControlStreamNode = void 0;
+const grpc = __importStar(require("@grpc/grpc-js"));
+const rxjs_1 = require("rxjs");
+const ControlStreamAbstract_1 = require("./ControlStreamAbstract");
+const conker_grpc_pb_1 = require("../../../grpc/robot-control/conker_grpc_pb");
+const RocosControlMessage_1 = require("../../../models/message/RocosControlMessage");
+const RocosLogger_1 = require("../../../logger/RocosLogger");
+const SubscriberStatusEnum_1 = require("../../../models/SubscriberStatusEnum");
+class ControlStreamNode extends ControlStreamAbstract_1.ControlStreamAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`ControlStreamNode(${this.identifier})`);
+        const port = config.port || 443;
+        const credentials = config.insecure ? grpc.credentials.createInsecure() : grpc.credentials.createSsl();
+        this.client = new conker_grpc_pb_1.RobotControlClient(`${this.url}:${port}`, credentials);
+    }
+    controlRobotCall(request, params) {
+        const metadata = this.getMetadata(params.projectId, params.callsign);
+        this.client.controlRobotCall(request, metadata, (err, ack) => {
+            return null;
+        });
+    }
+    controlRobotCallWithAckStream(request, params) {
+        const metadata = this.getMetadata(params.projectId, params.callsign);
+        let call;
+        return new rxjs_1.Observable((emitter) => {
+            call = this.client.controlRobotCallWithAckStream(request, metadata);
+            this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.ALIVE;
+            this.statusStream$.next(this.subscriberStatus);
+            call.on('data', (update) => {
+                const message = RocosControlMessage_1.RocosControlMessage.fromMessage(update);
+                emitter.next(message);
+                this.logger.debug('controlRobotCallWithAckStream - on(data)', {
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    destination: params.destination,
+                });
+            });
+            call.on('end', () => {
+                this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug('controlRobotCallWithAckStream - on(end)', {
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                    destination: params.destination,
+                });
+                emitter.complete();
+            });
+            call.on('close', () => {
+                this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug('controlRobotCallWithAckStream - on(close)');
+            });
+            call.on('error', (error) => {
+                this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.ERROR;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug('controlRobotCallWithAckStream - on(error)', error);
+                emitter.error(error);
+            });
+            return () => {
+                this.logger.debug('unsubscribing controlRobotCallWithAckStream');
+                call.cancel();
+            };
+        });
+    }
+    setPayload(request, payload) {
+        request.setPayload(Buffer.from(payload).toString('base64'));
+    }
+    getMetadata(projectId, callsign) {
+        const meta = new grpc.Metadata();
+        meta.add('authorization', this.token);
+        meta.add('r-p', projectId);
+        meta.add('r-cs', callsign);
+        return meta;
+    }
+}
+exports.ControlStreamNode = ControlStreamNode;

package/api/streams/fileAccessor/FileAccessorStream.d.ts

@@ -0,0 +1,10 @@
+import { FileAccessorStreamAbstract } from './FileAccessorStreamAbstract';
+import { IFileAccessorReqOpParams } from '../../../models/params/IFileAccessorParams';
+import { IRocosOpResultMessage } from '../../../models/message/IRocosOpResultMessage';
+import { IStreamConfig } from '../../../models/IStreamConfig';
+export declare class FileAccessorStream extends FileAccessorStreamAbstract {
+    private client;
+    constructor(config: IStreamConfig);
+    serverReqOpInternal(params: IFileAccessorReqOpParams): Promise<IRocosOpResultMessage[]>;
+    private getMetadata;
+}

package/api/streams/fileAccessor/FileAccessorStream.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileAccessorStream = void 0;
+const filagree_pb_1 = require("../../../grpc/file-accessor/filagree_pb");
+const filagree_pb_service_1 = require("../../../grpc/file-accessor/filagree_pb_service");
+const FileAccessorStreamAbstract_1 = require("./FileAccessorStreamAbstract");
+const FileEnums_1 = require("../../../models/file/FileEnums");
+const RocosLogger_1 = require("../../../logger/RocosLogger");
+const RocosOpResultMessage_1 = require("../../../models/message/RocosOpResultMessage");
+const SubscriberStatusEnum_1 = require("../../../models/SubscriberStatusEnum");
+class FileAccessorStream extends FileAccessorStreamAbstract_1.FileAccessorStreamAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`FileAccessorStream(${this.identifier})`);
+        const protocol = config.insecure ? 'http' : 'https';
+        this.client = new filagree_pb_service_1.FilagreeClient(`${protocol}://${this.url}`);
+    }
+    serverReqOpInternal(params) {
+        return new Promise((resolve, reject) => {
+            this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.ALIVE;
+            this.statusStream$.next(this.subscriberStatus);
+            this.logger.debug('serverReqOp - request', {
+                status: this.subscriberStatus,
+                projectId: params.projectId,
+                callsign: params.callsign,
+            });
+            const req = new filagree_pb_1.OpRequest();
+            req.setOpcode(params.opCode);
+            req.setPath(params.path);
+            req.setTarget(params.target || FileEnums_1.OpRequestTarget.AGENT);
+            // Set map values
+            if (params.args) {
+                Object.keys(params.args).forEach((key) => {
+                    var _a;
+                    if ((_a = params === null || params === void 0 ? void 0 : params.args) === null || _a === void 0 ? void 0 : _a[key]) {
+                        req.getArgsMap().set(key, params.args[key]);
+                    }
+                });
+            }
+            const reqs = new filagree_pb_1.OpRequests();
+            reqs.setRequestsList([req]);
+            const metadata = this.getMetadata(params.projectId, params.callsign);
+            this.client.serverReqOp(reqs, metadata, (err, data) => {
+                if (err) {
+                    reject(err);
+                }
+                else if (data) {
+                    resolve(RocosOpResultMessage_1.RocosOpResultMessage.fromMessages(data));
+                }
+                else {
+                    reject('Error in serverReqOp call');
+                }
+                this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED;
+                this.statusStream$.next(this.subscriberStatus);
+                this.logger.debug('serverReqOp - response', {
+                    status: this.subscriberStatus,
+                    projectId: params.projectId,
+                    callsign: params.callsign,
+                });
+            });
+        });
+    }
+    getMetadata(projectId, callsign) {
+        const result = { authorization: this.token };
+        if (projectId) {
+            result['r-p'] = projectId;
+        }
+        if (callsign) {
+            result['r-cs'] = callsign;
+        }
+        return result;
+    }
+}
+exports.FileAccessorStream = FileAccessorStream;

package/api/streams/fileAccessor/FileAccessorStreamAbstract.d.ts

@@ -0,0 +1,26 @@
+import { IFileAccessorParams, IFileAccessorReqOpParams } from '../../../models/params/IFileAccessorParams';
+import { BehaviorSubject } from 'rxjs';
+import { IFileAccessorStream } from '../../../models/stream/IFileAccessorStream';
+import { IRocosOpResultMessage } from '../../../models/message/IRocosOpResultMessage';
+import { IStreamConfig } from '../../../models/IStreamConfig';
+import { Logger } from 'loglevel';
+import { SubscriberStatusEnum } from '../../../models/SubscriberStatusEnum';
+export declare abstract class FileAccessorStreamAbstract implements IFileAccessorStream {
+    identifier: string;
+    statusStream$: BehaviorSubject<SubscriberStatusEnum>;
+    protected token: string;
+    private scope;
+    protected url: string;
+    protected subscriberStatus: SubscriberStatusEnum;
+    protected logger: Logger;
+    constructor(config: IStreamConfig);
+    protected abstract serverReqOpInternal(params: IFileAccessorReqOpParams): Promise<IRocosOpResultMessage[]>;
+    setToken(token: string): void;
+    stopStream(): void;
+    serverReqOp(params: IFileAccessorReqOpParams): Promise<IRocosOpResultMessage[]>;
+    listFolder(params: IFileAccessorParams): Promise<IRocosOpResultMessage[]>;
+    downloadFile(params: IFileAccessorParams): Promise<IRocosOpResultMessage[]>;
+    getDownloadFileLinkByUsingBlob(params: IFileAccessorParams): Promise<any>;
+    uploadFile(params: IFileAccessorParams, file: File): Promise<any>;
+    private getPathForBlobSas;
+}

package/api/streams/fileAccessor/FileAccessorStreamAbstract.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileAccessorStreamAbstract = void 0;
+const FileEnums_1 = require("../../../models/file/FileEnums");
+// import { BlockBlobClient } from '@azure/storage-blob'
+const rxjs_1 = require("rxjs");
+const identifier_1 = require("../../../constants/identifier");
+const RocosStore_1 = require("../../../store/RocosStore");
+const StreamRegister_1 = require("../../StreamRegister");
+const SubscriberStatusEnum_1 = require("../../../models/SubscriberStatusEnum");
+const operators_1 = require("rxjs/operators");
+class FileAccessorStreamAbstract {
+    constructor(config) {
+        this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED;
+        this.scope = config.scope;
+        this.identifier = StreamRegister_1.StreamRegister.getIdentifier(identifier_1.IDENTIFIER_NAME_FILE_ACCESSOR, this.scope);
+        this.token = config.token;
+        this.url = config.url;
+        this.statusStream$ = new rxjs_1.BehaviorSubject(SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED);
+        RocosStore_1.RocosStore.getChangeSubject()
+            .pipe(operators_1.filter((message) => {
+            return message.type === 'token' && message.url === this.url;
+        }))
+            .subscribe((msg) => {
+            this.token = msg.data;
+        });
+    }
+    setToken(token) {
+        this.token = token;
+    }
+    stopStream() {
+        // do nothing for now
+    }
+    async serverReqOp(params) {
+        return this.serverReqOpInternal(params);
+    }
+    async listFolder(params) {
+        return this.serverReqOp(Object.assign(Object.assign({}, params), { opCode: FileEnums_1.OpCode.INFO }));
+    }
+    async downloadFile(params) {
+        return this.serverReqOp(Object.assign(Object.assign({}, params), { opCode: FileEnums_1.OpCode.READFILE }));
+    }
+    async getDownloadFileLinkByUsingBlob(params) {
+        const pathForBlobSas = this.getPathForBlobSas(params.projectId, params.callsign, params.path);
+        const msgs = await this.serverReqOp(Object.assign(Object.assign({}, params), { path: pathForBlobSas, opCode: FileEnums_1.OpCode.READFILE, target: FileEnums_1.OpRequestTarget.SERVER }));
+        if (msgs && msgs.length > 0) {
+            const [{ data: url }] = msgs;
+            if (url) {
+                return this.serverReqOp(Object.assign(Object.assign({}, params), { opCode: FileEnums_1.OpCode.BLOBPUT, target: FileEnums_1.OpRequestTarget.AGENT, args: { url } }));
+            }
+            throw new Error('Could not create SAS');
+        }
+        else {
+            throw new Error('Could not create SAS');
+        }
+    }
+    async uploadFile(params, file) {
+        const pathForBlobSas = this.getPathForBlobSas(params.projectId, params.callsign, params.path);
+        const msgs = await this.serverReqOp(Object.assign(Object.assign({}, params), { path: pathForBlobSas, opCode: FileEnums_1.OpCode.BLOBSAS, target: FileEnums_1.OpRequestTarget.SERVER }));
+        if (msgs && msgs.length > 0) {
+            // TODO(matej): implement file upload using azure blob
+            // const [{ data: url }] = msgs
+            //
+            // if (url) {
+            //   const client = new BlockBlobClient(url)
+            //   return from(client.uploadBrowserData(file)).pipe(
+            //     mergeMap((res) => {
+            //       return this.serverReqOp(projectId, callsign, path, OpCode.BLOBGET, OpRequest.Target.AGENT, {
+            //         url,
+            //       })
+            //     }),
+            //   )
+            // }
+            throw new Error('Could not create SAS');
+        }
+        throw new Error('Could not create SAS');
+    }
+    getPathForBlobSas(projectId, callsign, path) {
+        return `/${callsign}${path}`;
+    }
+}
+exports.FileAccessorStreamAbstract = FileAccessorStreamAbstract;

package/api/streams/fileAccessor/FileAccessorStreamNode.d.ts

@@ -0,0 +1,10 @@
+import { FileAccessorStreamAbstract } from './FileAccessorStreamAbstract';
+import { IFileAccessorReqOpParams } from '../../../models/params/IFileAccessorParams';
+import { IRocosOpResultMessage } from '../../../models/message/IRocosOpResultMessage';
+import { IStreamConfig } from '../../../models/IStreamConfig';
+export declare class FileAccessorStreamNode extends FileAccessorStreamAbstract {
+    private client;
+    constructor(config: IStreamConfig);
+    serverReqOpInternal(params: IFileAccessorReqOpParams): Promise<IRocosOpResultMessage[]>;
+    private getMetadata;
+}