@digione/node-custom-api 0.0.1

package/utils/file.js

@@ -0,0 +1,772 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileUtil = exports.getBuffer = void 0;
+const tslib_1 = require("tslib");
+const file_1 = require("../models/system/file");
+const folder_1 = require("../models/system/folder");
+const errors_1 = require("../errors");
+const config_1 = require("./config");
+const helper_1 = require("./helper");
+const db_1 = require("./db");
+const setting_1 = require("./setting");
+const sequelize_1 = require("sequelize");
+const aws = require("aws-sdk");
+const jimp = require("jimp/dist");
+const mime = require("mime-types");
+const _ = require("lodash");
+const uuid_1 = require("uuid");
+const path = require("path");
+const fs = require("fs");
+const getBuffer = (image, { mimetype = "" } = {}) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    if (mimetype === "gif") {
+        mimetype = jimp.MIME_PNG;
+    }
+    else {
+        mimetype = jimp.AUTO;
+    }
+    return new Promise((resolve, reject) => {
+        image.getBuffer(mimetype, (err, buffer) => {
+            if (err) {
+                reject(err);
+            }
+            resolve(buffer);
+        });
+    });
+});
+exports.getBuffer = getBuffer;
+class FileUtil {
+    constructor(ref = "", option) {
+        this.location = (0, helper_1.getENV)('AWS_LOCATION', 'default');
+        this.bucket = (0, helper_1.getENV)('AWS_BUCKET');
+        this.ACL = (0, helper_1.getENV)('AWS_ACL', 'public-read');
+        this.ref = ref;
+        this.option = option || {};
+        this.settingUtil = new setting_1.SettingUtil(this.ref);
+    }
+    getStorage() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let storage = { driver: this.driver, setting: this.setting };
+            if (!storage['setting']) {
+                this.setting = yield this.settingUtil.findSetting(["files_driver", "files_url", "files_object_access_key", "files_object_secret_key", "files_object_url"]);
+                this.driver = this.setting["files_driver"];
+                this.setting = _.omit(this.setting, ["files_driver"]);
+                storage['setting'] = this.setting;
+                if (this.driver == "object") {
+                    this.driver = "local";
+                    if (this.setting['files_object_secret_key'] && this.setting['files_object_access_key'] && this.setting['files_object_url']) {
+                        this.driver = "object";
+                        let url = this.setting['files_object_url'].replace(/ /g, "");
+                        this.url = String(url).replace("{{bucket}}", this.bucket);
+                        this.setting['files_object_url'] = url.replace("https://{{bucket}}.", "");
+                        this.s3 = new aws.S3({
+                            secretAccessKey: this.setting['files_object_secret_key'],
+                            accessKeyId: this.setting['files_object_access_key'],
+                            endpoint: this.setting['files_object_url']
+                        });
+                    }
+                }
+                storage['driver'] = this.driver;
+            }
+            return storage;
+        });
+    }
+    getFileAttribute() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return yield (0, db_1.getFieldAll)(this.ref + "_" + file_1.FileModel.getTableName());
+        });
+    }
+    getFilePath(item) {
+        let result = [item['path']], thumb = item['thumb'] || {};
+        result = result.concat(Object.keys(thumb).reduce((total, key) => total.concat(thumb[key]), []));
+        return result;
+    }
+    getSettingImgKit() {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let setting = yield this.settingUtil.findSetting(['files_img_kit_url', 'files_img_kit', 'files_img_kit_default_param', 'files_object_url']);
+            if (setting && (setting['files_img_kit'] == '1' && setting['files_img_kit_url'])) {
+                let origin = "";
+                if (setting['files_object_url']) {
+                    origin = setting['files_object_url'].replace(/ /g, "").replace("{{bucket}}", this.bucket);
+                }
+                setting = { url: setting['files_img_kit_url'], origin, default_param: setting['files_img_kit_default_param'] };
+            }
+            return setting;
+        });
+    }
+    convertImgKit(path, setting = {}) {
+        if (typeof path != "string")
+            return path;
+        let rep = setting['origin'] || this.url;
+        let temp = path.replace(rep, setting['url']);
+        if (temp != path) {
+            path = temp;
+            if (setting['default_param']) {
+                path = path + setting['default_param'];
+            }
+        }
+        return path;
+    }
+    afterQueryFile(data = {}, { tag = {}, file_link = false } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            data['custom'] = data['custom'] || {};
+            data['tags'] = data['tags'] || [];
+            if (data['filename'] == data['path']) {
+                data['path'] = (this.setting['files_url'] || this.option.hostname) + '/uploads/' + data['path'];
+            }
+            if (Object.keys(tag).length && (data['tags'] && data['tags'].length)) {
+                data['tags'] = data['tags'].map(i => {
+                    if (tag[i['slug']])
+                        i['title'] = tag[i['slug']];
+                    return i;
+                });
+            }
+            if (file_link && data['file_link'] == 'yes' && data['file_id']) {
+                data['file_data'] = yield file_1.FileModel.schema(this.ref, "_").findOne({
+                    where: { id: data['file_id'] }, raw: true
+                });
+            }
+            return data;
+        });
+    }
+    uploadRaw(files) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let reqs = [], results = [];
+            for (let file of files) {
+                let extension = mime.extension(file.mimetype);
+                let input = {
+                    Bucket: this.bucket,
+                    Key: this.ref + "/" + (0, helper_1.getDateTime)().format('X') + '.' + (0, helper_1.getSlug)(32) + '.' + extension,
+                    Body: file.buffer,
+                    ACL: this.ACL,
+                    ContentType: file.mimetype
+                };
+                let type = yield this.allowedFileType(extension);
+                reqs.push(Object.assign(Object.assign(Object.assign({}, input), file), { type, extension: "." + extension }));
+                results.push(input);
+            }
+            results = yield this.upload(results);
+            return _.merge(reqs, results);
+        });
+    }
+    upload(files) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (files.length) {
+                try {
+                    let storage = yield this.getStorage();
+                    let data = yield Promise.all(files.map((file) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                        if (storage['driver'] == "object") {
+                            let res = yield this.s3.upload(file).promise();
+                            return Object.assign(Object.assign({}, res), file);
+                        }
+                        else {
+                            let destination = path.join(config_1.config.fileDestination, file.Key);
+                            let segment = destination.split('/'), dir = segment.slice(0, segment.length - 1).join('/');
+                            let exist = yield fs.existsSync(dir);
+                            if (!exist) {
+                                yield fs.mkdirSync(dir, { recursive: true });
+                            }
+                            yield fs.writeFileSync(destination, file.Body);
+                            return Object.assign({ Location: file.Key }, file);
+                        }
+                    })));
+                    return data;
+                }
+                catch (err) {
+                    return Promise.reject(errors_1.generalError.BAD_REQUEST);
+                }
+            }
+            return Promise.reject(errors_1.generalError.BAD_REQUEST);
+        });
+    }
+    uploadThumb(item, title, { extension = "", width = 0, height = 0 } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let files = [];
+            let image, buffer;
+            try {
+                image = yield jimp.read(item);
+                image.resize(width * 2, jimp.AUTO);
+                buffer = yield (0, exports.getBuffer)(image, { mimetype: extension.split('.')[1] });
+            }
+            catch (err) {
+                return null;
+            }
+            files.push({
+                Bucket: this.bucket,
+                Key: title,
+                Body: buffer,
+                ACL: this.ACL,
+                ContentType: "image/" + extension.split('.')[1]
+            });
+            let results = yield this.upload(files);
+            return results[0].Location;
+        });
+    }
+    existImageThumb(item, { width = 0, height = 0, checkExist = true } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (item && item['filename']) {
+                let segment = item['filename'].split("/");
+                let filename = segment[segment.length - 1];
+                segment = filename.split(".");
+                filename = filename.replace("." + segment[segment.length - 1], "");
+                let img_thumb = this.ref + '/thumb/' + filename + '_' + width + 'x' + height + item['extension'];
+                let storage = yield this.getStorage();
+                if (storage['driver'] == "object") {
+                    if (checkExist) {
+                        try {
+                            yield this.s3.headObject({
+                                Bucket: this.bucket,
+                                Key: img_thumb
+                            }).promise();
+                            return this.url + img_thumb;
+                        }
+                        catch (err) { }
+                    }
+                    return yield this.uploadThumb(item['path'], img_thumb, { extension: item['extension'], width, height });
+                }
+                else {
+                    if (checkExist) {
+                        let destination = path.join(config_1.config.fileDestination, img_thumb);
+                        let exist = yield fs.existsSync(destination);
+                        if (exist) {
+                            return img_thumb;
+                        }
+                    }
+                    try {
+                        let destination = path.join(config_1.config.fileDestination, item['filename']);
+                        let buffer = yield fs.readFileSync(destination);
+                        return yield this.uploadThumb(buffer, img_thumb, { extension: item['extension'], width, height });
+                    }
+                    catch (err) { }
+                }
+            }
+            return null;
+        });
+    }
+    findImageThumb(item, { width = 0, height = 0, upsert = true }) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (item) {
+                let result = item['thumb'] || {}, path = item['path'];
+                if (typeof item['thumb'] == "undefined") {
+                    let query = yield file_1.FileModel.schema(this.ref, "_").findOne({ where: { id: item['id'] }, attributes: ['path', 'thumb'], raw: true });
+                    if (query)
+                        path = query['path'], result = query['thumb'] || {};
+                }
+                let thumb = result[width + 'x' + height] || (yield this.existImageThumb(item, { width, height }));
+                if (upsert && !result[width + 'x' + height] && item['id']) {
+                    result[width + 'x' + height] = thumb;
+                    yield (0, db_1.update)(this.ref, file_1.FileModel.getTableName().toString(), { thumb: JSON.stringify(result) }, { where: { id: item['id'] } });
+                }
+                if (item['filename'] == path) {
+                    yield this.getStorage();
+                    let data = yield this.afterQueryFile({ filename: thumb, path: thumb });
+                    thumb = data.path;
+                }
+                return thumb;
+            }
+            return null;
+        });
+    }
+    findImageThumbByFolderSlug(slug, { where = {}, width = 0, height = 0, parent_folder = "", tags = [], group = null } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                if (parent_folder) {
+                    let query = yield folder_1.FolderModel.schema(this.ref, "_").findOne({ where: { slug: parent_folder }, attributes: ['id'], raw: true });
+                    if (!query)
+                        return null;
+                    where['$folder.parent_id$'] = query['id'];
+                }
+                where = this.beforeFindFile(where, { tags, group });
+                let result = yield file_1.FileModel.schema(this.ref, "_").findOne({
+                    raw: true, attributes: ['id', 'extension', 'filename', 'path', 'thumb'],
+                    where: Object.assign({ '$folder.slug$': slug }, where),
+                    include: [{ as: 'folder', model: folder_1.FolderModel.schema(this.ref, "_"), attributes: [] }],
+                    order: [['sort', 'asc'], ['tags', 'desc']]
+                });
+                return this.findImageThumb(result, { width, height });
+            }
+            catch (err) {
+                return null;
+            }
+        });
+    }
+    findImageThumbByFileId(id, { width = 0, height = 0 }) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const data = yield file_1.FileModel.schema(this.ref, "_").findOne({
+                where: { id }, attributes: ['id', 'extension', 'filename', 'path', 'thumb']
+            });
+            let item = data.toJSON();
+            return this.findImageThumb(item, { width, height });
+        });
+    }
+    beforeFindFile(where = {}, { tags = [], group = undefined } = {}) {
+        if (this.option.organ_id) {
+            where[sequelize_1.Op.and] = (where[sequelize_1.Op.and] || []).concat({ [sequelize_1.Op.or]: [{ organ_id: this.option.organ_id }, { organ_by: this.option.organ_id }] });
+        }
+        if (typeof group != "undefined") {
+            where['group'] = group;
+        }
+        if (tags.length) {
+            let op = tags.reduce((total, tag) => {
+                let value = Object.keys(tag).reduce((total, key) => total.concat([`'${key}'`, `"${tag[key]}"`]), []).join(',');
+                if (value) {
+                    total = total.concat((0, sequelize_1.literal)(`JSON_CONTAINS(tags,JSON_OBJECT(${value}))`));
+                    if (tag['slug'] == "thumbnail") {
+                        total = total.concat((0, sequelize_1.literal)(`tags IS NULL`));
+                    }
+                }
+                return total;
+            }, []);
+            if (op.length) {
+                where[sequelize_1.Op.and] = (where[sequelize_1.Op.and] || []).concat({ [sequelize_1.Op.or]: op });
+            }
+        }
+        return where;
+    }
+    findAllFile({ where = {}, folder = false, full = false, file_link = false, thumb = false, width = 0, height = 0, parent_folder = "", attributes = undefined, limit = undefined, offset = undefined, tag = {}, tags = [], group = undefined } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                let include = [];
+                if (parent_folder || folder)
+                    include.push({ as: 'folder', model: folder_1.FolderModel.schema(this.ref, "_"), attributes: [] });
+                if (parent_folder) {
+                    let query = yield folder_1.FolderModel.schema(this.ref, "_").findOne({ where: { slug: parent_folder }, attributes: ['id'], raw: true });
+                    if (!query)
+                        return [];
+                    where['$folder.parent_id$'] = query['id'];
+                }
+                where = this.beforeFindFile(where, { tags, group });
+                where['is_hidden'] = where['is_hidden'] || "no";
+                let result = yield file_1.FileModel.schema(this.ref, "_").findAll({
+                    attributes, raw: true, where, limit, offset, include, order: [['sort', 'asc'], ['tags', 'desc']]
+                });
+                result.length && (yield this.getStorage());
+                result = yield Promise.all(result.map((item) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    let include = {};
+                    if (thumb && item['type'] == 'i') {
+                        include['thumb'] = yield this.findImageThumb(item, { width, height });
+                    }
+                    let data = yield this.afterQueryFile(Object.assign(Object.assign({}, item), include), { tag, file_link });
+                    if (!full) {
+                        data = data.path;
+                    }
+                    return data;
+                })));
+                return result;
+            }
+            catch (err) {
+                return [];
+            }
+        });
+    }
+    findAndCountAllFileByFolder(slug, { where = {}, file_link = false, parent_folder = "", limit = undefined, offset = undefined, tag = {}, tags = [], group = null } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let where_folder = {};
+            if (parent_folder) {
+                let query = yield folder_1.FolderModel.schema(this.ref, "_").findOne({ where: { slug: parent_folder }, attributes: ['id'], raw: true });
+                if (!query)
+                    return { rows: [], count: 0 };
+                where_folder['parent_id'] = query['id'];
+            }
+            let folder = yield folder_1.FolderModel.schema(this.ref, "_").findOne({ where: Object.assign({ slug }, where_folder), attributes: ['id'], raw: true });
+            if (!folder)
+                return { rows: [], count: 0 };
+            where['folder_id'] = folder['id'];
+            where = this.beforeFindFile(where, { tags, group });
+            where['is_hidden'] = where['is_hidden'] || "no";
+            let data = yield Promise.all([this.findAllFile({ where, full: true, file_link, limit, offset, tag, group }), file_1.FileModel.schema(this.ref, "_").count({ where })]);
+            return { rows: data[0], count: data[1] };
+        });
+    }
+    findAllFileByFolder(slug, { where = {}, full = false, file_link = false, thumb = false, width = 0, height = 0, parent_folder = "", limit = undefined, offset = undefined, tags = [], group = null } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return yield this.findAllFile({ where: Object.assign({ '$folder.slug$': slug }, where), folder: true, full, file_link, thumb, width, height, parent_folder, limit, offset, tags, group });
+        });
+    }
+    findOneFileByFolder(slug, { where = {}, full = false, file_link = false, parent_folder = "", tags = [], group = null } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return (yield this.findAllFile({ where: Object.assign({ '$folder.slug$': slug }, where), folder: true, full, file_link, parent_folder, limit: 1, tags, group }))[0] || null;
+        });
+    }
+    findOneFileById(id, { where = {}, full = true, file_link = false, parent_folder = "", tags = [], group = null } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return (yield this.findAllFile({ where: Object.assign({ id }, where), full, file_link, parent_folder, limit: 1, tags, group }))[0] || null;
+        });
+    }
+    uploadByReq(req, slug, user_id, { parent_id = 0, parent_slug = "", name = undefined, root = false, thumb = false, width = 0, height = 0, input = {}, is_hidden = undefined, tags = undefined, group = undefined } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            req.files = req.file ? [req.file] : (req.files || []);
+            if (req.files.length && slug) {
+                let files = [], reqs = [];
+                if (parent_slug) {
+                    let query = yield this.createFolder(parent_slug, { root: true });
+                    if (query) {
+                        parent_id = query['id'];
+                    }
+                }
+                let folder = yield this.createFolder(slug, { parent_id, root, name });
+                for (let file of req.files) {
+                    let extension = mime.extension(file.mimetype);
+                    let input = {
+                        Bucket: this.bucket,
+                        Key: this.ref + "/" + (0, helper_1.getDateTime)().format('X') + '.' + (0, helper_1.getSlug)(32) + '.' + extension,
+                        Body: file.buffer,
+                        ACL: this.ACL,
+                        ContentType: file.mimetype
+                    };
+                    let type = yield this.allowedFileType(extension);
+                    files.push(input);
+                    reqs.push(Object.assign(Object.assign(Object.assign({}, file), input), { type }));
+                }
+                let results = yield this.upload(files);
+                results = yield this.formatFile(folder['id'], user_id, reqs, results, { input, is_hidden, tags, group });
+                return yield this.insertFileUnique(results, { thumb, width, height });
+            }
+            return Promise.reject(errors_1.generalError.BAD_REQUEST);
+        });
+    }
+    createFolder(slug, { parent_id = 0, root = false, name = undefined, location = this.location, remote_container = this.bucket, hidden = 0, input = {} } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let where = {};
+            let storage = yield this.getStorage();
+            location = (storage['driver'] == 'object') ? location : 'local';
+            if (!root && this.option.organ_id) {
+                where[sequelize_1.Op.and] = (where[sequelize_1.Op.and] || []).concat({ [sequelize_1.Op.or]: [{ organ_id: this.option.organ_id }, { organ_by: this.option.organ_id }] });
+            }
+            let query = yield folder_1.FolderModel.schema(this.ref, "_").findOne({ where: Object.assign({ slug, parent_id, location }, where), attributes: ['id'], raw: true });
+            if (query) {
+                return query;
+            }
+            else {
+                input = Object.assign(Object.assign({}, input), { slug,
+                    parent_id, name: name || _.startCase(_.camelCase(slug)), location, remote_container: (storage['driver'] == 'object') ? remote_container : '', hidden });
+                if (!root) {
+                    if (this.option.organ_id) {
+                        input['organ_id'] = this.option.organ_id;
+                    }
+                    if (this.option.parent_organ_id) {
+                        input['organ_by'] = this.option.parent_organ_id;
+                    }
+                }
+                let query = yield folder_1.FolderModel.schema(this.ref, "_").create(input);
+                if (!query) {
+                    return Promise.reject(errors_1.generalError.BAD_REQUEST);
+                }
+                return query.toJSON();
+            }
+        });
+    }
+    createFileByPath(files, slug, user_id, { parent_slug = "", type = "i", name = undefined, root = false, upload = false, tags = undefined, group = undefined } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let parent_id = null, input = {};
+            if ((files && files.length) && slug) {
+                if (parent_slug) {
+                    let query = yield this.createFolder(parent_slug, { root: true });
+                    if (query) {
+                        parent_id = query['id'];
+                    }
+                }
+                if (upload)
+                    input['upload'] = 1;
+                let folder = yield this.createFolder(slug, { parent_id, root, name });
+                let results = [], reqs = [];
+                files.forEach((item) => {
+                    results.push({ Location: item, Key: item });
+                    reqs.push({ originalname: (0, helper_1.getSlug)(32), mimetype: null, size: 0, type });
+                });
+                results = yield this.formatFile(folder['id'], user_id, reqs, results, { input, tags, group });
+                return yield this.insertFileUnique(results);
+            }
+            return Promise.reject(errors_1.generalError.BAD_REQUEST);
+        });
+    }
+    allowedFileType(extension) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let type;
+            switch (extension) {
+                case "mpga":
+                case "mp2":
+                case "mp3":
+                case "ra":
+                case "rv":
+                case "wav":
+                    type = 'a';
+                    break;
+                case "mpeg":
+                case "mpg":
+                case "mpe":
+                case "mp4":
+                case "flv":
+                case "qt":
+                case "mov":
+                case "avi":
+                case "movie":
+                    type = 'v';
+                    break;
+                case "pdf":
+                case "xls":
+                case "ppt":
+                case "pptx":
+                case "txt":
+                case "text":
+                case "log":
+                case "rtx":
+                case "rtf":
+                case "xml":
+                case "json":
+                case "xsl":
+                case "doc":
+                case "docx":
+                case "xlsx":
+                case "word":
+                case "xl":
+                case "csv":
+                case "pages":
+                case "numbers":
+                    type = 'd';
+                    break;
+                case "bmp":
+                case "gif":
+                case "jpeg":
+                case "jpg":
+                case "jpe":
+                case "png":
+                case "tiff":
+                case "tif":
+                case "ico":
+                    type = 'i';
+                    break;
+                case "psd":
+                case "gtar":
+                case "swf":
+                case "tar":
+                case "tgz":
+                case "xhtml":
+                case "zip":
+                case "css":
+                case "html":
+                case "htm":
+                case "shtml":
+                case "svg":
+                case "rar":
+                    type = 'o';
+                    break;
+            }
+            if (!type) {
+                return Promise.reject(errors_1.generalError.FILE_TYPE_NOT_ALLOW);
+            }
+            return type;
+        });
+    }
+    formatFile(folder_id, user_id, reqs, files, { use_id = true, field = [], formatDateTime = "X", input = {}, is_hidden = undefined, tags = undefined, group = undefined } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                let result = yield Promise.all(files.map((file, key) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                    folder_id = reqs[key].folder ? reqs[key].folder : folder_id;
+                    let id = (0, uuid_1.v4)().replace(/-/gi, '').substring(0, 15);
+                    let organ_id = this.option.organ_id;
+                    let organ_by = this.option.parent_organ_id;
+                    let sort = (0, helper_1.getDateTime)().format(formatDateTime);
+                    let date_added = sort;
+                    let path = file.Location;
+                    if (path && path != file.Key) {
+                        let protocol = 'https://';
+                        let index = path.indexOf(protocol);
+                        path = (index < 0) ? protocol + path : path;
+                    }
+                    let extension = mime.extension(reqs[key].mimetype);
+                    let format = Object.assign(Object.assign({}, input), { folder_id,
+                        user_id,
+                        organ_id,
+                        organ_by,
+                        sort,
+                        date_added, name: reqs[key].originalname || (0, helper_1.getSlug)(32), filename: reqs[key].Key || file.Key || input['filename'], path, mimetype: reqs[key].mimetype, filesize: reqs[key].size, extension: (extension ? "." + extension : ''), type: reqs[key].type || file.type || input['type'], is_hidden,
+                        tags,
+                        group });
+                    if (use_id) {
+                        format['id'] = id;
+                    }
+                    if (reqs[key].mimetype && reqs[key].mimetype.split('/')[0] == "image") {
+                        try {
+                            let body = reqs[key].Body || reqs[key].buffer;
+                            let image = yield jimp.read(body);
+                            format['height'] = image.bitmap.height;
+                            format['width'] = image.bitmap.width;
+                        }
+                        catch (err) { }
+                    }
+                    if (field.length) {
+                        format = _.pick(format, field);
+                    }
+                    return format;
+                })));
+                return result;
+            }
+            catch (err) {
+                return null;
+            }
+        });
+    }
+    insertFileUnique(results, { thumb = false, width = 0, height = 0 } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                let data = yield file_1.FileModel.schema(this.ref, "_").bulkCreate(results);
+                if (!data) {
+                    return Promise.reject(errors_1.generalError.BAD_REQUEST);
+                }
+                let result = data.map(item => item.toJSON());
+                if (thumb) {
+                    // create thumb
+                    result = yield Promise.all(result.map((item) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+                        if (item['type'] == 'i') {
+                            item['thumb'] = null;
+                            let thumb = yield this.findImageThumb(item, { width, height });
+                            return Object.assign(Object.assign({}, item), { thumb });
+                        }
+                        return item;
+                    })));
+                }
+                return result;
+            }
+            catch (err) {
+                if (err.errors && err.errors[0].validatorKey == "not_unique") {
+                    results = results.map(item => (Object.assign(Object.assign({}, item), { id: (0, uuid_1.v4)().replace(/-/gi, '').substring(0, 15) })));
+                    return yield this.insertFileUnique(results, { thumb, width, height });
+                }
+                return Promise.reject(errors_1.generalError.BAD_REQUEST);
+            }
+        });
+    }
+    uploadRawFormat(files, { field = ['name', 'filename', 'path', 'mimetype', 'filesize', 'extension', 'type', 'height', 'width'] } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let query = yield this.uploadRaw(files);
+            return yield this.formatFile(0, 0, files, query, { field });
+        });
+    }
+    updateFile(id, input = {}, { paths = [] } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let query = yield file_1.FileModel.schema(this.ref, "_").findOne({ where: { id }, attributes: ['path', 'thumb'], raw: true });
+            if (!query) {
+                return Promise.reject(errors_1.generalError.NOT_FOUND);
+            }
+            if (input['path'] && input['path'] != query['path']) {
+                input['thumb'] = null;
+                [query].forEach(i => { paths = paths.concat(this.getFilePath(i)); return i['id']; });
+            }
+            if (paths.length)
+                yield this.deleteObjects(paths);
+            return (0, db_1.update)(this.ref, file_1.FileModel.getTableName().toString(), input, { where: { id } });
+        });
+    }
+    updateFolderSlug(old_slug, new_slug) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (old_slug == new_slug) {
+                return 1;
+            }
+            let exist = yield folder_1.FolderModel.schema(this.ref, "_").count({ where: { slug: new_slug } });
+            if (exist > 0) {
+                return Promise.reject(errors_1.generalError.SLUG_DUPLICATE);
+            }
+            yield folder_1.FolderModel.schema(this.ref, "_").update({ slug: new_slug }, { where: { slug: old_slug } });
+            return 1;
+        });
+    }
+    remove({ where = {}, delete_object = false, error = true, tags = [], group = undefined } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            where = this.beforeFindFile(where, { tags, group });
+            let files = yield file_1.FileModel.schema(this.ref, "_").findAll({ where, attributes: ['id', 'path', 'thumb'], raw: true });
+            if (files.length) {
+                let paths = [], id = files.map(i => { paths = paths.concat(this.getFilePath(i)); return i['id']; });
+                yield file_1.FileModel.schema(this.ref, "_").destroy({ where: { id } });
+                if (delete_object || config_1.config.fileDelete) {
+                    yield this.deleteObjects(paths);
+                }
+                return id;
+            }
+            else if (error) {
+                return Promise.reject(errors_1.generalError.NOT_FOUND);
+            }
+            return [];
+        });
+    }
+    removeFileById(id, { tags = [], group = undefined, delete_object = false, error = true } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            return yield this.remove({ where: { id }, tags, group, delete_object, error });
+        });
+    }
+    removeFileByFolder(slug, { where = {}, parent_folder = "", delete_object = false, tags = [], group = undefined } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (parent_folder) {
+                let query = yield folder_1.FolderModel.schema(this.ref, "_").findOne({ where: { slug: parent_folder }, attributes: ['id'], raw: true });
+                if (!query)
+                    return [];
+                where['parent_id'] = query['id'];
+            }
+            let query = yield folder_1.FolderModel.schema(this.ref, "_").findAll({ where: Object.assign({ slug }, where), attributes: ['id'], raw: true });
+            let folder_id = query.map(i => i['id']);
+            if (folder_id.length) {
+                let where_file = { folder_id };
+                return yield this.remove({ where: where_file, tags, group, delete_object, error: false });
+            }
+            return [];
+        });
+    }
+    removeFolder(index, { where = {}, field = "slug", parent_folder = "", delete_object = false } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            try {
+                if (parent_folder) {
+                    let query = yield folder_1.FolderModel.schema(this.ref, "_").findOne({ where: { slug: parent_folder }, attributes: ['id'], raw: true });
+                    if (!query)
+                        return [];
+                    where['parent_id'] = query['id'];
+                }
+                let query = yield folder_1.FolderModel.schema(this.ref, "_").findAll({ where: Object.assign({ [field]: index }, where), attributes: ['id'], raw: true });
+                let folder_id = query.map(i => i['id']);
+                if (folder_id.length) {
+                    yield this.remove({ where: { folder_id }, delete_object, error: false });
+                    yield folder_1.FolderModel.schema(this.ref, "_").destroy({ where: { id: folder_id } });
+                }
+                return folder_id;
+            }
+            catch (err) {
+                return [];
+            }
+        });
+    }
+    deleteObjects(paths, { origin = "" } = {}) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            let storage = yield this.getStorage();
+            if (storage['driver'] == "object") {
+                origin = origin || this.url;
+                let Objects = [];
+                paths.forEach(path => {
+                    if (path) {
+                        let Key = path.split(origin)[1];
+                        Key && Objects.push({ Key });
+                    }
+                });
+                if (!Objects.length) {
+                    return null;
+                }
+                return yield this.s3.deleteObjects({
+                    Bucket: this.bucket,
+                    Delete: { Objects },
+                }).promise();
+            }
+            else {
+                let result = { error: 0, n: 0 };
+                for (let filename of paths) {
+                    try {
+                        let destination = path.join(config_1.config.fileDestination, filename);
+                        yield fs.unlinkSync(destination);
+                        result['n'] += 1;
+                    }
+                    catch (err) {
+                        result['error'] += 1;
+                    }
+                }
+                return result;
+            }
+        });
+    }
+}
+exports.FileUtil = FileUtil;