init

app/camera/camera.controller.js

@@ -0,0 +1,58 @@
+/*jshint esversion: 6 */
+const path = require('path');
+const express = require('express');
+const router = express.Router();
+const cameraService = require(path.resolve(__dirname, './camera.service'));
+
+router.post('/create', _create);
+router.get('/cameras', getAll);
+router.get('/', getById);
+router.put('/', update);
+router.delete('/', _delete);
+router.post('/osd', _osd);
+router.post('/stream', _stream);
+
+module.exports = router;
+
+function _create(req, res, next) {
+    cameraService.create(req.body)
+        .then((camera) => res.json(camera))
+        .catch(err => next(err));
+}
+
+function update(req, res, next) {
+    cameraService.update(req.body.id)
+        .then((camera) => res.json(camera))
+        .catch(err => next(err));
+}
+
+function getAll(req, res, next) {
+    cameraService.getAll()
+        .then((cameras) => res.json(cameras))
+        .catch(err => next(err));
+}
+
+function getById(req, res, next) {
+    cameraService.getById(req.body.id)
+        .then((camera) => res.json(camera))
+        .catch(err => next(err));
+}
+
+function _delete(req, res, next) {
+    cameraService.delete(req.body.id)
+        .then((id) => res.json(id))
+        .catch(err => next(err));
+}
+
+function _osd(req, res, next) {
+    cameraService.osd(req.body)
+        .then((socket) => res.json(socket))
+        .catch(err => next(err));
+}
+
+function _stream(req, res, next) {
+    console.log("Stream Requester ip: " + req.ip);
+    cameraService.stream(req.body)
+        .then((streamPort) => res.json(streamPort))
+        .catch(err => next(err));
+}

app/camera/camera.model.js

@@ -0,0 +1,30 @@
+/*jshint esversion: 6 */
+
+const mongoose = require('mongoose');
+const Schema = mongoose.Schema;
+
+const schema = new Schema({
+    _id: Schema.Types.ObjectId,
+    ip: {type: String, unique: true, required: true},
+    port: {type: String, required: true},
+    rtsp: {type: String, required: true},
+    model: {type: String, required: true},
+    serial: {type: String, required: true},
+    name: {type: String, unique: true},
+    streamPort: {type: Number, unique: true},
+    presets: [
+        {
+            memNum: {type: Number, max: 127},
+            name: {type: String},
+            location: {
+                pan: {type: String},
+                tilt: {type: String},
+                focus: {type: String},
+                zoom: {type: String}
+            }
+        }
+    ]
+});
+
+schema.set('toJson', {virtuals: true});
+module.exports = mongoose.model('Camera', schema);

app/camera/camera.service.js

@@ -0,0 +1,127 @@
+/*jshint esversion: 6 */
+const path = require('path');
+const Stream = require('../stream/videoStream');
+const db = require(path.resolve(__dirname, '../_helpers/db.js'));
+const mongoose = require('mongoose');
+const cameraHelper = require(path.resolve(__dirname, '../_helpers/cameraHelper.js'));
+const socket = require(path.resolve(__dirname, '../_helpers/socket.js'));
+const Camera = db.Camera;
+
+module.exports = {
+    create: _create,
+    getAll: _getAll,
+    getById: _getById,
+    update: _update,
+    delete: _delete,
+    osd: _osd,
+    stream: _stream
+};
+
+async function _getAll() {
+    try {
+        return await Camera.find().lean();
+    } catch(err) {
+        throw err;
+    }
+}
+
+async function _getById(id) {
+    try {
+        return await Camera.findById(id).lean();
+    } catch(err) {
+        throw err;
+    }
+}
+
+async function _create(cameraParams) {
+    if (await Camera.findOne({ip: cameraParams.ip})) {
+        throw 'There is already a camera with ip ' + cameraParams.ip;
+    } else {
+        const modelSerialArr = await cameraHelper.getDeviceModel(cameraParams.ip);
+        const camId = new mongoose.Types.ObjectId();
+        const streamPort = await cameraHelper.createNewCameraStreamPort();
+        return new Camera({
+            ...cameraParams,
+            _id: camId,
+            model: modelSerialArr[0],
+            serial: modelSerialArr[1],
+            streamPort: streamPort
+        })
+        .save()
+        .then((camera) => {
+            return camera.toObject();
+        }).catch((err) => {
+            throw err;
+        });
+    }
+}
+
+async function _update(cameraParams) {
+    try {
+        return await Camera.findByIdAndUpdate(cameraParams._id, cameraParams, {new: true}).save();
+    } catch(err) {
+        throw err;
+    }
+}
+
+async function _delete(id) {
+    try {
+        return await Camera.findOneAndDelete(id);
+    } catch(err) {
+        throw err;
+    }
+}
+
+async function _osd({id, option}) {
+    let osdHex = "8101";
+    switch(option.toLowerCase()) {
+        case "openToggle":
+            osdHex += "043F025FFF";
+            break;
+        case "up":
+            osdHex += "06010E0E0301FF";
+            break;
+        case "down":
+            osdHex += "06010E0E0302FF";
+            break;
+        case "left":
+            osdHex += "06010E0E0103FF";
+            break;
+        case "right":
+            osdHex += "06010E0E0203FF";
+            break;
+        case "enter":
+            osdHex += "060605FF";
+            break;
+        case "return":
+            osdHex += "060604FF";
+            break;
+        default:
+            throw "The OSD option " + option + " is not a recognizable OSD option.";
+    }
+    return await socket.sendCmd(id, osdHex);
+}
+
+async function _stream({id, width = 1920, height = 1080}) {
+    const camera = await Camera.findById(id).lean();
+
+    // In case a seperate user wants to reach same camera stream
+    let inUse;
+    try {
+        inUse = await cameraHelper.checkPortUse(camera.streamPort);
+    } catch(err) {
+        throw err;
+    }
+
+    if (!inUse) {
+        const stream = new Stream({
+            name: camera.name || "stream: " + camera.rtsp,
+            url: 'rtsp://' + camera.rtsp,
+            port: camera.streamPort,
+            width: width,
+            height: height
+        });
+        stream.start();
+    }
+    return camera.streamPort;
+}