技术标签: koa上传文件 nodejs 文件上传 好玩的JavaScript
代码所在的项目:https://github.com/langyuxiansheng/biu-server-admin 已开源
在用node开发后端服务的时候,可能会用到fs文件系统.我这里用的koa2+ koa-body做的文件上传服务.
废话不多说.直接上源码, 主逻辑在FilesService.js中,代码部分提供思路仅供参考.
config里的配置,主要是代码中有staticPath的部分
server: {
port: 3010, // default: 3000
host: '127.0.0.1', // default: localhost,
jwtPublicKey: 'jwtPublicKey', //公钥
isNuxtRender: !true, //是否启用nuxt渲染
staticPath: path.join(__dirname, `/server/src/public`), //静态文件路径,相对于 Server.js 的路径
crawler: {
start: true, //是否开启爬虫系统
settimeout: 1 //延时多少s启动
}
},
1.Server.js 我是这样命名的,有些的主入口应该是app.js
const path = require('path'); //路径模块
const Koa2 = require('koa'); //koa
const KoaCors = require('koa-cors'); //核心文件
const KoaBody = require('koa-body'); //koa文件上传
const app = new Koa2();
app.use(KoaCors());
app.use(KoaBody({
multipart: true,
strict: false,
formidable: {
uploadDir: path.join(__dirname, `/uploads/tmp/server/src/public`), //设置上传缓存文件夹
maxFileSize: 1024 * 1024 * 10 * 1024 // 设置上传文件大小最大限制,默认1G 1024M
},
jsonLimit: '10mb',
formLimit: '10mb',
textLimit: '10mb'
}));
app.listen(port, host);
目录结构,这是一部分.
路由是这样配置的.
FilesController.js
/**
* 公共信息入口
*/
const KoaRouter = require('koa-router');
const { common: { FilesService } } = require(':services');
const controller = new KoaRouter();
const service = new FilesService();
//文件上传接口(单文件)
controller.post('/uploadFile', async(ctx) => {
ctx.body = await service.uploadFile({ state: ctx.state, files: ctx.request.files });
});
//文件上传接口(多文件)
controller.post('/uploadFiles', async(ctx) => {
ctx.body = await service.uploadFiles({ state: ctx.state, files: ctx.request.files });
});
//文件删除接口(多文件)
controller.delete('/deleteFiles', async(ctx) => {
ctx.body = await service.deleteFiles({ state: ctx.state, body: ctx.request.body });
});
//获取文件列表接口
controller.get('/getFiles', async(ctx) => {
ctx.body = await service.getFiles({ state: ctx.state, query: ctx.request.query });
});
//获取文件列表接口
controller.get('/getFileById/:fileId', async(ctx) => {
ctx.body = await service.getFileById(ctx.params);
});
module.exports = controller;
文件基础表数据模型,作者用的sequelize.js 一个orm工具.
/**
* 文件基础表数据模型
* @param {*} sequelize
* @param {*} dataTypes
* 此模型仅限关系型数据库使用
*/
// const { getTimeStampUUID } = require(':lib/Utils');
module.exports = (sequelize, dataTypes) => {
return sequelize.define('FilesBase', {
//文件ID
fileId: {
type: dataTypes.STRING(50),
allowNull: false,
primaryKey: true
},
//文件名
fileName: {
type: dataTypes.STRING(100),
allowNull: true
},
//文件别名
aliasName: {
type: dataTypes.STRING(100),
allowNull: true
},
//上传人ID
userId: {
type: dataTypes.STRING(50),
allowNull: true
},
//上传人名称
userName: {
type: dataTypes.STRING(100),
allowNull: true
},
//文件大小
size: {
type: dataTypes.INTEGER(20),
allowNull: true
},
//文件类型
type: {
type: dataTypes.STRING(100),
allowNull: true
},
//文件后缀
suffix: {
type: dataTypes.STRING(30),
allowNull: true
},
//文件存放的路径
path: {
type: dataTypes.STRING(200),
allowNull: true
},
//文件状态
status: {
type: dataTypes.INTEGER(2),
allowNull: true
},
//备注
remark: {
type: dataTypes.STRING(255),
allowNull: true
},
//是否删除 true是 false否
isDelete: {
type: dataTypes.BOOLEAN(),
allowNull: true,
defaultValue: () => false
},
//创建时间
createdTime: {
type: dataTypes.INTEGER(),
allowNull: true,
defaultValue: () => (Date.parse(new Date()) / 1000)
},
//修改时间
updatedTime: {
type: dataTypes.INTEGER(),
allowNull: true,
defaultValue: () => (Date.parse(new Date()) / 1000)
}
}, {
tableName: 'files_base'
});
};
文件系统主服务.
FilesService.js 这个是最原始的版本
/**
* 文件服务类
*/
const fs = require('fs');
const path = require('path');
const result = require(':lib/Result');
const config = require(':root/nuxt.config'); //配置文件
const { MODELS_PATH, getExtname, getTimeStampUUID, getYearMonthDay } = require(':lib/Utils');
const { MuHomeDB, SOP } = require(':lib/sequelize');
const FilesBaseModel = MuHomeDB.import(`${MODELS_PATH}/common/FilesBaseModel`);
module.exports = class {
// constructor() {
// FilesBaseModel.sync().then((res) => {
// console.log(`FilesBaseModel 同步成功`, res);
// });
// }
/**
* 单文件上传
* @param {*} param0
*/
async uploadFile({ state, files }) {
const file = files.file; //文件
if (!file) return result.failed(`未发现上传文件!`);
try {
if (Array.isArray(file)) { //只能上传单文件,需要删除临时文件
file.forEach((file) => {
fs.unlink(file.path, (err) => { //上传成功后删除临时文件
if (err) {
throw new Error('删除临时文件异常!');
} else {
console.log(`文件: ${file.path} 删除成功!`);
}
});
});
return result.failed(`只能上传单文件!`);
};
//创建文件夹
const time = getYearMonthDay(); //获取时间
let uploadPath = path.join(config.server.staticPath, `/uploads/`, time.replace(/-/g, '')); //文件上传存放路径
const existsSync = await new Promise((resolve, reject) => {
if (!fs.existsSync(uploadPath)) { //判断文件夹是否存在
fs.mkdir(uploadPath, (err) => {
if (err) {
reject(new Error(err));
} else {
resolve(true);
}
});
} else {
resolve(true);
}
});
if (existsSync) { //确认成功之后再进行操作
const data = await this.__filePromise(file, uploadPath, state.user.data); //调用文件上传方法
await FilesBaseModel.create(data); //保存文件到数据库
return result.success(null, data);
}
return result.failed(`上传文件异常!`);
} catch (error) {
console.log(error);
return result.failed(error);
}
}
/**
* 多文件上传
* @param {*} param0
*/
async uploadFiles({ state, files }) {
if (!files.file) return result.failed(`未发现上传文件!`);
//兼容单文件上传
const fileList = Array.isArray(files.file) ? files.file : [files.file];
try {
//创建文件夹
const time = getYearMonthDay(); //获取时间
let uploadPath = path.join(config.server.staticPath, `/uploads/`, time.replace(/-/g, '')); //文件上传存放路径
const existsSync = await new Promise((resolve, reject) => {
if (!fs.existsSync(uploadPath)) { //判断文件夹是否存在
fs.mkdir(uploadPath, (err) => {
if (err) {
reject(new Error(err));
} else {
resolve(true);
}
});
} else {
resolve(true);
}
});
if (existsSync) { //确认成功之后再进行操作
//多文件上传
const saveFiles = await Promise.all(fileList.map((file) => {
return this.__filePromise(file, uploadPath, state.user.data);
}));
//保存文件到数据库
await FilesBaseModel.bulkCreate(saveFiles);
console.log(saveFiles);
return result.success(null, saveFiles);
}
return result.failed(`上传文件异常!`);
} catch (error) {
console.log(error);
return result.failed(`上传文件出错!`);
}
}
/**
* 异步上传文件
* @param {*} file
*/
__filePromise (file, uploadPath, { userId, userName }) {
return new Promise((resolve, reject) => { //异常上传,同步获取
const { name, size, type } = file;
//创建数据库存储数据
const data = {
userId, //上传者id
userName, //上传者名称
fileId: getTimeStampUUID(),
size, //文件大小
type, //文件类型
fileName: name, //获取原文件名
suffix: getExtname(name), //获取文件后缀名
path: null, //文件路径
aliasName: null, //文件别名
remark: null //源文件路径
};
try {
const reader = fs.createReadStream(file.path); //创建可读文件流
const fileName = `${data.fileId}.${data.suffix}`; //重名名后的文件
const fileSavePath = path.join(uploadPath, fileName); //合成路径 + 时间 + 文件名
data.path = fileSavePath; //存储完整路径
data.aliasName = fileName; //存储别名
reader.pipe(fs.createWriteStream(fileSavePath)); //写入文件
reader.on('end', () => {
reader.close(); //关闭文件
fs.unlink(file.path, (err) => { //上传成功后删除临时文件
if (err) {
reject(new Error('删除临时文件异常!'));
} else {
console.log(`文件: ${file.path} 删除成功!`);
}
});
console.log(`文件:${name} 上传成功!`);
resolve(data);
});
reader.on('error', (err) => { reject(err); });
} catch (error) {
console.log(error);
reject(error);
}
});
}
/**
* 批量删除文件
* @param {*} param0
*/
async deleteFiles({ state, body: { fileIds } }) {
if (!Array.isArray(fileIds)) return result.paramsLack();
try {
const { userId } = state.user.data;
//查询相关文件
const files = await FilesBaseModel.findAll({
where: {
userId,
fileId: { [SOP.in]: fileIds }
// isDelete: false
}
});
if (files && files.length) { //获取数据库里的文件数据
const deleteFiles = files.map((file) => {
return new Promise((resolve, reject) => {
fs.unlink(file.path, (err) => { //删除文件
if (err) {
reject(new Error(`删除文件: ${file.path} 异常!`));
} else {
console.log(`文件: ${file.path} 删除成功!`);
resolve(file);
}
});
});
});
//返回删除文件的结果
const delData = await Promise.all(deleteFiles);
//批量删除数据库的数据
await FilesBaseModel.destroy({
where: {
userId,
fileId: delData.map(file => file.fileId)
}
});
return result.success(null, delData);
}
return result.success(`未发现需要删除的文件!`);
} catch (error) {
console.log(error);
return result.failed(`删除文件出错!`);
}
}
/**
* 获取文件列表
* @param {*} param0
*/
async getFiles({ state, query }) {
const { userId } = state.user.data;
const { keyword, page, limit } = query;
let queryData = {
where: { userId, isDelete: false },
order: [
['createdTime', 'DESC']
],
attributes: { exclude: ['isDelete'] }
};
if (keyword) {
queryData.where['fileName'] = {
[SOP.like]: `%${keyword}%`
};
}
if (page && limit) { //分页
queryData.offset = Number((page - 1) * limit); //开始的数据索引
queryData.limit = Number(limit); //每页限制返回的数据条数
};
try {
const { rows, count } = await FilesBaseModel.findAndCountAll(queryData);
return result.success(null, { list: rows, total: count });
} catch (error) {
console.log(error);
return result.failed(error);
}
}
/**
* 获取文件详情
* @param {*} param0
*/
async getFileById({ fileId }) {
if (!fileId) return result.paramsLack();
try {
const file = await FilesBaseModel.findOne({
where: { fileId, isDelete: false },
attributes: ['fileId', 'path', 'fileName']
});
return result.success(null, file);
} catch (error) {
console.log(error);
return result.failed(error);
}
}
};
上传示例:
Utils.js 工具类
const MD5 = require('blueimp-md5');
const UUID = require('uuid');
const JWT = require('jsonwebtoken');
const config = require(':root/nuxt.config');
/**
* 工具类
*/
const Utils = {
//获取models路径
SRC_PATH: `${process.cwd()}/server/src`,
MODELS_PATH: `${process.cwd()}/server/src/models`,
/**
* 获取jwt数据
* @param {*} authorization
*/
getJwtData(authorization) {
if (!authorization) return null;
return JWT.verify(authorization, config.server.jwtPublicKey);
},
/**
* 签发jwt
* @param {*} data 你要保存到token的数据
* @param {*} expiresIn 秒到期时间
*/
signJWT(data, expiresIn) {
const time = 60 * 30; //默认为30分钟的有效期
const sign = { data: { data }, publicKey: config.server.jwtPublicKey, expiresIn: { expiresIn: expiresIn || time } };
return JWT.sign(sign.data, sign.publicKey, sign.expiresIn);
},
/**
* 取随机数
*/
getRandomNum() {
let Min = 10000000;
let Max = 99999999;
let Range = Max - Min;
let Rand = Math.random();
return (Min + Math.round(Rand * Range));
},
/**
* 获取MD5加密
*/
getMd5(str) {
return MD5(`${str}_SERVICE.MU.HOME`).toUpperCase();
},
/**
* 获取随机UUID 可能会重复
*/
getRandomUUID(isLowerCase) {
// return UUID.v4().replace(/-/g, '');
const str = Utils.getMd5(UUID.v4());
return isLowerCase ? str : str.toUpperCase();
},
/**
* 根据时间戳生成UUID
* @param {*} isLowerCase 是否小写
*/
getTimeStampUUID(isLowerCase) {
// const str = UUID.v1().replace(/-/g, '');
const str = Utils.getMd5(UUID.v1());
return isLowerCase ? str : str.toUpperCase();
},
/**
* 获取当前时间戳 毫秒
*/
getTimeStamp() {
return Date.parse(new Date());
},
/**
* 获取年月日 2019-09-25
* @param {*} connect 连接符
*/
getYearMonthDay(connect) {
const str = connect || '-';
const date = new Date();
const Y = date.getFullYear();
const M = date.getMonth() + 1;
const D = date.getDay();
return `${Y}${str}${M > 10 ? M : '0' + M}${str}${D > 10 ? D : '0' + D}`;
},
/**
* 获取当前年月日 时分秒
* @param {*} c1 连接符
* @param {*} c2 连接符
*/
getYearMonthDayAndHMI(c1, c2) {
const str = c1 || ':';
const date = new Date();
const H = date.getHours();
const M = date.getMinutes();
const I = date.getSeconds();
const YMD = Utils.getYearMonthDay(c2);
return `${YMD} ${H > 10 ? H : '0' + H}${str}${M > 10 ? M : '0' + M}${str}${I > 10 ? I : 'I' + I}`;
},
/**
* 截取字符串, 多余的部分用...代替
* @param {*} str
* @param {*} len
*/
setString(str, len) {
let StrLen = 0;
let s = '';
for (let i = 0; i < str.length; i++) {
if (str.charCodeAt(i) > 128) {
StrLen += 2;
} else {
StrLen++;
}
s += str.charAt(i);
if (StrLen >= len) {
return s + '...';
}
}
return s;
},
/**
* 格式化设置
* @param {*} GetOptions
*/
optionFormat(GetOptions) {
let options = '{';
for (let n = 0; n < GetOptions.length; n++) {
options = options + '\'' + GetOptions[n].option_name + '\':\'' + GetOptions[n].option_value + '\'';
if (n < GetOptions.length - 1) {
options = options + ',';
}
}
return JSON.parse(options + '}');
},
/**
* 数组去重
* @param {*} arr
*/
hovercUnique(arr) {
let n = {};
let r = [];
for (let i = 0; i < arr.length; i++) {
if (!n[arr[i]]) {
n[arr[i]] = true;
r.push(arr[i]);
}
}
return r;
},
/**
* 获取json长度
* @param {*} jsonData
*/
getJsonLength(jsonData) {
let arr = [];
for (let item in jsonData) {
arr.push(jsonData[item]);
}
return arr.length;
},
/**
* 线性数据转化为树
* @param {Object} source 源数据
* @param {Object} parentKey 父级id key
* @param {childrenKey} childrenKey 子集key
* @param {Object} pId 父级标识符
*/
listToTree(source, parentKey, childrenKey, pId) {
let data = JSON.parse(JSON.stringify(source));
let tree = [];
let temp = null;
for (let i = 0; i < data.length; i++) {
if (data[i][parentKey] == pId) {
let obj = data[i];
temp = Utils.listToTree(data, parentKey, childrenKey, data[i][childrenKey]);
if (temp.length > 0) {
obj.children = temp;
}
tree.push(obj);
}
}
return tree;
},
/**
* 移除对象中的无效属性
* @param obj
* @return {*}
*/
removeEmpty(obj) {
Object.keys(obj).forEach(function(key) {
(obj[key] && typeof obj[key] === 'object') && Utils.removeEmpty(obj[key]) ||
(obj[key] === undefined || obj[key] === null || obj[key] === '') && delete obj[key];
});
return obj;
},
/**
* 深度拷贝
* @param {*} obj
*/
deepCloneObject(object) {
return JSON.parse(JSON.stringify(object));
// const obj = JSON.parse(JSON.stringify(object));
// let objClone = Array.isArray(obj) ? [] : {};
// if (obj && typeof obj === 'object') {
// for (let key in obj) {
// if (obj.hasOwnProperty(key)) {
// //判断ojb子元素是否为对象,如果是,递归复制
// if (obj[key] && typeof obj[key] === 'object') {
// objClone[key] = Utils.deepCloneObject(obj[key]);
// } else {
// //如果不是,简单复制
// objClone[key] = obj[key];
// }
// }
// }
// }
// return objClone;
},
/**
* 字符转小写
*/
getLC(val) {
if (!val) throw Error(`字符串不存在 val${val}`);
return (val).toLowerCase();
},
/**
* 字符转大写
* @param {*} val
*/
getUC(val) {
if (!val) throw Error(`字符串不存在 val${val}`);
return (val).toLocaleUpperCase();
},
/**
* js生成随机数
* @param {*} lower
* @param {*} upper
*/
random(lower, upper) {
return Math.floor(Math.random() * (upper - lower)) + lower;
},
/**
* 生成文件名
* @param {*} isLowerCase
*/
getFileNameUUID32(nameExtension, isLowerCase) {
const str = Utils.getMd5(UUID.v1());
const name = isLowerCase ? str : str.toUpperCase();
return `BIUXS_WEB_${name}.${nameExtension}`;
},
// 转为unicode 编码
encodeUnicode(str) {
var res = [];
for (var i = 0; i < str.length; i++) {
res[i] = ('00' + str.charCodeAt(i).toString(16)).slice(-4);
}
return '\\u' + res.join('\\u');
},
// 解码
decodeUnicode(str) {
str = str.replace(/\\/g, '%');
//转换中文
str = unescape(str);
//将其他受影响的转换回原来
str = str.replace(/%/g, '\\');
//对网址的链接进行处理
str = str.replace(/\\/g, '');
return str;
},
/**
* 获取文件的后缀名
* @param {*} filename
*/
getExtname(filename) {
if (!filename || typeof filename != 'string') return false;
const a = filename.split('').reverse().join('');
const b = a.substring(0, a.search(/\./)).split('').reverse().join('');
return b;
}
};
module.exports = Utils;
以上是部分源码.有不明白的地方.或者可以优化的地方请留言给出您宝贵的意见或者建议.
再分享一个文件操作的工具类
const fs = require('fs');
// 图片文件夹路径
const path = require('path');
const request = require('request');
const { SRC_PATH, getFileNameUUID32 } = require(':lib/Utils');
/**
* 文件操作工具类
*/
const FileUtils = {
/**
* 读取目录
* @param {*} path
*/
async readdir(readPath) {
return new Promise((resolve, reject) => {
fs.readdir(readPath, (err, files) => {
if (err) {
console.log(`获取文件列表失败`);
reject(err);
} else {
resolve(files);
}
});
});
},
/**
* 获取文件信息
* @param {*} path
*/
async getfileStat(filepath) {
return new Promise((resolve, reject) => {
fs.stat(filepath, (eror, stats) => {
if (eror) {
console.log(`获取文件stats失败`);
reject(eror);
} else {
if (stats.isFile()) { //是文件
resolve({ isFile: true, filepath, ...stats });
} else if (stats.isDirectory()) {
resolve({ isFile: false, filepath, ...stats });
} else {
reject(new Error(`未知类型!`));
}
}
});
});
},
/**
* 读取文件内容
* @param {*} path
* @param encode 编码格式
* @returns { code,data}
*/
async readerFile(fileFullPath, encode) {
return new Promise((resolve, reject) => {
fs.readFile(fileFullPath, (err, data) => {
if (err) {
console.log(`读取文件:${fileFullPath}内容失败,${err}`);
reject(err);
} else if (encode) {
console.log(`读取文件:${fileFullPath}成功!`);
resolve({ code: 200, data: data.toString(encode || 'utf-8') });
} else {
resolve({ code: 200, data });
}
});
});
},
/**
* 创建文件夹
* @param {*} filepath
* @returns Boolean
*/
async createDir(filepath) {
return new Promise((resolve, reject) => {
fs.mkdir(filepath, (err) => {
if (err) {
console.log(`创建文件夹:${filepath}失败!`);
reject(err);
} else {
console.log(`创建文件夹:${filepath}成功!`);
resolve(true);
}
});
});
},
/**
* 判断一个文件夹是否存在
* @param {*} dirpath 文件夹路径
* @param {*} isCreateDir 如果不存在就创建
*/
async isDirExists(dirpath, isCreateDir) {
return new Promise(async (resolve, reject) => {
if (!fs.existsSync(dirpath)) { //判断文件夹是否存在
if (isCreateDir) {
const res = await FileUtils.createDir(dirpath);
if (res) {
resolve(res);
} else {
reject(res);
}
} else {
resolve(false);
}
} else {
resolve(true);
}
});
},
/**
* 删除文件
* @param {*} fileFullPath 文件的路径
* @returns {code }
*/
async deleteFile(fileFullPath) {
return new Promise((resolve, reject) => {
fs.unlink(fileFullPath, (err) => { //上传成功后删除临时文件
if (err) {
console.log(`删除文件:${fileFullPath}异常!`);
reject(err);
} else {
console.log(`删除文件:${fileFullPath}成功!`);
resolve({ code: 200, path: fileFullPath });
}
});
});
},
/**
* 写内容到文件
* @param {*} path
* @param encode 编码格式
* @returns { code,data}
*/
async writeFile(fileFullPath, content) {
return new Promise((resolve, reject) => {
fs.writeFile(fileFullPath, content, (err, data) => {
if (err) {
console.log(`写入文件:${fileFullPath}内容失败,${err}`);
reject(err);
} else if (content) {
console.log(`写入文件:${fileFullPath}成功!`);
resolve({ code: 200, data: data.toString(content || 'utf-8') });
} else {
resolve({ code: 200, data });
}
});
});
}
};
module.exports = FileUtils;
重新封装整理后的FilesService.js
/**
* 文件服务类
*/
const fs = require('fs');
const path = require('path');
const crypto = require('crypto');
const result = require(':lib/Result');
const config = require(':config/server.base.config'); //配置文件
const { MODELS_PATH, SRC_PATH, getExtname, getTimeStampUUID, getYearMonthDay, getFileNameUUID32 } = require(':lib/Utils');
const { isDirExists, deleteFile, readerFile } = require(':lib/FileUtils');
const { BiuDB, SOP } = require(':lib/sequelize');
const Email = require(':lib/Email');
const FilesBaseModel = BiuDB.import(`${MODELS_PATH}/common/FilesBaseModel`);
module.exports = class {
constructor() {
console.log(Email);
FilesBaseModel.sync().then((res) => {
console.log(`FilesBaseModel 同步成功`, res);
});
}
/**
* 单文件上传
* @param {*} param0
*/
async uploadFile({ state, files }) {
const file = files.file; //文件
if (!file) return result.failed(`未发现上传文件!`);
try {
if (Array.isArray(file)) { //只能上传单文件,需要删除临时文件
file.forEach((file) => {
deleteFile(file.path); //上传成功后删除临时文件
});
return result.failed(`只能上传单文件!`);
} else if (file.size / 1024 / 1024 < 200) { //单位是M
return result.failed(`上传文件不能超过200M!`);
}
//创建文件夹
const time = getYearMonthDay(); //获取时间
let uploadPath = path.join(config.staticPath, `/uploads/`, time.replace(/-/g, '')); //文件上传存放路径
const existsSync = await isDirExists(uploadPath, true); //判断文件夹是否存在,不存在就创建
if (existsSync) { //确认成功之后再进行操作
const data = await this.__filePromise(file, uploadPath, state.user.data); //调用文件上传方法
await FilesBaseModel.create(data); //保存文件到数据库
return result.success(null, data);
}
return result.failed(`上传文件异常!`);
} catch (error) {
console.log(error);
return result.failed(error);
}
}
/**
* 多文件上传
* @param {*} param0
*/
async uploadFiles({ state, files }) {
if (!files.file) return result.failed(`未发现上传文件!`);
//兼容单文件上传
const fileList = Array.isArray(files.file) ? files.file : [files.file];
try {
const maxSize = fileList.map(item => item.size).reduce((a, b) => (a + b), 0);
if (maxSize / 1024 / 1024 < 200) { //单位是M
fileList.forEach((file) => {
deleteFile(file.path); //上传成功后删除临时文件
});
return result.failed(`批量上传文件总大小不能超过200M!`);
}
//创建文件夹
const time = getYearMonthDay(); //获取时间
let uploadPath = path.join(config.staticPath, `/uploads/`, time.replace(/-/g, '')); //文件上传存放路径
const existsSync = await isDirExists(uploadPath, true); //判断文件夹是否存在,不存在就创建
if (existsSync) { //确认成功之后再进行操作
//多文件上传
const saveFiles = await Promise.all(fileList.map((file) => {
return this.__filePromise(file, uploadPath, state.user.data);
}));
//保存文件到数据库
await FilesBaseModel.bulkCreate(saveFiles);
console.log(saveFiles);
return result.success(null, saveFiles);
}
return result.failed(`上传文件异常!`);
} catch (error) {
console.log(error);
return result.failed(`上传文件出错!`);
}
}
/**
* 异步上传文件
* @param {*} file
*/
__filePromise (file, uploadPath, { userId, userName }) {
return new Promise((resolve, reject) => { //异常上传,同步获取
const md5sum = crypto.createHash('md5'); //创建文件指纹读取对象
const { name, size, type } = file;
//创建数据库存储数据
const data = {
userId, //上传者id
userName, //上传者名称
fileId: getTimeStampUUID(),
size, //文件大小
type, //文件类型
fileName: name, //获取原文件名
suffix: getExtname(name), //获取文件后缀名
path: null, //文件路径
aliasName: null, //文件别名
remark: null //源文件路径
};
try {
console.log(`正在上传${name}`);
const reader = fs.createReadStream(file.path); //创建可读文件流
const fileName = getFileNameUUID32(data.suffix); //重名名后的文件
const fileSavePath = path.join(uploadPath, fileName); //合成路径 + 时间 + 文件名
data.path = fileSavePath.split('public')[1]; //存储完整路径
data.aliasName = fileName; //存储别名
reader.pipe(fs.createWriteStream(fileSavePath)); //写入文件
reader.on('data', (chunk) => { md5sum.update(chunk); }); //读取文件流
reader.on('end', () => {
data.fileMD5 = md5sum.digest('hex').toUpperCase();
console.log(`fileMD5:`, data.fileMD5);
reader.close(); //关闭文件
deleteFile(file.path); //上传成功后删除临时文件
console.log(`文件:${name} 上传成功!`);
resolve(data);
});
reader.on('error', (err) => { reject(err); });
} catch (error) {
console.log(error);
reject(error);
}
});
}
/**
* 批量删除文件
* @param {*} param0
*/
async deleteFiles({ state, body: { ids } }) {
if (!Array.isArray(ids)) return result.paramsLack();
try {
const { userId, isAdmin, roleName } = state.user.data;
const queryData = {
where: {
userId,
fileId: { [SOP.in]: ids },
isDelete: false
}
};
if (isAdmin && (roleName === '超级管理员')) { //超级管理员会获取所有的文件
delete queryData.where['userId'];
delete queryData.where['isDelete'];
}
//查询相关文件
const files = await FilesBaseModel.findAll(queryData);
if (files && files.length) { //获取数据库里的文件数据
if (isAdmin && (roleName === '超级管理员')) { //只有超级管理员才能真正的删除文件,普通用户为软删除
const deleteFiles = files.map((file) => {
return new Promise(async (resolve, reject) => {
try {
const res = await deleteFile(path.join(config.staticPath, file.path)); //上传成功后删除临时文件
if (res && res.code == 200) {
await FilesBaseModel.destroy({ where: { fileId: file.fileId } });
resolve(file);
} else {
reject(res);
}
} catch (error) {
reject(error);
}
});
});
//返回删除文件的结果
const delData = await Promise.all(deleteFiles);
//批量删除数据库的数据
return result.success(null, delData);
} else {
//批量软删除
await FilesBaseModel.update({ isDelete: true }, { where: { fileId: ids } });
return result.success(null);
}
}
return result.success(`未发现需要删除的文件!`);
} catch (error) {
console.log(error);
return result.failed(`删除部分文件出错!`);
}
}
/**
* 获取文件列表
* @param {*} param0
*/
async getFiles({ state, query }) {
const { userId, isAdmin, roleName } = state.user.data;
const { keyword, isDelete, page, limit } = query;
let queryData = {
where: { userId, isDelete: false },
order: [
['createdTime', 'DESC']
]
// attributes: { exclude: ['isDelete'] }
};
if (isAdmin && (roleName === '超级管理员')) {
delete queryData.where['userId']; //超级管理员会获取所有的文件
delete queryData.where['isDelete'];
}
if (keyword) {
queryData.where['fileName'] = {
[SOP.like]: `%${keyword}%`
};
}
if (isDelete != undefined || isDelete != null) {
console.log(isDelete);
queryData.where['isDelete'] = isDelete != 0;
}
if (page && limit) { //分页
queryData.offset = Number((page - 1) * limit); //开始的数据索引
queryData.limit = Number(limit); //每页限制返回的数据条数
};
try {
const { rows, count } = await FilesBaseModel.findAndCountAll(queryData);
return result.success(null, { list: rows, total: count });
} catch (error) {
console.log(error);
return result.failed(error);
}
}
/**
* 获取文件详情
* @param {*} param0
*/
async getFileById({ fileId }) {
if (!fileId) return result.paramsLack();
try {
const file = await FilesBaseModel.findOne({
where: { fileId, isDelete: false },
attributes: ['fileId', 'path', 'fileName']
});
return result.success(null, file);
} catch (error) {
console.log(error);
return result.failed(error);
}
}
/**
* 读取文件内容
* @param {*} param0
*/
async readeFileContent({ filePath }) {
if (!filePath) return result.paramsLack();
try {
const { code, data } = await readerFile(path.join(SRC_PATH, '/public', filePath), 'utf-8');
if (code == 200) {
return result.success(null, data);
}
return result.failed('读取文件失败!'); // return result.success(null, file);
} catch (error) {
console.log(error);
return result.failed(error);
}
}
};
文章浏览阅读2w次,点赞7次,收藏51次。四个步骤1.创建C++ Win32项目动态库dll 2.在Win32项目动态库中添加 外部依赖项 lib头文件和lib库3.导出C接口4.c#调用c++动态库开始你的表演...①创建一个空白的解决方案,在解决方案中添加 Visual C++ , Win32 项目空白解决方案的创建:添加Visual C++ , Win32 项目这......_c#调用lib
文章浏览阅读4.6k次。苹方字体是苹果系统上的黑体,挺好看的。注重颜值的网站都会使用,例如知乎:font-family: -apple-system, BlinkMacSystemFont, Helvetica Neue, PingFang SC, Microsoft YaHei, Source Han Sans SC, Noto Sans CJK SC, W..._ubuntu pingfang
文章浏览阅读159次。表单表单概述表单标签表单域按钮控件demo表单标签表单标签基本语法结构<form action="处理数据程序的url地址“ method=”get|post“ name="表单名称”></form><!--action,当提交表单时,向何处发送表单中的数据,地址可以是相对地址也可以是绝对地址--><!--method将表单中的数据传送给服务器处理,get方式直接显示在url地址中,数据可以被缓存,且长度有限制;而post方式数据隐藏传输,_html表单的处理程序有那些
文章浏览阅读1.2k次。使用说明:开启Google的登陆二步验证(即Google Authenticator服务)后用户登陆时需要输入额外由手机客户端生成的一次性密码。实现Google Authenticator功能需要服务器端和客户端的支持。服务器端负责密钥的生成、验证一次性密码是否正确。客户端记录密钥后生成一次性密码。下载谷歌验证类库文件放到项目合适位置(我这边放在项目Vender下面)https://github.com/PHPGangsta/GoogleAuthenticatorPHP代码示例://引入谷_php otp 验证器
文章浏览阅读4.3k次,点赞5次,收藏11次。matplotlib.plot画图横坐标混乱及间隔处理_matplotlib更改横轴间距
文章浏览阅读2.2k次。①Storage driver 处理各镜像层及容器层的处理细节,实现了多层数据的堆叠,为用户 提供了多层数据合并后的统一视图②所有 Storage driver 都使用可堆叠图像层和写时复制(CoW)策略③docker info 命令可查看当系统上的 storage driver主要用于测试目的,不建议用于生成环境。_docker 保存容器
文章浏览阅读834次,点赞27次,收藏13次。网络拓扑结构是指计算机网络中各组件(如计算机、服务器、打印机、路由器、交换机等设备)及其连接线路在物理布局或逻辑构型上的排列形式。这种布局不仅描述了设备间的实际物理连接方式,也决定了数据在网络中流动的路径和方式。不同的网络拓扑结构影响着网络的性能、可靠性、可扩展性及管理维护的难易程度。_网络拓扑csdn
文章浏览阅读1.8k次,点赞5次,收藏8次。IOS系统Date的坑要创建一个指定时间的new Date对象时,通常的做法是:new Date("2020-09-21 11:11:00")这行代码在 PC 端和安卓端都是正常的,而在 iOS 端则会提示 Invalid Date 无效日期。在IOS年月日中间的横岗许换成斜杠,也就是new Date("2020/09/21 11:11:00")通常为了兼容IOS的这个坑,需要做一些额外的特殊处理,笔者在开发的时候经常会忘了兼容IOS系统。所以就想试着重写Date函数,一劳永逸,避免每次ne_date.prototype 将所有 ios
文章浏览阅读5.3k次。方法一:用PLSQL Developer工具。 1 在PLSQL Developer的sql window里输入select * from test for update; 2 按F8执行 3 打开锁, 再按一下加号. 鼠标点到第一列的列头,使全列成选中状态,然后粘贴,最后commit提交即可。(前提..._excel导入pl/sql
文章浏览阅读83次。Git常用命令速查手册1、初始化仓库git init2、将文件添加到仓库git add 文件名 # 将工作区的某个文件添加到暂存区 git add -u # 添加所有被tracked文件中被修改或删除的文件信息到暂存区,不处理untracked的文件git add -A # 添加所有被tracked文件中被修改或删除的文件信息到暂存区,包括untracked的文件...
文章浏览阅读202次。分享119个ASP.NET源码总有一个是你想要的_千博二手车源码v2023 build 1120
文章浏览阅读1.8k次。版权声明:转载请注明出处 http://blog.csdn.net/irean_lau。目录(?)[+]1、缺省构造函数。2、缺省拷贝构造函数。3、 缺省析构函数。4、缺省赋值运算符。5、缺省取址运算符。6、 缺省取址运算符 const。[cpp] view plain copy_空类默认产生哪些类成员函数