@arisan/data-api/lib/routers/mountEvents.js

The Universal Database API Gateway for CLIO's Modules

'use strict';

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.default = mountEvents;

var _bodyParser = require('body-parser');

var _bodyParser2 = _interopRequireDefault(_bodyParser);

var _express = require('express');

var _express2 = _interopRequireDefault(_express);

var _mongodb = require('mongodb');

var _mongodb2 = _interopRequireDefault(_mongodb);

var _checkObjectID = require('../middleware/checkObjectID');

var _checkObjectID2 = _interopRequireDefault(_checkObjectID);

var _checkStreamIndex = require('../middleware/checkStreamIndex');

var _checkStreamIndex2 = _interopRequireDefault(_checkStreamIndex);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

//endregion

//endregion

//region 2. Project Libraries
const context = {
    router: _express2.default.Router({ mergeParams: true }),
    cameras: null,
    telemetryEvents: null,
    logger: null
}; //region 1. Platform Libraries


context.router.use('/', _bodyParser2.default.json());
context.router.use('/', _checkObjectID2.default);
context.router.use('/', _checkStreamIndex2.default);

context.router.post('/', (req, res) => {
    const log = (lvl, msg) => context.logger.log(lvl, msg, { tags: `POST ${req.originalUrl}` });
    log('debug', JSON.stringify(req.body, null, 2));
    ['type', 'time'].forEach(property => {
        if ({}.hasOwnProperty.call(req.body, property)) {
            return;
        }
        const message = `Event Contains No ${property}`;
        log('error', message);
        res.status(400).send(message);
        throw new Error(message);
    });
    const triggeringCameraId = new _mongodb2.default.ObjectID(req.params.id);
    context.cameras.find({
        triggering_camera_id: triggeringCameraId
    }, {
        fields: {
            project_id: 1,
            active_stream_index: 1
        }
    }).toArray((findCameraErr, triggeredCameras) => {
        if (findCameraErr) {
            log('error', findCameraErr.message);
            res.status(500).send(findCameraErr.message);
            return;
        }
        if (triggeredCameras.length === 0) {
            const message = 'Camera Not Found';
            log('error', message);
            res.status(500).send(message);
            return;
        }
        const event = {
            type: req.body.type,
            created: new Date(req.body.time),
            status: 'PENDING',
            project_id: triggeredCameras[0].project_id,
            triggering_camera_id: triggeringCameraId,
            triggering_stream_index: parseInt(req.params.index, 10),
            videos: [],
            response_trail: []
        };
        triggeredCameras.forEach(triggeredCamera => {
            event.videos.push({
                camera_id: triggeredCamera._id,
                stream_index: triggeredCamera.active_stream_index,
                status: 'TRIGGERED'
            });
        });
        context.telemetryEvents.insert(event, telemetryEventsInsertErr => {
            if (telemetryEventsInsertErr) {
                log('error', telemetryEventsInsertErr.message);
                res.status(500).send(telemetryEventsInsertErr.message);
                return;
            }
            log('info', '200 OK');
            res.sendStatus(200);
        });
    });
});

context.router.put('/', (req, res) => {
    const log = (lvl, msg) => context.logger.log(lvl, msg, { tags: `PUT ${req.originalUrl}` });
    log('debug', JSON.stringify(req.query));
    log('debug', JSON.stringify(req.body));
    if (!{}.hasOwnProperty.call(req.body, 'videoInfo')) {
        const message = 'Event Contains No Video Info';
        log('error', message);
        res.status(400).send(message);
        return;
    }
    if (!{}.hasOwnProperty.call(req.body.videoInfo, 'streamId')) {
        const message = 'Event Video Info Contains No Stream ID';
        log('error', message);
        res.status(400).send(message);
        return;
    }
    const size = req.body.videoInfo.size;
    const objectName = req.body.videoInfo.objectName;
    if (objectName && (!size || typeof size !== 'number' || !Number.isInteger(size))) {
        const message = 'Invalid size value';
        log('error', message);
        res.status(400).send(message);
        return;
    }

    const triggeringCameraId = new _mongodb2.default.ObjectID(req.params.id);
    const created = new Date(parseInt(req.query.time, 10));
    const streamId = req.body.videoInfo.streamId.split('_');
    const cameraId = new _mongodb2.default.ObjectID(streamId[0]);
    const video = {};
    if (req.body.videoInfo.status) {
        video['videos.$.status'] = req.body.videoInfo.status.toUpperCase();
    }
    if (req.body.videoInfo.startTime) {
        video['videos.$.started'] = new Date(parseInt(req.body.videoInfo.startTime, 10));
    }
    if (req.body.videoInfo.endTime) {
        video['videos.$.ended'] = new Date(parseInt(req.body.videoInfo.endTime, 10));
    }
    if (req.body.videoInfo.bucketName) {
        video['videos.$.bucket_name'] = req.body.videoInfo.bucketName;
    }
    if (req.body.videoInfo.objectName) {
        video['videos.$.object_name'] = req.body.videoInfo.objectName;
    }
    if (req.body.videoInfo.size) {
        video['videos.$.size'] = req.body.videoInfo.size;
    }

    context.telemetryEvents.updateOne({
        triggering_camera_id: triggeringCameraId,
        created,
        'videos.camera_id': cameraId
    }, { $set: video }, (updateEventErr, updateEventResult) => {
        if (updateEventErr) {
            log('error', updateEventErr.message);
            res.status(500).send(updateEventErr.message);
            return;
        }
        if (!updateEventResult.matchedCount) {
            const message = 'Telemetry Event Video Not Found';
            log('error', message);
            res.status(500).send(message);
            return;
        }
        log('info', '200 OK');
        res.sendStatus(200);
    });
});

//noinspection JSUnusedGlobalSymbols
/**
 * Mount router for /c/:/s/:/events
 * @param {object}         options          Options
 * @param {object}         options.app      Express App
 * @param {MongoClient.Db} options.database Associated Database
 * @param {winston.Logger} options.logger   Logger
 */
function mountEvents(options) {
    context.logger = options.logger;
    const log = (lvl, msg) => context.logger.log(lvl, msg, { tags: 'mountEvents' });
    log('debug', 'Mounting router for /c/:/s/:/events....');
    options.app.use('/cameras/:id/streams/:index/events', context.router);
    context.cameras = options.database.collection('cameras');
    context.cameras.createIndex({
        triggering_camera_id: -1
    }, { background: true });
    context.telemetryEvents = options.database.collection('telemetry_events');
    context.telemetryEvents.createIndex({
        triggering_camera_id: -1,
        created: -1,
        type: 1
    }, { background: true, unique: true });
    log('info', 'Router for /c/:/s/:/events Mounted');
}
//# sourceMappingURL=mountEvents.js.map