Source: models/operationshelper.js

// Constructor
class operations {
    constructor(logger) {
      // always initialize all instance properties
      this.logger = logger;
    }

    /**
     * returns list of all operations
     * @param {function} callback rows or null
     */
    getListOfOperations(callback) {
        //global.plgManager.logger.debug('MODELS-OPERATIONSHELPER | Reading operations list');
        let sql = `SELECT * FROM operationsStore ORDER BY id DESC`;

        global.coreDb.all(sql, [], (err, rows) => {
            if (err) {
                this.logger.error('MODELS-OPERATIONSHELPER | Error reading list of operations from database: ' + err);
                return callback(null);
            }
            return callback(rows);
        });
    }

    /**
     * Returns list of all active operations
     * @param {function} callback rows or null
     */
    getListOfActiveOperations(callback) {
        global.plgManager.logger.debug('MODELS-OPERATIONSHELPER | Reading active operations list');
        let sql = `SELECT * FROM operationsStore WHERE operationState = 0 ORDER BY id DESC`;

        global.coreDb.all(sql, [], (err, rows) => {
            if (err) {
                this.logger.error('MODELS-OPERATIONSHELPER | Error reading list of active operations from database: ' + err);
                return callback(null);
            }
            return callback(rows);
        });
    }

    /**
     * Returns last operation coming in
     * @param {function} callback 
     */
    getLastOperation(callback) {
        let sql = "SELECT * FROM operationsStore ORDER BY id DESC LIMIT 1";
        global.plgManager.logger.debug('MODELS-OPERATIONSHELPER | Reading last operation');
        global.coreDb.all(sql, [], (err, rows) => {
            if (err) {
                this.logger.error('MODELS-OPERATIONSHELPER | Error reading last operation from database: ' + err);
                return callback(null);
            }
            return callback(rows);
        });
    }

    /**
     * Returns one single operation from operationsStore in core database
     * @param {integer} oId id of operation to be loaded from core datbase
     * @param {function} callback row or null
     */
    getOperation(oId, callback) {
        let sql = "SELECT * FROM operationsStore WHERE id = ?";
        global.plgManager.logger.debug(`MODELS-OPERATIONSHELPER | Reading operation with id ${oId}`);
        global.coreDb.all(sql, [
            oId
        ], (err, rows) => {
            if (err) {
                this.logger.error('MODELS-OPERATIONSHELPER | Error reading operation from database: ' + err);
                return callback(null);
            }
            return callback(rows);
        });
    }

    /**
     * Returns one single operation from operationsStore in core database
     * @param {integer} oId id of operation to be loaded from core datbase
     * @param {function} callback row or null
     */
    getOperationForUUID(uuid, callback) {
        let sql = "SELECT * FROM operationsStore WHERE uuid = ?";
        global.plgManager.logger.debug(`MODELS-OPERATIONSHELPER | Reading operation with uuid ${uuid}`);
        global.coreDb.all(sql, [
            uuid
        ], (err, rows) => {
            if (err) {
                this.logger.error('MODELS-OPERATIONSHELPER | Error reading operation from database: ' + err);
                return callback(null);
            }
            return callback(rows);
        });
    }

    /**
     * deletes one single operation from operationsStore in core database
     * @param {integer} oId id of operation to be loaded from core datbase
     * @param {function} callback row or null
     */
    deleteOperation(oId, callback) {
        let sql = "DELETE FROM operationsStore WHERE id = ?";
        global.plgManager.logger.debug(`MODELS-OPERATIONSHELPER | DELETE operation with id ${oId}`);
        global.coreDb.all(sql, [
            oId
        ], (err, rows) => {
            if (err) {
                this.logger.error('MODELS-OPERATIONSHELPER | Error deleteing operation from database: ' + err);
                return callback(null);
            }
            return callback(null);
        });
    }

    /**
     * Returns sub operations for given operation from operationsStore in core database
     * @param {integer} oId id of operation sub operations to be loaded from core datbase for
     * @param {function} callback rows or null
     */
    getSubOperationsForOperation(oId, callback) {
        let sql = "SELECT * FROM operationsStore WHERE subOperationFor = ?";
        global.plgManager.logger.debug(`MODELS-OPERATIONSHELPER | Reading sub operations for operation with id ${oId}`);
        global.coreDb.all(sql, [
            oId
        ], (err, rows) => {
            if (err) {
                this.logger.error('MODELS-OPERATIONSHELPER | Error reading sub operations from database: ' + err);
                return callback(null);
            }
            return callback(rows);
        });
    }

    /**
     * sets the archived flag for an operation
     * @param {integer} oId id of operation to be archived
     * @param {function} callback success (true/false)
     */
    archiveOperation(oId, callback) {
        let query = "UPDATE operationsStore SET operationState = 2 WHERE id = ?";
        this.logger.debug(`MODELS-OPERATIONSHELPER | archiving operation with id ${oId}`);
        global.coreDb.all(query, [
            oId
        ], (err, rows) => {
            if (err) {
                this.logger.error('MODELS-OPERATIONSHELPER | Error archiving operation: ' + err);
                return callback(false);
            }
            return callback(true);
        });
    }

    /**
     * sets the archived flag for an operation identified by uuid
     * @param {string} uuid id of operation to be archived
     * @param {function} callback success (true/false)
     */
    archiveOperationByUUID(uuid, callback) {
        let query = "UPDATE operationsStore SET operationState = 2 WHERE uuid = ?";
        this.logger.debug(`MODELS-OPERATIONSHELPER | archiving operation with uuid ${uuid}`);
        global.coreDb.all(query, [
            uuid
        ], (err, rows) => {
            if (err) {
                this.logger.error('MODELS-OPERATIONSHELPER | Error archiving operation: ' + err);
                return callback(false);
            }
            return callback(true);
        });
    }

     /**
     * sets the closed flag for an operation
     * @param {integer} oId id of operation to be archived
     * @param {function} callback success (true/false)
     */
    closeOperation(oId, callback) {
        let query = "UPDATE operationsStore SET operationState = 1 WHERE id = ?";
        this.logger.debug(`MODELS-OPERATIONSHELPER | clsoing operation with id ${oId}`);
        global.coreDb.all(query, [
            oId
        ], (err, rows) => {
            if (err) {
                this.logger.error('MODELS-OPERATIONSHELPER | Error closing operation: ' + err);
                return callback(false);
            }
            return callback(true);
        });
    }

    /**
     * sets the closed flag for an operation identified by uuid
     * @param {string} uuid uuid of operation to be archived
     * @param {function} callback success (true/false)
     */
    closeOperationByUUID(uuid, callback) {
        let query = "UPDATE operationsStore SET operationState = 1 WHERE uuid = ?";
        this.logger.debug(`MODELS-OPERATIONSHELPER | clsoing operation with uuid ${uuid}`);
        global.coreDb.all(query, [
            uuid
        ], (err, rows) => {
            if (err) {
                this.logger.error('MODELS-OPERATIONSHELPER | Error closing operation: ' + err);
                return callback(false);
            }
            return callback(true);
        });
    }


    /**
     * Returns list of operations from core database as JSON for map view
     * @param {function} callback JSON String of operations
     */
    getListOfOperationsJSON(callback) {
        this.logger.info('Reading operations as JSON');
        let query = "SELECT * FROM operationsStore";

        global.coreDb.all(query, [], (err, rows) => {
            if (err) {
                this.logger.error('OPERATIONS-MODEL | Error loading list of operations from core data: ' + err.message);
                return callback(null);
            } else {
                var counter = 0;
                this.logger.info('OPERATIONS-MODEL | Read ' + rows.length + ' operations successfully');
                var returnJSON = "[";

                rows.forEach(operation => {
                    counter++;
                    var dividerStr = '';
                    if (counter > 0) {
                        dividerStr = ', ';
                    }
                    returnJSON = returnJSON + dividerStr + '{ lat: ' + operation.lat + ', lon: ' + operation.lon + ', keywordId: \'' + operation.keywordId + '\'}';
                });

                returnJSON = returnJSON + ']';
                //TEST
                returnJSON = JSON.stringify(rows);
                return callback(returnJSON);
            }
        });
    }
  }

    
  // export the class
  module.exports = operations;