FM / db

/var/www/myprog.com.ua/server/node/db/

/var/www/myprog.com.ua/server/node/db

Name	Size	Mode	Actions
db_context.js	17030	0644	edit dl rm
db_context_cameras.js	5106	0666	edit dl rm
db_context_chat.js	113	0644	edit dl rm
db_context_commands.js	3609	0666	edit dl rm
db_context_devices.js	4058	0666	edit dl rm
db_context_events.js	4496	0666	edit dl rm
db_context_hosts.js	4342	0644	edit dl rm
db_context_host_config.js	2658	0644	edit dl rm
db_context_places.js	14885	0644	edit dl rm
db_context_scenario.js	3214	0666	edit dl rm
db_context_users.js	7944	0644	edit dl rm
db_context_values.js	5472	0666	edit dl rm
db_context_var.js	3002	0666	edit dl rm

Edit: /var/www/myprog.com.ua/server/node/db/db_context_places.js (14885B)

const Place = require('../objects/place');
const UsersPlaces = require('../objects/users_places');
const PlacesScenario = require('../objects/places_scenario');
const PlacesCameras = require('../objects/places_cameras');
const PlacesDevices = require('../objects/places_devices');
const PlacesValues = require('../objects/places_values');
const log = require('../helpers/log');
module.exports = (DbContext) => {

DbContext.prototype.get_place = async function (place_id) {
        //let t1 = new Date().microtime(true);
        let _self = this;
        let value = null;
        try {
            let sql = `SELECT * FROM \`places\` 
            WHERE id='${place_id}' LIMIT 1`;
            //log.debug('DbContext', 'get_value()', `SQL: ${sql}`);
            let result = await _self.query(sql);
            if(result[0]!=undefined){
                if (result[0].id > 0) {
                    value = new Place(result[0]);
                }
            }
        } catch (e) {
            log.error('DbContext', 'get_place()', e);
        }

//let t2 = new Date().microtime(true);
        //log.debug('DbContext', 'get_value()', `complete ${t2 - t1}`);
        return value;
    }

DbContext.prototype.get_user_places_scenario = async function (user_id) {
        let _self = this;
        let t1 = new Date().microtime(true);
            let sql = `SELECT pc.* FROM \`places_scenario\` pc
            INNER JOIN users_places up ON up.place_id = pc.place_id  
            INNER JOIN places p ON up.place_id = p.id  
            INNER JOIN scenario s ON s.id = pc.scenario_id  
            WHERE up.user_id='${user_id}' AND p.deleted='0' AND s.deleted='0' LIMIT 10000`;
        //log.debug('DbContext', 'get_user_devices()', `SQL: ${sql}`);
        let places = [];
        try {
            let rows = await _self.query(sql);
            for (row of rows) {
                places.push(new PlacesScenario(row));
            }
        } catch (e) {
            log.error('DbContext', 'get_user_places_scenario()', e);
        }
        let t2 = new Date().microtime(true);
        //log.debug('DbContext', 'get_user_values()', `complete ${t2 - t1}`);
        return places;
    }

DbContext.prototype.get_user_places_cameras = async function (user_id) {
        let _self = this;
        let t1 = new Date().microtime(true);
            let sql = `SELECT pc.* FROM \`places_cameras\` pc
            INNER JOIN users_places up ON up.place_id = pc.place_id  
            INNER JOIN places p ON up.place_id = p.id  
            INNER JOIN cameras c ON c.id = pc.camera_id  
            WHERE up.user_id='${user_id}' AND p.deleted='0' AND c.deleted='0' LIMIT 1000`;
        //log.debug('DbContext', 'get_user_devices()', `SQL: ${sql}`);
        let places = [];
        try {
            let rows = await _self.query(sql);
            for (row of rows) {
                places.push(new PlacesCameras(row));
            }
        } catch (e) {
            log.error('DbContext', 'get_user_places_cameras()', e);
        }
        let t2 = new Date().microtime(true);
        //log.debug('DbContext', 'get_user_values()', `complete ${t2 - t1}`);
        return places;
    }

DbContext.prototype.get_user_places_devices = async function (user_id) {
        let _self = this;
        let t1 = new Date().microtime(true);
            let sql = `SELECT pd.* FROM \`places_devices\` pd
            INNER JOIN users_places up ON up.place_id=pd.place_id  
            INNER JOIN places p ON up.place_id = p.id  
            INNER JOIN devices d ON pd.device_id = d.id  
            INNER JOIN hosts h ON d.host_id = h.id  
            WHERE up.user_id='${user_id}' AND p.deleted='0' AND h.deleted='0' LIMIT 10000`;
        //log.debug('DbContext', 'get_user_devices()', `SQL: ${sql}`);
        let places = [];
        try {
            let rows = await _self.query(sql);
            for (row of rows) {
                places.push(new PlacesDevices(row));
            }
        } catch (e) {
            log.error('DbContext', 'get_user_places_devices()', e);
        }
        let t2 = new Date().microtime(true);
        //log.debug('DbContext', 'get_user_values()', `complete ${t2 - t1}`);
        return places;
    }

DbContext.prototype.get_user_places_values = async function (user_id) {
        let _self = this;
        let t1 = new Date().microtime(true);
            let sql = `SELECT pv.* FROM \`places_values\` pv
            INNER JOIN users_places up ON up.place_id = pv.place_id  
            INNER JOIN places p ON up.place_id = p.id  
            INNER JOIN \`values\` v ON pv.value_id = v.id  
            INNER JOIN hosts h ON v.host_id = h.id  
            WHERE up.user_id='${user_id}' AND p.deleted='0' AND h.deleted='0' LIMIT 10000`;
        // log.debug('DbContext', 'get_user_devices()', `SQL: ${sql}`);
        let places = [];
        try {
            let rows = await _self.query(sql);
            for (row of rows) {
                places.push(new PlacesValues(row));
            }
        } catch (e) {
            log.error('DbContext', 'get_user_places_values()', e);
        }
        let t2 = new Date().microtime(true);
        //log.debug('DbContext', 'get_user_values()', `complete ${t2 - t1}`);
        return places;
    }

DbContext.prototype.get_user_places = async function (user_id) {
        let _self = this;
        let t1 = new Date().microtime(true);
            let sql = `SELECT p.* FROM \`places\` p
            INNER JOIN users_places up ON up.place_id=p.id  
            WHERE up.user_id='${user_id}' AND p.deleted='0' LIMIT 100`;
        log.debug('DbContext', 'get_user_places()', `SQL: ${sql}`);
        let places = [];
        try {
            let rows = await _self.query(sql);
            for (row of rows) {
                places.push(new Place(row));
            }
        } catch (e) {
            log.error('DbContext', 'get_user_places()', e);
        }
        let t2 = new Date().microtime(true);
        //log.debug('DbContext', 'get_user_values()', `complete ${t2 - t1}`);
        return places;
    }

DbContext.prototype.update_place = async function (place) {
        //let t1 = new Date().microtime(true);
        let _self = this;
        //await this.query('START TRANSACTION');
        try {
            let sql = _self.sql_insert_or_update(place, 'places');
            //log.debug('DbContext', 'update_value()',`SQL: ${sql}`);

DbContext.prototype.add_user_place = async function (user_id, place_id) {
        let _self = this;
        try {
            sql = "SELECT * FROM `users_places` WHERE place_id="+place_id+" AND user_id="+user_id;
            let rows = await _self.query(sql);
            users_places = null;
            for (row of rows) {
                users_places = new UsersPlaces(row);
            }
        } catch (e) {
            log.error('DbContext', 'add_user_place()', e);
        }
        
        if (users_places==null) {
            users_places = new UsersPlaces();
            users_places.place_id = place_id;
            users_places.user_id = user_id;
        }
        
        try {
            let sql = _self.sql_insert_or_update(users_places, 'users_places');

return places_scenario;
        } catch (e) {
            log.error('DbContext', 'del_place_scenario()',e);
            return null;
        }
    }
    DbContext.prototype.add_place_camera = async function (place_id,camera_id) {
        let _self = this;
        try {
            sql = "SELECT * FROM `places_cameras` WHERE place_id="+place_id+" AND camera_id="+camera_id;
            let rows = await _self.query(sql);
            places_cameras = null;
            for (row of rows) {
                places_cameras = new PlacesCameras(row);
            }
        } catch (e) {
            log.error('DbContext', 'add_place_camera()', e);
        }
        
        if (places_cameras==null) {
            places_cameras = new PlacesCameras();
            places_cameras.place_id = place_id;
            places_cameras.camera_id = camera_id;
        }
        
        try {
            let sql = _self.sql_insert_or_update(places_cameras, 'places_cameras');

}

cmd: