stmms-proxy/source/lib/image.js

//云端图片操作工具
const EventEmitter = require('events')
const api = require('./api.js')
const env = require('./env.js')
const config = require('./config.js')
const logger = require('./logger.js')('image.js')
const downloadLogger = require('./logger.js')('download')
const upyun = require('./upyun.js')
const fs = require('fs')
const path = require('path')
const readline = require('readline')
const sizeOf = require('image-size')
const mustache = require('mustache')
const mkdirp = require('mkdirp')
const gm = config.imagemagick != undefined ? require('gm').subClass({
    imageMagick: true,
    appPath: config.imagemagick
}) : require('gm')

class executor extends EventEmitter {

    async readFile(file) {
        return new Promise((resolve, reject) => {
            var data = []
            if (fs.existsSync(file)) {
                let reader = readline.createInterface({
                    input: fs.createReadStream(file)
                })
                reader.on('line', line => {
                    data.push(line)
                })
                reader.on('close', () => {
                    resolve(data)
                })
            } else {
                resolve(data)
            }
        })
    }

    async addWatermark(image, file, student, index) {
        let fontSize = config.watermark.fontSize
        let fontFile = config.watermark.fontFile
        let color = config.watermark.color
        let imgData = gm(image)
        let size = sizeOf(image)
        //添加第一页的得分明细
        if (index == 1) {
            //初始坐标
            let x = 30
            let y = 10
            //最大宽/高限制
            let fontSize = 30
            let maxX = size.width / 2 - x * 2
            let height = fontSize + 10
            //计算总分
            let totalScore = (parseFloat(student.objectiveScore) || 0) + (parseFloat(student.subjectiveScore) || 0)
            //显示总分明细
            imgData.font(fontFile, fontSize).fill(color)
            imgData.drawText(x, y += height, '成绩明细')
            imgData.drawText(x, y += height, '总分=(客观+主观) | ' + totalScore + '=' + student.objectiveScore + '+' + student.subjectiveScore)
            //显示客观题明细
            if (student.objectiveScoreDetail && student.objectiveScoreDetail.length > 0) {
                let lines = []
                let array = []
                //前置提示文字的字符数
                let count = 10
                lines.push(array)
                for (let i = 0; i < student.objectiveScoreDetail.length; i++) {
                    let detail = student.objectiveScoreDetail[i]
                    let content = detail.answer + ':' + detail.score
                    //超长后另起一行显示客观题
                    if ((count + content.length) * fontSize * 0.7 > maxX) {
                        array = []
                        lines.push(array)
                        count = 10
                    }
                    array.push(content)
                    count += content.length
                }
                //显示所有行的客观题明细
                for (let l = 0; l < lines.length; l++) {
                    imgData.drawText(x, y += height, '客观题识别结果 | ' + lines[l].join(';'))
                }
            }
            //显示主观题明细
            if (student.subjectiveScoreDetail && student.subjectiveScoreDetail.length > 0) {
                let startY = y
                imgData.drawText(x, y += height, '题号 | 分数')
                for (let i = 0; i < student.subjectiveScoreDetail.length; i++) {
                    let detail = student.subjectiveScoreDetail[i]
                    //超过最大高度了则另起一列
                    if ((y + height + 15) > size.height) {
                        y = startY
                        x += 300
                        imgData.drawText(x, y += height, '题号 | 分数')
                    }
                    let content = detail.mainNumber + '-' + detail.subNumber + ' : ' + detail.score
                    if (detail.marker != undefined) {
                        content = content + ' ' + detail.marker.join(',')
                    }
                    imgData.drawText(x, y += height, content)
                }
            }
        }
        //显示评卷标记
        if (student.tags != undefined && student.tags[index] != undefined) {
            let fontSize = 60
            let height = fontSize + 10
            imgData.font(fontFile, fontSize).fill(color)
            let tags = student.tags[index]
            for (let i = 0; i < tags.length; i++) {
                let tag = tags[i]
                if (tag.content != undefined) {
                    let top = tag.top
                    for (let j = 0; j < tag.content.length; j++) {
                        imgData.drawText(tag.left, top, tag.content[j])
                        top += height
                    }
                }
            }
        }
        return new Promise((resolve, reject) => {
            imgData.write(file, error => {
                if (error) {
                    reject(error)
                } else {
                    resolve()
                }
            })
        })
    }

    async downloadFile(remoteTemplate, localTemplate, data, dir, client, bucket, index, watermark) {
        data.index = index
        let remote = mustache.render(remoteTemplate, data)
        let local = path.join(dir, mustache.render(localTemplate, data))
        mkdirp.sync(path.dirname(local))

        let imgData
        if (config.localStore != undefined && config.localStore.length > 0) {
            let cache = path.join(config.localStore, bucket, remote)
            if (fs.existsSync(cache)) {
                imgData = fs.readFileSync(cache)
            }
        }
        if (imgData == undefined) {
            try {
                imgData = await client.download(remote)
            } catch (err) {
                if (err.code === 404) {
                    //文件不存在，记录日志并跳过
                    downloadLogger.error('404 ' + bucket + ' ' + remote)
                    return Promise.resolve()
                } else {
                    logger.error(err)
                    return Promise.reject(err)
                }
            }
        }
        //是否需要添加分数水印
        if (watermark) {
            await this.addWatermark(imgData, local, data, index)
        } else {
            await fs.writeFileSync(local, imgData)
        }
    }

    async downloadSheet(dir, template, watermark) {
        //从文件中读取已成功下载的准考证号列表
        let doneFile = path.join(__dirname, '../../logs/sheet.log')
        let finish = await this.readFile(doneFile)
        //logger.info(finish)
        let success = {}
        for (let i = 0; i < finish.length; i++) {
            success[finish[i]] = true
        }

        let bucket = env.server.bucketPrefix + '-sheet'
        let client = upyun(bucket, config.upyun.operator, config.upyun.password)
        if (env.server.upyunDomain && env.server.upyunDomain != '') {
            //局域网模式修改图片服务器地址
            client.setDomain(env.server.upyunDomain)
        }

        try {
            let totalCount = await api.countStudents(env.examId, true, undefined)
            this.emit('total', totalCount)

            let count = 0
            let pageNumber = 0
            this.emit('count', 0)
            while (true) {
                pageNumber++

                let array = await api.getStudents(env.examId, pageNumber, 10, true, undefined, watermark === true, watermark === true)
                if (array == undefined || array.length == 0) {
                    break
                }
                for (let i = 0; i < array.length; i++) {
                    let promises = []
                    let student = array[i]
                    let examNumber = student['examNumber']
                    if (success[examNumber]) {
                        //在已完成列表中则跳过，不用重复下载
                    } else {
                        student.examId = env.examId
                        for (let i = 1; i <= student.sheetCount; i++) {
                            promises.push(this.downloadFile(config.imageUrl.sheet, template, student, dir, client, bucket, i, watermark))
                        }
                        //等待所有图片下载完毕
                        await Promise.all(promises)

                        //finish.push(examNumber)
                        success[examNumber] = true

                        //实时回写到记录文件中去
                        fs.appendFileSync(doneFile, examNumber + '\r\n')
                    }
                    count++
                    this.emit('count', count)

                    //实时回写到记录文件中去
                    //fs.writeFileSync(doneFile, finish.join('\r\n'))
                }
            }
            this.emit('finish')
        } catch (error) {
            logger.error('download sheet error:' + error)
            this.emit('error', error)
        } finally {
            //回写到记录文件中去
            //fs.writeFileSync(doneFile, finish.join('\r\n'))
        }
    }

    async downloadPackage(dir, template) {
        let bucket = env.server.bucketPrefix + '-package'
        let client = upyun(bucket, config.upyun.operator, config.upyun.password)
        if (env.server.upyunDomain && env.server.upyunDomain != '') {
            client.setDomain(env.server.upyunDomain)
        }

        try {
            let array = await api.getPackages(env.examId, true)
            this.emit('total', array.length)
            let count = 0
            this.emit('count', 0)
            for (let i = 0; i < array.length; i++) {
                let p = array[i]
                p.examId = env.examId
                for (let i = 1; i <= p.picCount; i++) {
                    p.index = i
                    await this.downloadFile(config.imageUrl.package, template, p, dir, client, bucket)
                }
                count++
                this.emit('count', count)
            }
            this.emit('finish')
        } catch (err) {
            logger.error('download package error: ' + err)
            this.emit('error', err)
        }
    }
}

module.exports = function() {
    return new executor()
}