CraneAntiCollision/console/routes/attachment/index.js

'use strict';
const request = require('superagent');
// const parse = require('async-busboy');
const path = require('path')
const fs = require('fs');

const UploadPath = {
    project: ['.txt', '.dwg', '.doc', '.docx', '.xls', '.xlsx', ".csv", '.pdf', '.pptx', '.png', '.jpg', '.svg', '.rar', '.zip', '.jpeg', '.mp4'],
    report: ['.doc', '.docx', '.xls', '.xlsx', ".csv", '.pdf'],
    data: ['.txt', '.xls', '.xlsx', ".csv"],
    image: ['.png', '.jpg', '.svg'],
    three: ['.js'],
    video: ['.mp4']
};
const ext = {
    project: ['.txt', '.dwg', '.doc', '.docx', '.xls', '.xlsx', ".csv", '.pdf', '.pptx', '.png', '.jpg', '.svg', '.rar', '.zip', '.jpeg', '.mp4'],
    report: [".doc", ".docx", ".xls", ".xlsx", ".pdf"],
    data: [".txt", ".xls", ".xlsx"],
    image: [".png", ".jpg", ".svg"],
    three: [".js"],
    video: [".mp4"],
    bpmn: [".bpmn", ".bpmn20.xml", ".zip", ".bar"],
    app: [".apk"]
}

module.exports = {
    entry: function (app, router, opts) {
        let download_ = async function (ctx, next) {
            const { fetchUrl } = opts.qiniu;
            const { fetchUrl: aliFetchUrl, bucket, region } = opts.aliOss
            if (ctx.path && ctx.path.includes(fetchUrl)) {
                try {
                    const { filename } = ctx.request.query;
                    const fkey = decodeURI(ctx.path.slice(fetchUrl.length + 1)).replace(/\.json$/, '.js');
                    if (ctx.path) {
                        const extNames = ctx.path.split('.');
                        app.fs.logger.log('info', 'extNames', extNames);
                        if (extNames.length > 0) {
                            let fileType = extNames[extNames.length - 1].toLowerCase();
                            if (fileType === 'pdf') {
                                ctx.type = 'application/pdf';
                                app.fs.logger.log('info', 'application/pdf', fileType);
                            }
                        }
                    }
                    const publicDownloadUrl = await app.fs.attachment.download(fkey);
                    ctx.status = 200;
                    if (filename) ctx.attachment(filename);
                    ctx.body = request.get(publicDownloadUrl);
                } catch (err) {
                    ctx.fs.logger.error(err);
                    ctx.status = 404;
                    ctx.body = { error: 'file not found.' };
                }
            } else if (ctx.path && ctx.path.includes(aliFetchUrl)) {
                const { filename } = ctx.request.query;
                const fkey = decodeURI(ctx.path.slice(aliFetchUrl.length + 1)).replace(/\.json$/, '.js');
                if (ctx.path) {
                    const extNames = ctx.path.split('.');
                    app.fs.logger.log('info', 'extNames', extNames);
                    if (extNames.length > 0) {
                        let fileType = extNames[extNames.length - 1].toLowerCase();
                        if (fileType === 'pdf') {
                            ctx.type = 'application/pdf';
                            app.fs.logger.log('info', 'application/pdf', fileType);
                        }
                    }
                }
                const publicDownloadUrl = `http://${bucket}.${region}.aliyuncs.com/${encodeURIComponent(fkey)}`
                ctx.status = 200;
                ctx.body = request.get(publicDownloadUrl);
            } else {
                await next();
            }
        };

        let upload = async function (ctx, next) {
            try {
                // const { files } = await parse(ctx.req);
                // const file = files[0];
                // const extname = path.extname(file.filename).toLowerCase();
                // const fileType = ctx.query.type || "image";
                // const fileFolder = ctx.query.fileFolder || 'common';
                // if (ext[fileType].indexOf(extname) < 0) {
                //     ctx.status = 400;
                //     ctx.body = JSON.stringify({ name: 'UploadFailed', message: '文件格式无效' });
                //     return;
                // }
                // const date = new Date().toLocaleDateString();
                // const time = new Date().getTime();
                // let fileName = time + '_' + file.filename;
                // let saveFile = path.join(__dirname, '../../', `/client/assets/files/${fileFolder}`, fileName);
                // const pathUrl = `./client/assets/files/${fileFolder}`;

                // const res1 = fs.existsSync(`./client/assets/files/${fileFolder}`);
                // !res1 && fs.mkdirSync(`./client/assets/files/${fileFolder}`);
                // const res = fs.existsSync(pathUrl);
                // !res && fs.mkdirSync(pathUrl);
                // let stream = fs.createWriteStream(saveFile);
                // fs.createReadStream(file.path).pipe(stream);
                // stream.on('error', function (err) {
                //     app.fs.logger.log('error', '[Upload Heatmap]', err);
                // });
                // ctx.status = 200;
                // ctx.body = { filename: path.join(`/assets/files/${fileFolder}`, fileName), name: 'UploadSuccess', message: '上传成功' };
            } catch (err) {
                ctx.status = 500;
                ctx.fs.logger.error(err);
                ctx.body = { err: 'upload error.' };
            }
        }

        let remove = async function (ctx, next) {
            try {
                const fkeys = ctx.request.body;
                let removeUrl = path.join(__dirname, '../../', './client', fkeys.url);
                const res = fs.existsSync(removeUrl);
                if (!res) {
                    ctx.status = 400;
                    ctx.body = JSON.stringify({ name: 'DeleteFailed', message: '文件地址不存在' });
                    return;
                }
                fs.unlink(removeUrl, function (error) {
                    if (error) {
                        console.log(error);
                    }
                })
                ctx.status = 200;
                ctx.body = { name: 'DeleteSuccess.', message: '删除成功' };
            } catch (err) {
                ctx.status = 500;
                ctx.fs.logger.error(err);
                ctx.body = { err: 'upload cleanup error.' };
            }
        }
        let upload_ = async function (ctx, next) {
            let fkey = null;
            try {
                // const { p } = ctx.params;
                // const { files } = await parse(ctx.req);
                // const file = files[0];
                // const extname = path.extname(file.filename).toLowerCase();
                // if (!UploadPath[p]) {
                //     ctx.status = 400;
                //     ctx.body = JSON.stringify({ error: '附件存放的文件夹名称无效' });
                //     return;
                // } else if (UploadPath[p].indexOf(extname) < 0) {
                //     ctx.status = 400;
                //     ctx.body = JSON.stringify({ error: '文件格式无效' });
                //     return;
                // } else {
                //     const fileInfo = await ctx.app.fs.attachment.upload(file, { uploadPath: p });
                //     fkey = fileInfo.key;
                //     ctx.body = { uploaded: fkey };
                // }
            } catch (err) {
                ctx.status = 500;
                ctx.fs.logger.error(err);
                ctx.body = { err: 'upload error.' };
            }
        }

        router.use(download_);
        router.post('/_upload/new', upload);
        router.delete('/_upload/cleanup', remove);
        router.post('/_upload/attachments/:p', upload_);
    }
};