rubick/web/index.js

tools for mtc

/**
 * Created by hongzhiyuan on 2017/5/17.
 */

"use strict"

let express = require('express');
let app = express();
let path = require('path');
let server = require('http').Server(app);
let bodyParser = require('body-parser');
let busboy = require('connect-busboy');
let cookieParser = require('cookie-parser');
let compression = require('compression');
let multer = require('multer');
let fs  = require('fs');
let logger = require('../log').init('rubick');

app.use(compression());
app.use(bodyParser.json());
app.use('/static', express.static(__dirname + '/static'));
app.use(bodyParser.urlencoded({extended: true}));
app.use(cookieParser());


let DeviceManager = require('../service/device').Manager;
let record = require('../service/record');

let Storage = multer.diskStorage({
    destination: function (req, file, callback) {
        callback(null, "./static/files");
    },
    filename: function (req, file, callback) {
        callback(null, file.fieldname + "_" + Date.now() + "_" + file.originalname);
    }
});

let busboyOption = busboy({limits: {fileSize: 200 * 1024 * 1024}});

app.post('/case/upload', busboyOption, (req, res) => {
    let fstream;
    req.pipe(req.busboy);
    req.busboy.on('file', function (fieldname, file, filename) {
        console.log("Uploading: " + filename);
        fstream = fs.createWriteStream(__dirname + '/static/files/' + filename);
        file.pipe(fstream);
        fstream.on('close', function () {
            let readline = require('readline');

            let rd = readline.createInterface({
                input: fs.createReadStream(__dirname + '/static/files/' + filename),
                output: process.stdout,
                console: false
            });
            let case_list = [];

            rd.on('line', function (line) {
                console.log(line);
                let lines = line.split(',');
                if (lines.length >= 2) {
                    case_list.push({index: lines[0], name: lines[1]});
                }
            });

            rd.on('close', function() {
                res.send({'errno': 0, 'data': case_list});
            });
        });
    });
});

app.post('/case/import', busboyOption, (req, res) => {
    let fstream;
    req.pipe(req.busboy);
    req.busboy.on('file', function (fieldname, file, filename) {
        console.log("Uploading: " + filename);
        let path = __dirname + '/static/files/' + filename;
        fstream = fs.createWriteStream(path);
        file.pipe(fstream);
        fstream.on('close', function () {
            console.log(path);
            let readline = require('readline');
            let rd = readline.createInterface({
                input: fs.createReadStream(__dirname + '/static/files/' + filename),
                output: process.stdout,
                console: false
            });

            let codeContent = '';
            rd.on('line', function (line) {
                codeContent = codeContent + line;
            });

            rd.on('close', function() {
                res.send({'errno': 0, 'data': codeContent});
            });
        });
    });
});

app.post('/apk/analysis', busboyOption, (req, res) => {
    let fstream;
    req.pipe(req.busboy);
    req.busboy.on('file', function (fieldname, file, filename) {
        console.log("Uploading: " + filename);
        let path = __dirname + '/static/files/' + filename;
        fstream = fs.createWriteStream(path);
        file.pipe(fstream);
        fstream.on('close', function () {
            console.log(path);
            record.analysisApk(path).then((apkInfo) => {
                res.send({'errno':0, 'data':apkInfo});
            }, () => {
                res.send({'errno':-1,'msg':'analysis failed'})
            });
        });
    });
});

app.use(['/device/:serial/*', '/device/:serial'], (req, res, next) => {
    let deviceId = req.params.serial;
    if (deviceId === 'default') {

    }
    if (DeviceManager.devices.hasOwnProperty(deviceId)) {
        next();
    } else {
        res.status(500).send({
            error: 'device not exists'
        });
    }
});

/**
 * get device list
 */
app.get('/devices', (req, res) => {
    DeviceManager.getDevices().then(() => {
        res.send({'errno':0, 'data':DeviceManager.all(),'msg':''})
    }, () => {
        res.send({'errno':-1, 'msg':'error happens'})
    });
});

/**
 * get device info by serial
 */
app.get('/device/:serial', (req, res) => {
    let device = DeviceManager.devices[req.params.serial];
    res.send({'errno':0, 'data':device.detail(),'msg':''});
});

/**
 * dump the window into xml source
 */
app.get('/device/:serial/dump', (req, res) => {
    DeviceManager.devices[req.params.serial].dump().then((text) => {
        res.send({'errno':0, 'data':text, 'msg':''});
    }, () => {
        res.send({'errno':-1,'msg':'dump error occurs'})
    });
});

/**
 * dump the window into dom view
 */
app.get('/device/:serial/dumpView', (req, res) => {
    DeviceManager.devices[req.params.serial].dumpDom().then((text) => {
        // logger.info(text);
        res.send({'errno':0, 'data':text, 'msg':''});
    }, () => {
        res.send({'errno':-1,'msg':'dumpView error occurs'})
    });
});

app.post('/compileCode', (req,res) => {
    logger.info(req.body);
    // res.send({'errno':0, 'data':{}, 'msg':''});

    record.compileCode(req.body).then((result) => {
        res.send({'errno':0, 'data':result, 'msg':''});
    }, () => {
        res.status(500).send({'errno':-1,'msg':'read file error occurs'});
    });
});

app.post('/device/:serial/installApk', (req,res) => {
    logger.info(req.body);
    let apkFile = req.body.fileName;
    DeviceManager.devices[req.params.serial].installApk(apkFile).then((result) => {
        res.send({'errno':0, 'data':result, 'msg':''});
    }, () => {
        res.status(500).send({'errno':-1,'msg':'install apk error occurs'});
    });
});

app.get('/file/caseFile', function(req, res, next) {
    // 实现文件下载
    var filePath = path.join(__dirname, '../tools/cases.zip');
    var stats = fs.statSync(filePath);
    if(stats.isFile()){
        res.set({
            'Content-Type': 'application/octet-stream',
            'Content-Disposition': 'attachment; filename=case.zip',
            'Content-Length': stats.size
        });
        fs.createReadStream(filePath).pipe(res);
    } else {
        res.end(404);
    }
});
/**
 * get screen shot stream and encode into base64
 */
app.post('/device/:serial/operate', (req, res) => {
    DeviceManager.devices[req.params.serial].deviceOperate(req.body).then((result) => {
        res.send({'errno':0, 'data':result, 'msg':''});
    }, () => {
        res.status(500).send({'errno':-1,'msg':'screenshot error occurs'});
    });
});

/**
 * get screen shot stream and encode into base64
 */
app.get('/device/:serial/screenshot', (req, res) => {
    DeviceManager.devices[req.params.serial].screenShot().then((stream) => {
        var chunks = [];
        stream.on('data', function(chunk) {
            chunks.push(chunk);
        });
        stream.on('end', function() {
            var result = Buffer.concat(chunks);
            res.send({'errno':0, 'data':result.toString('base64'), 'msg':''});
        });
    }, () => {
        res.status(500).send({'errno':-1,'msg':'screenshot error occurs'});
    });
});

exports.init = () => {
    server.listen(8888);
};