camstreamerlib 1.6.0 → 1.7.0

package/CameraVapix.js

@@ -0,0 +1,328 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CameraVapix = void 0;
+const WebSocket = require("ws");
+const prettifyXml = require("prettify-xml");
+const xml2js_1 = require("xml2js");
+const eventemitter2_1 = require("eventemitter2");
+const Digest_1 = require("./Digest");
+const RtspClient_1 = require("./RtspClient");
+const HTTPRequest_1 = require("./HTTPRequest");
+class CameraVapix extends eventemitter2_1.EventEmitter2 {
+    constructor(options) {
+        var _a, _b, _c, _d;
+        super();
+        this.rtsp = null;
+        this.ws = null;
+        this.protocol = (_a = options === null || options === void 0 ? void 0 : options.protocol) !== null && _a !== void 0 ? _a : 'html';
+        this.ip = (_b = options === null || options === void 0 ? void 0 : options.ip) !== null && _b !== void 0 ? _b : '127.0.0.1';
+        this.port = (_c = options === null || options === void 0 ? void 0 : options.port) !== null && _c !== void 0 ? _c : (this.protocol == 'http' ? 80 : 443);
+        this.auth = (_d = options === null || options === void 0 ? void 0 : options.auth) !== null && _d !== void 0 ? _d : '';
+    }
+    getParameterGroup(groupNames) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = (yield this.vapixGet(`/axis-cgi/param.cgi?action=list&group=${encodeURIComponent(groupNames)}`));
+            const params = {};
+            const lines = response.split(/[\r\n]/);
+            for (let i = 0; i < lines.length; i++) {
+                if (lines[i].length) {
+                    const p = lines[i].split('=');
+                    if (p.length >= 2) {
+                        params[p[0]] = p[1];
+                    }
+                }
+            }
+            return params;
+        });
+    }
+    setParameter(params) {
+        let postData = 'action=update&';
+        for (let key in params) {
+            postData += key + '=' + params[key] + '&';
+        }
+        postData = postData.slice(0, postData.length - 1);
+        return this.vapixPost('/axis-cgi/param.cgi', postData);
+    }
+    getPTZPresetList(channel) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = (yield this.vapixGet(`/axis-cgi/com/ptz.cgi?query=presetposcam&camera=${encodeURIComponent(channel)}`));
+            const positions = [];
+            const lines = response.split(/[\r\n]/);
+            for (let line of lines) {
+                if (line.length > 0 && line.indexOf('presetposno') != -1) {
+                    const p = line.split('=');
+                    if (p.length >= 2) {
+                        positions.push(p[1]);
+                    }
+                }
+            }
+            return positions;
+        });
+    }
+    goToPreset(channel, presetName) {
+        return this.vapixPost('/axis-cgi/com/ptz.cgi', `camera=${encodeURIComponent(channel)}&gotoserverpresetname=${encodeURIComponent(presetName)}`);
+    }
+    getGuardTourList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const gTourList = new Array();
+            const response = yield this.getParameterGroup('GuardTour');
+            for (let i = 0; i < 20; i++) {
+                const gTourBaseName = 'root.GuardTour.G' + i;
+                if (gTourBaseName + '.CamNbr' in response) {
+                    const gTour = {
+                        id: gTourBaseName,
+                        camNbr: response[gTourBaseName + '.CamNbr'],
+                        name: response[gTourBaseName + '.Name'],
+                        randomEnabled: response[gTourBaseName + '.RandomEnabled'],
+                        running: response[gTourBaseName + '.Running'],
+                        timeBetweenSequences: response[gTourBaseName + '.TimeBetweenSequences'],
+                        tour: [],
+                    };
+                    for (let j = 0; j < 100; j++) {
+                        const tourBaseName = 'root.GuardTour.G' + i + '.Tour.T' + j;
+                        if (tourBaseName + '.MoveSpeed' in response) {
+                            const tour = {
+                                moveSpeed: response[tourBaseName + '.MoveSpeed'],
+                                position: response[tourBaseName + '.Position'],
+                                presetNbr: response[tourBaseName + '.PresetNbr'],
+                                waitTime: response[tourBaseName + '.WaitTime'],
+                                waitTimeViewType: response[tourBaseName + '.WaitTimeViewType'],
+                            };
+                            gTour.tour.push(tour);
+                        }
+                    }
+                    gTourList.push(gTour);
+                }
+                else {
+                    break;
+                }
+            }
+            return gTourList;
+        });
+    }
+    setGuardTourEnabled(gourTourID, enable) {
+        const options = {};
+        options[gourTourID + '.Running'] = enable ? 'yes' : 'no';
+        return this.setParameter(options);
+    }
+    getInputState(port) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.vapixPost('/axis-cgi/io/port.cgi', `checkactive=${encodeURIComponent(port)}`);
+            return response.split('=')[1].indexOf('active') == 0;
+        });
+    }
+    setOutputState(port, active) {
+        return this.vapixPost('/axis-cgi/io/port.cgi', `action=${encodeURIComponent(port)}:${active ? '/' : '\\'}`);
+    }
+    getApplicationList() {
+        return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
+            const xml = (yield this.vapixGet('/axis-cgi/applications/list.cgi'));
+            (0, xml2js_1.parseString)(xml, (err, result) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                const apps = [];
+                for (let i = 0; i < result.reply.application.length; i++) {
+                    apps.push(result.reply.application[i].$);
+                }
+                resolve(apps);
+            });
+        }));
+    }
+    getEventDeclarations() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const data = '<s:Envelope xmlns:s="http://www.w3.org/2003/05/soap-envelope">' +
+                '<s:Body xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"' +
+                'xmlns:xsd="http://www.w3.org/2001/XMLSchema">' +
+                '<GetEventInstances xmlns="http://www.axis.com/vapix/ws/event1"/>' +
+                '</s:Body>' +
+                '</s:Envelope>';
+            const declarations = yield this.vapixPost('/vapix/services', data, 'application/soap+xml');
+            return prettifyXml(declarations);
+        });
+    }
+    isReservedEventName(eventName) {
+        return eventName == 'eventsConnect' || eventName == 'eventsDisconnect';
+    }
+    eventsConnect(channel = 'RTSP') {
+        if (this.ws != null) {
+            throw new Error('Websocket is already opened.');
+        }
+        if (this.rtsp != null) {
+            throw new Error('RTSP is already opened.');
+        }
+        if (channel == 'RTSP') {
+            this.rtspConnect();
+        }
+        else if (channel == 'websocket') {
+            this.websocketConnect();
+        }
+        else {
+            throw new Error('Unknown channel.');
+        }
+    }
+    eventsDisconnect() {
+        if (this.rtsp != null) {
+            this.rtsp.disconnect();
+        }
+        if (this.ws != null) {
+            this.ws.close();
+        }
+    }
+    rtspConnect() {
+        this.rtsp = new RtspClient_1.RtspClient({
+            ip: this.ip,
+            port: this.port,
+            auth: this.auth,
+        });
+        this.rtsp.on('connect', () => {
+            this.emit('eventsConnect');
+        });
+        this.rtsp.on('disconnect', (err) => {
+            this.emit('eventsDisconnect', new Error(err));
+            this.rtsp = null;
+        });
+        this.rtsp.on('event', (event) => {
+            const eventNames = this.eventNames();
+            for (let i = 0; i < eventNames.length; i++) {
+                if (!this.isReservedEventName(eventNames[i])) {
+                    let name = eventNames[i];
+                    while (name[name.length - 1] == '.' || name[name.length - 1] == '/') {
+                        name = name.substring(0, name.length - 1);
+                    }
+                    if (event.indexOf(name) != -1) {
+                        (0, xml2js_1.parseString)(event, (err, eventJson) => {
+                            if (err != null) {
+                                this.eventsDisconnect();
+                                return;
+                            }
+                            this.emit(eventNames[i], eventJson);
+                        });
+                        break;
+                    }
+                }
+            }
+        });
+        let eventTopicFilter = '';
+        const eventNames = this.eventNames();
+        for (let i = 0; i < eventNames.length; i++) {
+            if (!this.isReservedEventName(eventNames[i])) {
+                if (eventTopicFilter.length != 0) {
+                    eventTopicFilter += '|';
+                }
+                let topic = eventNames[i].replace(/tns1/g, 'onvif');
+                topic = topic.replace(/tnsaxis/g, 'axis');
+                eventTopicFilter += topic;
+            }
+        }
+        this.rtsp.connect(eventTopicFilter);
+    }
+    websocketConnect(digestHeader) {
+        var _a;
+        const address = `ws://${this.ip}:${this.port}/vapix/ws-data-stream?sources=events`;
+        const options = {
+            auth: this.auth,
+        };
+        if (digestHeader != undefined) {
+            const userPass = this.auth.split(':');
+            (_a = options['headers']) !== null && _a !== void 0 ? _a : (options['headers'] = {});
+            options['headers']['Authorization'] = Digest_1.Digest.getAuthHeader(userPass[0], userPass[1], 'GET', '/vapix/ws-data-stream?sources=events', digestHeader);
+        }
+        return new Promise((resolve, reject) => {
+            this.ws = new WebSocket(address, options);
+            this.ws.on('open', () => {
+                const topics = [];
+                const eventNames = this.eventNames();
+                for (let i = 0; i < eventNames.length; i++) {
+                    if (!this.isReservedEventName(eventNames[i])) {
+                        const topic = {
+                            topicFilter: eventNames[i],
+                        };
+                        topics.push(topic);
+                    }
+                }
+                const topicFilter = {
+                    apiVersion: '1.0',
+                    method: 'events:configure',
+                    params: {
+                        eventFilterList: topics,
+                    },
+                };
+                this.ws.send(JSON.stringify(topicFilter));
+            });
+            this.ws.on('unexpected-response', (req, res) => __awaiter(this, void 0, void 0, function* () {
+                if (res.statusCode == 401 && res.headers['www-authenticate'] != undefined)
+                    this.websocketConnect(res.headers['www-authenticate']).then(resolve, reject);
+                else {
+                    reject('Error: status code: ' + res.statusCode + ', ' + res.data);
+                }
+            }));
+            this.ws.on('message', (data) => {
+                const dataJSON = JSON.parse(data);
+                if (dataJSON.method === 'events:configure') {
+                    if (dataJSON.error === undefined) {
+                        this.emit('eventsConnect');
+                    }
+                    else {
+                        this.emit('eventsDisconnect', dataJSON.error);
+                        this.eventsDisconnect();
+                    }
+                    return;
+                }
+                const eventName = dataJSON.params.notification.topic;
+                this.emit(eventName, dataJSON);
+            });
+            this.ws.on('error', (error) => {
+                this.emit('eventsDisconnect', error);
+                this.ws = null;
+            });
+            this.ws.on('close', () => {
+                if (this.ws !== null) {
+                    this.emit('websocketDisconnect');
+                }
+                this.ws = null;
+            });
+        });
+    }
+    vapixGet(path, noWaitForData = false) {
+        const options = this.getBaseVapixConnectionParams();
+        options.path = encodeURI(path);
+        return (0, HTTPRequest_1.httpRequest)(options, undefined, noWaitForData);
+    }
+    getCameraImage(camera, compression, resolution, outputStream) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const path = `/axis-cgi/jpg/image.cgi?resolution=${resolution}&compression=${compression}&camera=${camera}`;
+            const res = (yield this.vapixGet(path, true));
+            res.pipe(outputStream);
+            return outputStream;
+        });
+    }
+    vapixPost(path, data, contentType) {
+        const options = this.getBaseVapixConnectionParams();
+        options.method = 'POST';
+        options.path = path;
+        if (contentType != null) {
+            options.headers = { 'Content-Type': contentType };
+        }
+        return (0, HTTPRequest_1.httpRequest)(options, data);
+    }
+    getBaseVapixConnectionParams() {
+        return {
+            protocol: this.protocol + ':',
+            host: this.ip,
+            port: this.port,
+            auth: this.auth,
+        };
+    }
+}
+exports.CameraVapix = CameraVapix;

package/CreatePackage.d.ts

@@ -0,0 +1 @@
+export {};

package/CreatePackage.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+const Path = require("path");
+const AdmZip = require("adm-zip");
+function isDirectory(path) {
+    const stat = fs.statSync(path);
+    return stat.isDirectory();
+}
+function createZipArchive(zip, folder, options) {
+    const files = fs.readdirSync(folder);
+    for (let file of files) {
+        const path = Path.join(folder, file);
+        const isDir = isDirectory(path);
+        if (file[0] == '.' ||
+            (file == 'node_modules' && !options.includeNodeModules) ||
+            (file == 'src' && options.typeScriptPackage)) {
+            continue;
+        }
+        else if (file == 'dist' && options.typeScriptPackage) {
+            zip.addLocalFolder(path);
+        }
+        else if (isDir) {
+            zip.addLocalFolder(path, file);
+        }
+        else {
+            zip.addLocalFile(path);
+        }
+    }
+}
+function main(args) {
+    const folder = Path.resolve('.');
+    const zipFile = Path.basename(folder) + '.zip';
+    const options = {
+        includeNodeModules: false,
+        typeScriptPackage: false,
+    };
+    for (let arg of args) {
+        if (arg == '-i' || arg == '-includeNodeModules') {
+            options.includeNodeModules = true;
+        }
+    }
+    if (fs.existsSync('dist')) {
+        options.typeScriptPackage = true;
+    }
+    if (fs.existsSync(zipFile)) {
+        try {
+            fs.unlinkSync(zipFile);
+        }
+        catch (error) {
+            console.log('An error occured: ', error);
+            process.exit(1);
+        }
+    }
+    const zip = new AdmZip();
+    createZipArchive(zip, folder, options);
+    zip.writeZip(zipFile);
+}
+main(process.argv.slice(2));

package/Digest.d.ts

@@ -0,0 +1,3 @@
+export declare class Digest {
+    static getAuthHeader(user: string, pass: string, method: string, uri: string, wwwAuthenticateHeader: string): string;
+}

package/{src/Digest.ts → Digest.js}

@@ -1,41 +1,39 @@
-import * as crypto from 'crypto';
-
-export class Digest {
-    static getAuthHeader(user: string, pass: string, method: string, uri: string, wwwAuthenticateHeader: string) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Digest = void 0;
+const crypto = require("crypto");
+class Digest {
+    static getAuthHeader(user, pass, method, uri, wwwAuthenticateHeader) {
         let digestItems = {};
         let digestArr = wwwAuthenticateHeader.substring(wwwAuthenticateHeader.indexOf('Digest') + 6).split(',');
-
         for (let i = 0; i < digestArr.length; i++) {
             let pos = digestArr[i].indexOf('=');
             let key = digestArr[i].substring(0, pos).trim();
             let value = digestArr[i].substring(pos + 1).trim();
             digestItems[key] = value.replace(/"/g, '');
         }
-
         let HA1 = crypto.createHash('md5').update(`${user}:${digestItems['realm']}:${pass}`).digest('hex');
         let HA2 = crypto.createHash('md5').update(`${method}:${uri}`).digest('hex');
-        let response: string;
+        let response;
         if (digestItems['qop'] != undefined) {
             response = crypto
                 .createHash('md5')
                 .update(`${HA1}:${digestItems['nonce']}:00000001:162d50aa594e9648:auth:${HA2}`)
                 .digest('hex');
-        } else {
+        }
+        else {
             response = crypto.createHash('md5').update(`${HA1}:${digestItems['nonce']}:${HA2}`).digest('hex');
         }
-
-        let header =
-            'Digest ' +
+        let header = 'Digest ' +
             `username="${user}",` +
             `realm="${digestItems['realm']}",` +
             `nonce="${digestItems['nonce']}",` +
             `uri="${uri}",` +
             `response="${response}"`;
-
         if (digestItems['qop'] != undefined) {
             header += ',qop=auth,nc=00000001,cnonce="162d50aa594e9648"';
         }
-
         return header;
     }
 }
+exports.Digest = Digest;

package/HTTPRequest.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import * as http from 'http';
+export declare type HttpRequestOptions = {
+    method?: string;
+    protocol?: string;
+    host: string;
+    port: number;
+    path?: string;
+    auth: string;
+    timeout?: number;
+    headers?: {
+        'Content-Type'?: string;
+    };
+};
+export declare function httpRequest(options: HttpRequestOptions, postData?: string, noWaitForData?: boolean): Promise<string | http.IncomingMessage>;

package/HTTPRequest.js

@@ -0,0 +1,84 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.httpRequest = void 0;
+const http = require("http");
+const https = require("https");
+const Digest_1 = require("./Digest");
+function httpRequest(options, postData, noWaitForData = false) {
+    var _a, _b;
+    var _c;
+    return __awaiter(this, void 0, void 0, function* () {
+        if (postData !== undefined) {
+            (_a = options.headers) !== null && _a !== void 0 ? _a : (options.headers = {});
+            (_b = (_c = options.headers)['Content-Type']) !== null && _b !== void 0 ? _b : (_c['Content-Type'] = 'application/x-www-form-urlencoded');
+            options.headers['Content-Length'] = Buffer.byteLength(postData);
+        }
+        let response = yield request(options, postData, undefined, noWaitForData);
+        if (response.resp.statusCode == 200) {
+            return noWaitForData ? response.resp : response.data;
+        }
+        else if (response.resp.statusCode == 401) {
+            if (response.resp.headers['www-authenticate'] != undefined &&
+                response.resp.headers['www-authenticate'].indexOf('Digest') != -1) {
+                response = yield request(options, postData, response.resp.headers['www-authenticate'], noWaitForData);
+                if (response.resp.statusCode == 200) {
+                    return noWaitForData ? response.resp : response.data;
+                }
+            }
+        }
+        if (noWaitForData) {
+            throw new Error(`Error: status code: ${response.resp.statusCode}`);
+        }
+        else {
+            throw new Error(`Error: status code: ${response.resp.statusCode}, ${response.data}`);
+        }
+    });
+}
+exports.httpRequest = httpRequest;
+function request(options, postData, digestHeader, noWaitForData) {
+    return new Promise((resolve, reject) => {
+        var _a, _b;
+        if (digestHeader != undefined) {
+            if (options.auth == undefined) {
+                reject('No credentials found');
+            }
+            const auth = options.auth.split(':');
+            delete options.auth;
+            (_a = options.method) !== null && _a !== void 0 ? _a : (options.method = 'GET');
+            (_b = options.headers) !== null && _b !== void 0 ? _b : (options.headers = {});
+            options['headers']['Authorization'] = Digest_1.Digest.getAuthHeader(auth[0], auth[1], options.method, options.path, digestHeader);
+        }
+        let client = options.protocol === 'https:' ? https : http;
+        let req = client
+            .request(options, (resp) => {
+            if (!noWaitForData) {
+                let data = '';
+                resp.on('data', (chunk) => {
+                    data += chunk;
+                });
+                resp.on('end', () => {
+                    resolve({ resp: resp, data: data });
+                });
+            }
+            else {
+                resolve({ resp: resp });
+            }
+        })
+            .on('error', (err) => {
+            reject(err);
+        });
+        if (postData != undefined) {
+            req.write(postData);
+        }
+        req.end();
+    });
+}

package/HttpServer.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import * as http from 'http';
+import * as EventEmitter from 'events';
+export declare type HttpServerOptions = {
+    port?: number;
+};
+declare type OnRequestCallback = (req: http.IncomingMessage, res: http.ServerResponse) => void;
+export declare class HttpServer extends EventEmitter {
+    private port;
+    private registeredPaths;
+    private server;
+    private sockets;
+    constructor(options?: HttpServerOptions);
+    onRequest(path: string, callback: OnRequestCallback): void;
+    close(): void;
+}
+export {};