gypsum
Version:
Simple and easy lightweight typescript server side framework on Node.js.
271 lines • 11.1 kB
JavaScript
;
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
Object.defineProperty(exports, "__esModule", { value: true });
const path = require("path");
const fs = require("fs");
const Multer = require("multer");
const mime = require("mime");
const url_1 = require("tools-box/url");
const decorators_1 = require("../decorators");
const models_1 = require("../models");
const types_1 = require("../types");
const state_1 = require("../state");
let File = class File extends models_1.Model {
constructor() {
super(...arguments);
this.origin = `http${state_1.State.config.secure ? 's' : ''}://storage.${state_1.State.config.domain}`;
this.uploader = Multer({
storage: Multer.diskStorage({
destination: state_1.State.storage.storageDir,
filename: (req, file, callback) => {
callback(null, `${Date.now()}`);
}
}),
limits: state_1.State.storage.limits
});
}
multerUploadPaths(ctx, type, options) {
let filePath;
let filesPaths;
if (type === 'single') {
filePath = `${this.origin}/${options}/${ctx._req.file.filename}`;
ctx.ok(new types_1.Response({ data: filePath }));
}
else if (type === 'array') {
let filesPaths = ctx._req.files.map(file => {
return `${this.origin}/${options}/${file.filename}`;
});
ctx.ok(new types_1.Response({ data: filesPaths }));
}
}
uploadOne(body, ctx) {
return new Promise((resolve, reject) => {
ctx._req.userId = ctx.user._id;
ctx.nextHook(this.multerUploadPaths, ['single', body.type]);
this.uploader.single(body.type)(ctx._req, ctx._res, ctx.next);
resolve();
});
}
uploadMany(body, ctx) {
return new Promise((resolve, reject) => {
ctx._req.userId = ctx.user._id;
ctx.nextHook(this.multerUploadPaths, ['array', body.type]);
this.uploader.array(body.type, state_1.State.storage.maxUploadCount)(ctx._req, ctx._res, ctx.next);
resolve();
});
}
dataURLUploadOne(body, ctx) {
return new Promise((resolve, reject) => {
if (!body.folder) {
return reject({
message: 'folder name was not provided!',
code: types_1.RESPONSE_CODES.BAD_REQUEST
});
}
if (state_1.State.storage.folders && state_1.State.storage.folders.indexOf(body.folder) === -1) {
return reject({
message: `folder name '${body.folder}' is not authorized!`,
code: types_1.RESPONSE_CODES.BAD_REQUEST
});
}
if (!body.file) {
return reject({
message: 'file was not provided!',
code: types_1.RESPONSE_CODES.BAD_REQUEST
});
}
let folderPath = path.join(state_1.State.storage.storageDir, body.folder);
let fileName = `${Date.now()}`;
let parts = body.file.split(',');
let data = parts[1];
let mimeType = parts[0].split(':')[1].split(';')[0];
let extension = mime.getExtension(mimeType);
if (extension === 'jpeg')
extension = 'jpg';
let filePath = path.join(folderPath, `${fileName}.${extension}`);
let clientFilePath = `${this.origin}/${body.folder}/${fileName}.${extension}`;
if (state_1.State.storage.mimeTypes && state_1.State.storage.mimeTypes.indexOf(mimeType) === -1) {
return reject({
message: `mime type '${mimeType}' is not authorized!`,
code: types_1.RESPONSE_CODES.BAD_REQUEST
});
}
if (!fs.existsSync(folderPath))
fs.mkdirSync(folderPath);
try {
fs.writeFileSync(path.join(filePath), data, 'base64');
resolve({ data: clientFilePath });
}
catch (err) {
this.$logger.error(err);
this.removeOne(`${body.folder}/${fileName}`)
.then(removed => {
reject({
message: 'error writing file',
original: err,
code: types_1.RESPONSE_CODES.UNKNOWN_ERROR
});
})
.catch(err => reject(err));
}
});
}
dataURLUploadMany(body, ctx) {
return new Promise((resolve, reject) => {
if (!body.folder)
return reject({
message: 'folder name was not provided!',
code: types_1.RESPONSE_CODES.BAD_REQUEST
});
if (state_1.State.storage.folders && state_1.State.storage.folders.indexOf(body.folder) === -1) {
return reject({
message: `folder name '${body.folder}' is not authorized!`,
code: types_1.RESPONSE_CODES.BAD_REQUEST
});
}
if (!body.files || !body.files.length)
return reject({
message: 'files were not provided!',
code: types_1.RESPONSE_CODES.BAD_REQUEST
});
let folderPath = path.join(state_1.State.storage.storageDir, body.folder);
if (!fs.existsSync(folderPath))
fs.mkdirSync(folderPath);
let savedFiles = [];
let clientPaths = [];
for (let i = 0; i < body.files.length && i < state_1.State.storage.maxUploadCount; i++) {
let fileName = `${Date.now()}`;
let parts = body.files[i].split(',');
let data = parts[1];
let mimeType = parts[0].split(':')[1].split(';')[0];
let extension = mime.getExtension(mimeType);
if (extension === 'jpeg')
extension = 'jpg';
let filePath = path.join(folderPath, `${fileName}.${extension}`);
let clientFilePath = `${this.origin}/${body.folder}/${fileName}.${extension}`;
if (state_1.State.storage.mimeTypes && state_1.State.storage.mimeTypes.indexOf(mimeType) === -1) {
return reject({
message: `mime type '${mimeType}' is not authorized!`,
code: types_1.RESPONSE_CODES.BAD_REQUEST
});
}
try {
fs.writeFileSync(path.join(filePath), data, 'base64');
clientPaths.push(clientFilePath);
savedFiles.push(`${body.folder}/${fileName}`);
}
catch (err) {
this.$logger.error(err);
clientPaths = [];
this.removeMany(savedFiles)
.then(removed => {
reject({
message: 'error writing file',
original: err,
code: types_1.RESPONSE_CODES.UNKNOWN_ERROR
});
})
.catch(err => reject(err));
}
}
if (clientPaths.length)
resolve({ data: clientPaths });
});
}
removeOne(filePath, ctx) {
return new Promise((resolve, reject) => {
if (!filePath) {
return reject({
message: 'filePath was not provided',
code: types_1.RESPONSE_CODES.BAD_REQUEST
});
}
filePath = url_1.URL.GetPath(filePath);
let fullPath = path.join(state_1.State.storage.storageDir, filePath);
fs.unlink(fullPath, (err) => {
if (err) {
return reject({
message: 'error removing file ' + filePath,
original: err,
code: types_1.RESPONSE_CODES.UNKNOWN_ERROR
});
}
resolve(true);
});
});
}
removeMany(filesPaths, ctx) {
return new Promise((resolve, reject) => {
if (!filesPaths && filesPaths.length) {
return reject({
message: 'filesPaths was not provided',
code: types_1.RESPONSE_CODES.BAD_REQUEST
});
}
try {
for (let i = 0; i < filesPaths.length; i++) {
let filePath = url_1.URL.GetPath(filesPaths[i]);
let fullPath = path.join(state_1.State.storage.storageDir, filePath);
fs.unlinkSync(fullPath);
}
resolve(true);
}
catch (err) {
return reject({
message: 'error removing files',
original: err,
code: types_1.RESPONSE_CODES.UNKNOWN_ERROR
});
}
});
}
};
__decorate([
decorators_1.SERVICE({
method: 'post',
args: ['body']
})
], File.prototype, "uploadOne", null);
__decorate([
decorators_1.SERVICE({
method: 'post',
args: ['body']
})
], File.prototype, "uploadMany", null);
__decorate([
decorators_1.SERVICE({
method: 'post',
args: ['body']
})
], File.prototype, "dataURLUploadOne", null);
__decorate([
decorators_1.SERVICE({
method: 'post',
args: ['body']
})
], File.prototype, "dataURLUploadMany", null);
__decorate([
decorators_1.SERVICE({
method: 'delete',
args: ['body.filePath']
})
], File.prototype, "removeOne", null);
__decorate([
decorators_1.SERVICE({
method: 'delete',
args: ['body.filesPaths']
})
], File.prototype, "removeMany", null);
File = __decorate([
decorators_1.MODEL({
secure: state_1.State.storage.secure,
authorize: state_1.State.storage.authorize
})
], File);
exports.File = File;
//# sourceMappingURL=file.js.map