Source: models/respiratory.js

const Basedata = require('./basedata');
const Momenthelper = require('./momenthelper');
const Moment = require('moment');

class respiratory {

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

   
    /**
     * Loads list of respiratory entries from core database
     * @param {*} callback 
     */
    loadList(callback) {
        this.logger.debug('MODELS-RESPIRATORY | Reading list from core database');
        let sql = 'SELECT ' +
                    'respiratoryStore.*, ' +
                    'basedata.firstname, ' +
                    'basedata.lastname, ' +
                    'organizations.name as orgName, ' +
                    'organizations.id AS orgId ' +
                    'FROM respiratoryStore ' +
                  'INNER JOIN basedata ON basedata.id = respiratoryStore.basedataId ' +
                  'INNER JOIN organizations ON basedata.organizationid = organizations.id';

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


    /**
     * returns basedata ids as rows for which respiratory entries exist in database
     * @param {function} callback rows or null
     */
    getBasedataForWhichRespiratoryEntryExists(callback) {
        let query = "SELECT basedata.id AS basedataId " +
                    "FROM basedata " +
                    "INNER JOIN respiratoryStore ON respiratoryStore.basedataId = basedata.id";
        global.coreDb.all(query, [], (err, rows) => {
            if (err) {
                this.logger.error('MODELS-RESPIRATORY | Error reading list of basedata from database: ' + err);
                console.log(err);
                return callback(null);
            }
            return callback(rows);
        });
    }


    /**
     * Returns existing entries for basedataId
     * @param {integer} basedataId id of basedata to return entry for
     * @param {*} callback rows or null
     */
    getEntryForBasedata(basedataId, callback) {
        let query = "SELECT * FROM respiratoryStore WHERE basedataId = ?";
        global.coreDb.all(query, [
            basedataId
        ], (err, rows) => {
            if (err) {
                this.logger.error('MODELS-RESPIRATORY | Error checking for existing entry from database: ' + err);
                console.log(err);
                return callback(null);
            } else {
                return callback(rows);
            }
        });
    }

    /**
     * Returns respiratory entry from core database
     * @param {integer} respId 
     * @param {function} callback rows or null
     */
    getEntryForId(respId, callback) {
        let query = "SELECT respiratoryStore.*, " +
                        "basedata.firstname AS firstname, " +
                        "basedata.lastname AS lastname " +
                        "FROM respiratoryStore " +
                        "INNER JOIN basedata ON basedata.id = respiratoryStore.basedataId " +
                        "WHERE respiratoryStore.id = ?";

        global.coreDb.all(query, [
            respId
        ], (err, rows) => {
            if (err) {
                this.logger.error('MODELS-RESPIRATORY | Error loading entry from database: ' + err);
                console.log(err);
                return callback(null);
            } else {
                return callback(rows);
            }
        });
    }

    /**
     * returns members with valid respiratory (till today)
     * @param {function} callback rows or null
     */
    getValidMembers(callback) {

        var dateBoundary_day = new Date().getDate();
        var dateBoundary_month = new Date().getMonth() + 1;
        var dateBoundary_year = new Date().getFullYear();
        if (dateBoundary_day < 10) dateBoundary_day = '0' + dateBoundary_day;
        if (dateBoundary_month < 10) dateBoundary_month = '0' + dateBoundary_month;
        var dateBoundary = dateBoundary_year + '-' + dateBoundary_month + '-' + dateBoundary_day;

        console.log('date boundary: ' + dateBoundary);

        let query = "SELECT * " +
                    "FROM respiratoryStore " +
                    "WHERE respiratoryStore.capableTill > datetime(?, 'localtime')";
                    global.coreDb.all(query, [
                        dateBoundary
                    ], (err, rows) => {
                        if (err) {
                            this.logger.error('MODELS-RESPIRATORY | Error checking for valid members from database: ' + err);
                            console.log(err);
                            return callback(null);
                        } else {
                            console.log('members identified: ' + rows.length);
                            return callback(rows);
                        }
                    });
    }

    /**
     * returns expiring respiratory 
     * @param {integer} months months left boundary
     * @param {function} callback rows or null
     */
    getExpiringMembers(months, callback) {

        var dateBoundary_day = new Date().getDate();
        var dateBoundary_month = new Date().getMonth() + 1;
        var dateBoundary_year = new Date().getFullYear();

        // add months (make sure year overflow is recognised)
        if ((dateBoundary_month + months) > 12) {
            dateBoundary_month = (dateBoundary_month + months) -12;
            dateBoundary_year = dateBoundary_year + 1;
        } else {
            dateBoundary_month = dateBoundary_month + months;
        }


        if (dateBoundary_day < 10) dateBoundary_day = '0' + dateBoundary_day;
        if (dateBoundary_month < 10) dateBoundary_month = '0' + dateBoundary_month;
        var dateBoundary = dateBoundary_year + '-' + dateBoundary_month + '-' + dateBoundary_day;

        console.log('date boundary (future): ' + dateBoundary);

        let query = "SELECT * " +
                    "FROM respiratoryStore " +
                    "WHERE respiratoryStore.capableTill < datetime(?, 'localtime')";
                    global.coreDb.all(query, [
                        dateBoundary
                    ], (err, rows) => {
                        if (err) {
                            this.logger.error('MODELS-RESPIRATORY | Error checking for expiring members from database: ' + err);
                            console.log(err);
                            return callback(null);
                        } else {
                            console.log('members identified: ' + rows.length);
                            return callback(rows);
                        }
                    });
    }

    /**
     * adds a new Entry for a basedata
     * @param {object} reqBody req.body of form sending in the information
     * @param {*} callback success (true/false)
     */
    addRespiratory(reqBody, callback) {
        var basedataId = reqBody.basedataid;
        this.getEntryForBasedata(basedataId, (rowsExisting) => {
            var capable = 1;
            var exists = false;
            if (rowsExisting !== null) {
                if (rowsExisting.length > 0) {
                    exists = true;
                }
            }
            if (exists) {
                // There exists an entry --> return false
                callback(false);
            } else {
                var capableFrom = reqBody.capableFrom;
                var capableTill = reqBody.capableTill;
                var doctorName = reqBody.doctorName;
                var restrictions = reqBody.restrictions;

                console.log('BASEDATA: ' + basedataId);
                if ((capableFrom.length < 10) || (capableTill.length < 10) || (basedataId === null) || (basedataId.length < 1)) {
                    return callback(false);
                }

                // Calculate dates to database format
                var momenthelper = new Momenthelper();
                var capableFrom = momenthelper.formDateToMysql(capableFrom);
                var capableTill = momenthelper.formDateToMysql(capableTill);

                // Check if date is in the past
                var dateTill = Moment(capableTill);
                var dateNow = Moment();
                if (dateTill.diff(dateNow, 'days') <= 1) {
                    capable = 0;
                }
                

                let query = "INSERT INTO respiratoryStore (basedataId, capable, capableFrom, capableTill, doctorName, restrictions) VALUES (?, ?, ?, ?, ?, ?)";
                global.coreDb.run(query,
                    [
                        basedataId,
                        capable,
                        capableFrom,
                        capableTill,
                        doctorName,
                        restrictions
                    ],
                    function (err) {
                        if (err) {
                            console.log('ERROR: ' + err.message);
                            callback(false);
                        } else {
                            callback(true);
                        }
                    });
            }
        })
    }

    /**
     * updates a record in core database
     * @param {integer} respId id of entry 
     * @param {*} reqBody req.body holding form data
     * @param {*} callback success (true/false)
     */
    editRespiratory(respId, reqBody, callback) {
        var capable = reqBody.capable;
        var capableFrom = reqBody.capableFrom;
        var capableTill = reqBody.capableTill;
        var restrictions = reqBody.restrictions;
        var doctorName = reqBody.doctorName;


        // Calculate dates to database format
        var momenthelper = new Momenthelper();
        var capableFrom = momenthelper.formDateToMysql(capableFrom);
        var capableTill = momenthelper.formDateToMysql(capableTill);

        // Check if date is in the past
        var dateTill = Moment(capableTill);
        var dateNow = Moment();
        if (dateTill.diff(dateNow, 'days') <= 1) {
            capable = 0;
        }

        let query = "UPDATE respiratoryStore SET " +
                    "capable = ?, " +
                    "capableFrom = ?, " +
                    "capableTill = ?, " +
                    "restrictions = ?, " + 
                    "doctorName = ? " +
                    "WHERE id = ?";

        global.coreDb.run(query,
            [
                capable,
                capableFrom,
                capableTill,
                restrictions,
                doctorName,
                respId
            ],
            function (err) {
                if (err) {
                    console.log('ERROR: ' + err.message);
                    callback(false);
                } else {
                    callback(true);
                }
            });

    }
}

// export the class
module.exports = respiratory;