filecat 5.15.5 → 5.16.1

package/build/server/main/domain/file/file.service.js

@@ -0,0 +1,1123 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileServiceImpl = exports.FileService = void 0;
+const file_pojo_1 = require("../../../common/file.pojo");
+const fs_1 = __importDefault(require("fs"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const Result_1 = require("../../other/Result");
+const rimraf_1 = require("rimraf");
+const ValueUtil_1 = require("../../../common/ValueUtil");
+const setting_service_1 = require("../setting/setting.service");
+const WsData_1 = require("../../../common/frame/WsData");
+const Result_pojo_1 = require("../../../common/Result.pojo");
+const file_compress_1 = require("./file.compress");
+const bin_1 = require("../bin/bin");
+const FileMenuType_1 = require("../../../common/FileMenuType");
+const StringUtil_1 = require("../../../common/StringUtil");
+const systeminformation_1 = __importDefault(require("systeminformation"));
+const multer_1 = __importDefault(require("multer"));
+const user_service_1 = require("../user/user.service");
+const user_req_1 = require("../../../common/req/user.req");
+const FileUtil_1 = require("./FileUtil");
+const node_process_watcher_1 = require("node-process-watcher");
+const archiver = require('archiver');
+const mime = require('mime-types');
+const chokidar = require('chokidar');
+const iconv = require('iconv-lite');
+class FileService extends file_compress_1.FileCompress {
+    constructor() {
+        super(...arguments);
+        this.fileUploadOptions = {
+            storage: multer_1.default.diskStorage({
+                destination: (req, file, cb) => {
+                    cb(null, req.fileDir);
+                },
+                filename: (req, file, cb) => {
+                    cb(null, req.fileName);
+                }
+            })
+        };
+        this.upload = (0, multer_1.default)({
+            storage: this.fileUploadOptions.storage,
+        }).single('file');
+        this.upload_num_set = {};
+        this.file_upload_count_map = new Map();
+        this.file_change_watcher_map = new Map();
+    }
+    utf8ToEncoding(utf8Str, targetEncoding, outputFormat = 'buffer') {
+        const buffer = iconv.encode(utf8Str, targetEncoding);
+        switch (outputFormat.toLowerCase()) {
+            case 'buffer':
+                return buffer;
+            case 'hex':
+                return buffer.toString('hex');
+            case 'base64':
+                return buffer.toString('base64');
+            case 'string':
+                if (['latin1', 'iso-8859-1'].includes(targetEncoding.toLowerCase())) {
+                    return buffer.toString('binary');
+                }
+                else {
+                    throw new Error(`outputFormat 'string' 仅支持 'latin1' 或 'iso-8859-1' 编码`);
+                }
+            default:
+                throw new Error(`不支持的 outputFormat: ${outputFormat}，可选 'buffer' | 'hex' | 'base64' | 'string'`);
+        }
+    }
+    getFile(param_path, token, is_sys_path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            const result = {
+                files: [],
+                folders: [],
+                relative_user_path: undefined
+            };
+            if (is_sys_path === 1 && decodeURIComponent(param_path) === "/etc/fstab") {
+                user_service_1.userService.check_user_auth(token, user_req_1.UserAuth.sys_disk_mount);
+            }
+            const root_path = setting_service_1.settingService.getFileRootPath(token);
+            const sysPath = is_sys_path === 1 ? `${decodeURIComponent(param_path)}` : path_1.default.join(root_path, param_path ? decodeURIComponent(param_path) : "");
+            user_service_1.userService.check_user_path(token, sysPath);
+            if (!(yield FileUtil_1.FileUtil.access(sysPath))) {
+                return (0, Result_1.Fail)("路径不存在", Result_pojo_1.RCode.Fail);
+            }
+            const stats = fs_1.default.statSync(sysPath);
+            if (stats.isFile()) {
+                const name = path_1.default.basename(sysPath);
+                const buffer = yield FileUtil_1.FileUtil.readFileSync(sysPath);
+                const pojo = (0, Result_1.Sucess)(buffer.toString(), Result_pojo_1.RCode.PreFile);
+                pojo.message = name;
+                return pojo;
+            }
+            else {
+                if (!stats.isDirectory()) {
+                    return (0, Result_1.Fail)("不是文件", Result_pojo_1.RCode.Fail);
+                }
+            }
+            if (is_sys_path === 1) {
+                if (sysPath.startsWith(root_path)) {
+                    result.relative_user_path = sysPath.substring(root_path.length);
+                }
+                return (0, Result_1.Sucess)(result);
+            }
+            const items = yield FileUtil_1.FileUtil.readdirSync(sysPath);
+            for (const item of items) {
+                const filePath = path_1.default.join(sysPath, item);
+                let stats = null;
+                try {
+                    stats = yield FileUtil_1.FileUtil.statSync(filePath);
+                }
+                catch (e) {
+                    console.log("读取错误", e);
+                }
+                const mtime = stats ? new Date(stats.mtime).getTime() : 0;
+                if (stats && stats.isFile()) {
+                    const type = (0, FileMenuType_1.getFileFormat)(item);
+                    (_a = result.files) === null || _a === void 0 ? void 0 : _a.push({
+                        type: type,
+                        name: item,
+                        mtime: mtime,
+                        size: stats.size,
+                        isLink: stats === null || stats === void 0 ? void 0 : stats.isSymbolicLink(),
+                        path: path_1.default.join(param_path, item)
+                    });
+                }
+                else if (stats && stats.isDirectory()) {
+                    (_b = result.folders) === null || _b === void 0 ? void 0 : _b.push({
+                        type: file_pojo_1.FileTypeEnum.folder,
+                        name: item,
+                        mtime: mtime,
+                        isLink: stats === null || stats === void 0 ? void 0 : stats.isSymbolicLink(),
+                        path: param_path
+                    });
+                }
+                else {
+                    (_c = result.files) === null || _c === void 0 ? void 0 : _c.push({
+                        type: file_pojo_1.FileTypeEnum.dev,
+                        name: item,
+                        mtime: mtime,
+                        size: stats === null || stats === void 0 ? void 0 : stats.size,
+                        path: path_1.default.join(param_path, item)
+                    });
+                }
+            }
+            return (0, Result_1.Sucess)(result);
+        });
+    }
+    get_folder_info(fpath, token, wss) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sysPath = path_1.default.join(setting_service_1.settingService.getFileRootPath(token), decodeURIComponent(fpath));
+            user_service_1.userService.check_user_path(token, sysPath);
+            node_process_watcher_1.node_process_watcher.on_folder_size(sysPath, (file_num, total_size) => {
+                wss.send(WsData_1.CmdType.folder_size_info, [file_num, total_size]);
+            });
+            wss.setClose(() => {
+                node_process_watcher_1.node_process_watcher.stop_folder_size(sysPath);
+            });
+        });
+    }
+    stop_folder_info(fpath, token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sysPath = path_1.default.join(setting_service_1.settingService.getFileRootPath(token), decodeURIComponent(fpath));
+            user_service_1.userService.check_user_path(token, sysPath);
+            node_process_watcher_1.node_process_watcher.stop_folder_size(sysPath);
+        });
+    }
+    getFileInfo(type, fpath, token, wss) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let info = {};
+            const sysPath = path_1.default.join(setting_service_1.settingService.getFileRootPath(token), decodeURIComponent(fpath));
+            user_service_1.userService.check_user_path(token, sysPath);
+            switch (type) {
+                case file_pojo_1.FileTypeEnum.folder:
+                    if (wss) {
+                        this.getDiskSizeForPath(sysPath).then(data => {
+                            const result = new WsData_1.WsData(WsData_1.CmdType.file_info);
+                            result.context = data;
+                            wss.sendData(result.encode());
+                        }).catch(error => {
+                            console.log(error);
+                        });
+                    }
+                    else {
+                        info = yield this.getDiskSizeForPath(sysPath);
+                    }
+                    break;
+                case file_pojo_1.FileTypeEnum.upload_folder:
+                    {
+                        const list = setting_service_1.settingService.get_dir_upload_max_num();
+                        for (const it of list) {
+                            if (user_service_1.userService.isSubPath(it.path, sysPath)) {
+                                info.dir_upload_max_num_value = it;
+                            }
+                        }
+                    }
+                    break;
+                default:
+                    break;
+            }
+            info.now_absolute_path = sysPath;
+            return info;
+        });
+    }
+    uploadFile(filePath, req, res, token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sysPath = path_1.default.join(setting_service_1.settingService.getFileRootPath(token), filePath ? decodeURIComponent(filePath) : "");
+            user_service_1.userService.check_user_path(token, sysPath);
+            user_service_1.userService.check_user_only_path(token, sysPath);
+            if ((req.query.dir === "1")) {
+                if (!(yield FileUtil_1.FileUtil.access(sysPath)))
+                    yield FileUtil_1.FileUtil.mkdirSync(sysPath, { recursive: true });
+                return;
+            }
+            let upload_max_key;
+            let max_num;
+            for (const it of setting_service_1.settingService.get_dir_upload_max_num()) {
+                if (user_service_1.userService.isSubPath(it.path, sysPath) && it.sys_upload_num !== undefined) {
+                    upload_max_key = it.path;
+                    max_num = it.sys_upload_num;
+                }
+            }
+            if (upload_max_key) {
+                let v = this.upload_num_set[upload_max_key];
+                if (v === undefined) {
+                    v = 1;
+                }
+                else {
+                    v++;
+                }
+                if (v > max_num)
+                    throw " upload file num max ";
+                this.upload_num_set[upload_max_key] = v;
+            }
+            req['fileDir'] = path_1.default.dirname(sysPath);
+            req['fileName'] = path_1.default.basename(sysPath);
+            req.on('close', () => {
+                if (upload_max_key) {
+                    if (this.upload_num_set[upload_max_key]) {
+                        this.upload_num_set[upload_max_key]--;
+                    }
+                }
+            });
+            return new Promise((resolve) => {
+                try {
+                    this.upload(req, res, (err) => {
+                        if (err) {
+                            console.log(err);
+                        }
+                        if (upload_max_key) {
+                            if (this.upload_num_set[upload_max_key]) {
+                                this.upload_num_set[upload_max_key]--;
+                            }
+                        }
+                        resolve(1);
+                    });
+                }
+                catch (e) {
+                    if (upload_max_key) {
+                        if (this.upload_num_set[upload_max_key]) {
+                            this.upload_num_set[upload_max_key]--;
+                        }
+                    }
+                    resolve(1);
+                }
+            });
+        });
+    }
+    file_upload_pre(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const param = data.context;
+            const token = data.wss.token;
+            const sysPath = path_1.default.join(setting_service_1.settingService.getFileRootPath(token), param.file_path ? decodeURIComponent(param.file_path) : "");
+            user_service_1.userService.check_user_path(token, sysPath);
+            user_service_1.userService.check_user_only_path(token, sysPath);
+            if (param.is_dir) {
+                if (!(yield FileUtil_1.FileUtil.access(sysPath)))
+                    yield FileUtil_1.FileUtil.mkdirSync(sysPath, { recursive: true });
+                return;
+            }
+            let max_num;
+            let upload_max_key;
+            for (const it of setting_service_1.settingService.get_dir_upload_max_num()) {
+                if (user_service_1.userService.isSubPath(it.path, sysPath) && it.sys_upload_num !== undefined) {
+                    upload_max_key = it.path;
+                    max_num = it.sys_upload_num;
+                }
+            }
+            if (upload_max_key) {
+                let v = this.upload_num_set[upload_max_key];
+                if (v === undefined) {
+                    v = 1;
+                }
+                else {
+                    v++;
+                }
+                if (v > max_num)
+                    throw " upload file num max ";
+                this.upload_num_set[upload_max_key] = v;
+            }
+            data.wss.setClose(() => {
+                if (upload_max_key) {
+                    if (this.upload_num_set[upload_max_key]) {
+                        this.upload_num_set[upload_max_key]--;
+                    }
+                }
+            });
+            let value = this.file_upload_count_map.get(sysPath);
+            if (value) {
+                value.buffer_list = new Array(param.parallel_done_num).fill(undefined);
+                value.parallel_done_num = 0;
+                if (param.lastModified !== value.lastModified) {
+                    if (yield FileUtil_1.FileUtil.access(sysPath)) {
+                        yield FileUtil_1.FileUtil.unlinkSync(sysPath);
+                    }
+                }
+                else if (yield FileUtil_1.FileUtil.access(sysPath)) {
+                    return { upload_data_size: value.upload_data_size };
+                }
+            }
+            this.lifeStart(sysPath, upload_max_key, (key) => __awaiter(this, void 0, void 0, function* () {
+                this.file_upload_count_map.delete(upload_max_key);
+                value.writeStream.end();
+                value.buffer_list = null;
+                this.file_upload_count_map.delete(sysPath);
+            }));
+            if (yield FileUtil_1.FileUtil.access(sysPath)) {
+                yield FileUtil_1.FileUtil.truncateSync(sysPath);
+            }
+            param.file_full_path = sysPath;
+            value = {
+                upload_data_size: 0,
+                wss: data.wss,
+                lastModified: param.lastModified,
+                buffer_list: new Array(param.parallel_done_num).fill(undefined),
+                sys_file_max_num: max_num,
+                sys_file_upload_max_key: upload_max_key,
+                parallel_done_num: 0,
+                writeStream: fs_1.default.createWriteStream(sysPath)
+            };
+            this.file_upload_count_map.set(sysPath, value);
+            return { upload_data_size: value.upload_data_size };
+        });
+    }
+    file_upload(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const param = data.context;
+            const token = data.wss.token;
+            const sysPath = path_1.default.join(setting_service_1.settingService.getFileRootPath(token), param.file_path ? decodeURIComponent(param.file_path) : "");
+            user_service_1.userService.check_user_path(token, sysPath);
+            user_service_1.userService.check_user_only_path(token, sysPath);
+            this.lifeHeart(sysPath);
+            const num_value = this.file_upload_count_map.get(sysPath);
+            try {
+                num_value.buffer_list[param.part_count] = data.bin_context;
+                delete data.bin_context;
+                num_value.parallel_done_num++;
+                if (num_value.parallel_done_num !== param.parallel_done_num) {
+                    return;
+                }
+                num_value.parallel_done_num = 0;
+                for (const add_chunk of num_value.buffer_list) {
+                    num_value.writeStream.write(add_chunk);
+                    num_value.upload_data_size += add_chunk.length;
+                }
+                num_value.buffer_list.length = 0;
+                num_value.buffer_list = new Array(param.parallel_done_num).fill(undefined);
+                if (param.chunk_index === param.total_chunk_index - 1) {
+                    if (num_value.sys_file_upload_max_key) {
+                        if (this.upload_num_set[num_value.sys_file_upload_max_key]) {
+                            this.upload_num_set[num_value.sys_file_upload_max_key]--;
+                        }
+                    }
+                    this.file_upload_count_map.delete(sysPath);
+                    num_value.writeStream.end();
+                }
+            }
+            catch (e) {
+                console.log(e);
+                if (num_value.sys_file_upload_max_key) {
+                    if (this.upload_num_set[num_value.sys_file_upload_max_key]) {
+                        this.upload_num_set[num_value.sys_file_upload_max_key]--;
+                    }
+                }
+                num_value.writeStream.end();
+                this.file_upload_count_map.delete(sysPath);
+            }
+        });
+    }
+    deletes(token, filePath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!filePath) {
+                return (0, Result_1.Sucess)("1");
+            }
+            let sysPath = path_1.default.join(setting_service_1.settingService.getFileRootPath(token), decodeURIComponent(filePath));
+            user_service_1.userService.check_user_path(token, sysPath);
+            if (user_service_1.userService.protectionCheck(sysPath, token) || setting_service_1.settingService.protectionCheck(sysPath)) {
+                return (0, Result_1.Fail)("1", Result_pojo_1.RCode.PROTECT_FILE);
+            }
+            if (setting_service_1.settingService.get_recycle_bin_status()) {
+                sysPath = (0, StringUtil_1.removeTrailingPath)(sysPath);
+                const cyc_map_list = setting_service_1.settingService.get_recycle_dir_map_list();
+                for (const it of cyc_map_list) {
+                    let cyc_p;
+                    let check_cyc_p = "";
+                    if (it.length > 1 && !!it[1]) {
+                        cyc_p = (0, StringUtil_1.removeTrailingPath)(it[1]);
+                        check_cyc_p = it[0];
+                    }
+                    else {
+                        cyc_p = (0, StringUtil_1.removeTrailingPath)(it[0]);
+                    }
+                    if (cyc_p === sysPath) {
+                        throw "cyc dir not to del";
+                    }
+                    if (check_cyc_p !== "" && !user_service_1.userService.isSubPath(check_cyc_p, sysPath)) {
+                        continue;
+                    }
+                    if (user_service_1.userService.isSubPath(cyc_p, sysPath)) {
+                        continue;
+                    }
+                    const ext_name = path_1.default.extname(sysPath);
+                    const fileName = path_1.default.basename(filePath, ext_name);
+                    let p = path_1.default.join(cyc_p, `${fileName}${ext_name}`);
+                    if (yield FileUtil_1.FileUtil.access(p)) {
+                        p = yield FileUtil_1.FileUtil.getUniqueFileName(p);
+                    }
+                    yield this.cut_exec(sysPath, p);
+                    return (0, Result_1.Sucess)("1");
+                }
+            }
+            const stats = yield FileUtil_1.FileUtil.statSync(sysPath);
+            if (stats.isFile()) {
+                yield FileUtil_1.FileUtil.unlinkSync(sysPath);
+            }
+            else {
+                yield (0, rimraf_1.rimraf)(sysPath);
+            }
+            return (0, Result_1.Sucess)("1");
+        });
+    }
+    save(token, context, filePath, is_sys_path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (context === null || context === undefined) {
+                return;
+            }
+            const sysPath = is_sys_path === 1 ? `/${filePath}` : path_1.default.join(setting_service_1.settingService.getFileRootPath(token), filePath ? decodeURIComponent(filePath) : "");
+            user_service_1.userService.check_user_path(token, sysPath);
+            user_service_1.userService.check_user_only_path(token, sysPath);
+            yield FileUtil_1.FileUtil.writeFileSync(sysPath, context);
+        });
+    }
+    common_base64_save(token, filepath, base64_context, type) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sysPath = path_1.default.join(setting_service_1.settingService.getFileRootPath(token), filepath);
+            user_service_1.userService.check_user_path(token, sysPath);
+            user_service_1.userService.check_user_only_path(token, sysPath);
+            const binaryData = Buffer.from(base64_context, 'base64');
+            if (type === file_pojo_1.base64UploadType.all || type === file_pojo_1.base64UploadType.start) {
+                yield FileUtil_1.FileUtil.writeFileSync(sysPath, binaryData);
+            }
+            else if (type === file_pojo_1.base64UploadType.part) {
+                yield FileUtil_1.FileUtil.appendFileSync(sysPath, binaryData);
+            }
+        });
+    }
+    cut(token, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!data) {
+                return;
+            }
+            const root_path = setting_service_1.settingService.getFileRootPath(token);
+            const sysPath = path_1.default.join(root_path);
+            const toSysPath = path_1.default.join(root_path, data.to ? decodeURIComponent(data.to) : "");
+            user_service_1.userService.check_user_path(token, sysPath);
+            user_service_1.userService.check_user_path(token, toSysPath);
+            for (const file of data.files) {
+                yield this.cut_exec(decodeURIComponent(path_1.default.join(sysPath, file)), decodeURIComponent(path_1.default.join(toSysPath, path_1.default.basename(file))));
+            }
+        });
+    }
+    cut_exec(source_path, to_file) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield FileUtil_1.FileUtil.renameSync(source_path, to_file);
+            yield (0, rimraf_1.rimraf)(source_path);
+        });
+    }
+    copy(token, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!data) {
+                return;
+            }
+            const root_path = setting_service_1.settingService.getFileRootPath(token);
+            const sysPath = path_1.default.join(root_path);
+            const toSysPath = path_1.default.join(root_path, data.to ? decodeURIComponent(data.to) : "");
+            user_service_1.userService.check_user_path(token, sysPath);
+            user_service_1.userService.check_user_only_path(token, sysPath);
+            user_service_1.userService.check_user_path(token, toSysPath);
+            user_service_1.userService.check_user_only_path(token, toSysPath);
+            for (const file of data.files) {
+                const filePath = decodeURIComponent(path_1.default.join(sysPath, file));
+                yield fs_extra_1.default.copy(filePath, decodeURIComponent(path_1.default.join(toSysPath, path_1.default.basename(file))), { overwrite: true });
+            }
+        });
+    }
+    newFile(token, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.todoNew(token, 2, data);
+        });
+    }
+    newDir(token, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.todoNew(token, 1, data);
+        });
+    }
+    todoNew(token, type, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (data === null || data === undefined) {
+                return;
+            }
+            const sysPath = path_1.default.join(setting_service_1.settingService.getFileRootPath(token), decodeURIComponent(data.name));
+            user_service_1.userService.check_user_path(token, sysPath);
+            user_service_1.userService.check_user_only_path(token, sysPath);
+            if (yield FileUtil_1.FileUtil.access(sysPath)) {
+                return;
+            }
+            if (type === 1) {
+                yield FileUtil_1.FileUtil.mkdirSync(sysPath, { recursive: true });
+            }
+            else {
+                yield FileUtil_1.FileUtil.writeFileSync(sysPath, (_a = data.context) !== null && _a !== void 0 ? _a : "");
+            }
+        });
+    }
+    rename(token, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!data) {
+                return;
+            }
+            const root_path = setting_service_1.settingService.getFileRootPath(token);
+            const sysPath = path_1.default.join(root_path, decodeURIComponent(data.name));
+            user_service_1.userService.check_user_path(token, sysPath);
+            const sysPathNew = path_1.default.join(root_path, decodeURIComponent(data.newName));
+            yield fs_extra_1.default.rename(sysPath, sysPathNew);
+        });
+    }
+    download_one_file(file_name, file_size, file_path, res, param) {
+        const encodedFileName = encodeURIComponent(file_name).replace(/%20/g, '+');
+        let handle_type = "";
+        if ((param === null || param === void 0 ? void 0 : param.handle_type_) !== undefined) {
+            handle_type = param.handle_type_;
+        }
+        else {
+            handle_type = "attachment";
+            if (file_name.endsWith('.pdf')) {
+                handle_type = "inline";
+            }
+        }
+        res.set({
+            "Content-Type": mime.lookup(file_name) || "application/octet-stream",
+            "Content-Length": file_size,
+            "Content-Disposition": `${handle_type}; filename="${encodedFileName}"; filename*=UTF-8''${encodedFileName}`
+        });
+        if (param === null || param === void 0 ? void 0 : param.cache) {
+            res.setHeader('Cache-Control', 'public, max-age=86400 ');
+        }
+        else if (param === null || param === void 0 ? void 0 : param.cache_length) {
+            res.setHeader('Cache-Control', `public, max-age=${param.cache_length}`);
+        }
+        const readStream = fs_1.default.createReadStream(file_path);
+        readStream.pipe(res);
+    }
+    download(ctx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const file = ctx.query.file;
+            if (!file || !file.length) {
+                ctx.res.status(404).send('File not found');
+                return;
+            }
+            const token = ctx.query['token'];
+            const cache = ctx.query['cache'];
+            const show = ctx.query['show'];
+            if (!Array.isArray(file)) {
+                const sysPath = path_1.default.join(setting_service_1.settingService.getFileRootPath(token), decodeURIComponent(file));
+                const fileName = path_1.default.basename(sysPath);
+                const stats = yield FileUtil_1.FileUtil.statSync(sysPath);
+                const range = ctx.header("Range");
+                const fileSize = stats.size;
+                if (range) {
+                    const encodedFileName = encodeURIComponent(fileName).replace(/%20/g, '+');
+                    const [start, end] = range.replace(/bytes=/, "").split("-");
+                    const startByte = parseInt(start, 10);
+                    const endByte = end ? parseInt(end, 10) : fileSize - 1;
+                    if (startByte >= fileSize) {
+                        ctx.res.status(416).send("Requested range not satisfiable");
+                        return;
+                    }
+                    const chunkSize = endByte - startByte + 1;
+                    const readStream = fs_1.default.createReadStream(sysPath, { start: startByte, end: endByte });
+                    ctx.res.status(206);
+                    ctx.res.set({
+                        "Content-Range": `bytes ${startByte}-${endByte}/${fileSize}`,
+                        "Accept-Ranges": "bytes",
+                        "Content-Length": chunkSize,
+                        "Content-Type": mime.lookup(fileName) || "application/octet-stream",
+                        "Content-Disposition": `attachment; filename="${encodedFileName}"; filename*=UTF-8''${encodedFileName}`
+                    });
+                    readStream.pipe(ctx.res);
+                    return;
+                }
+                if (stats.isFile()) {
+                    this.download_one_file(fileName, fileSize, sysPath, ctx.res, {
+                        cache: cache === "1",
+                        handle_type_: show === "1" ? "inline" : "attachment"
+                    });
+                }
+                else {
+                    ctx.res.attachment(path_1.default.basename(sysPath) + ".zip");
+                    const archive = archiver('zip', { zlib: { level: 5 } });
+                    archive.pipe(ctx.res);
+                    archive.directory(sysPath, path_1.default.basename(sysPath));
+                    archive.finalize();
+                }
+            }
+            else {
+                const files = file;
+                const archive = archiver('zip', {
+                    zlib: { level: 5 }
+                });
+                ctx.res.attachment("output.zip");
+                ctx.res.set('Content-Type', 'application/octet-stream');
+                archive.pipe(ctx.res);
+                for (const file of files) {
+                    const sysPath = path_1.default.join(setting_service_1.settingService.getFileRootPath(token), decodeURIComponent(file));
+                    const stats = yield FileUtil_1.FileUtil.statSync(sysPath);
+                    if (stats.isFile()) {
+                        archive.file(sysPath, { name: path_1.default.basename(sysPath) });
+                    }
+                    else {
+                        archive.directory(sysPath, path_1.default.basename(sysPath));
+                    }
+                }
+                archive.finalize();
+            }
+        });
+    }
+    file_video_trans(data) {
+        const pojo = data.context;
+        user_service_1.userService.check_user_auth(pojo.token, user_req_1.UserAuth.filecat_file_context_update_upload_created_copy_decompression);
+        const wss = data.wss;
+        const root_path = setting_service_1.settingService.getFileRootPath(pojo.token);
+        const sysPath = path_1.default.join(root_path, decodeURIComponent(pojo.source_filename));
+        const sysPathNew = path_1.default.join(root_path, decodeURIComponent(pojo.to_filename));
+        (0, bin_1.getFfmpeg)()(sysPath)
+            .toFormat(pojo.to_format)
+            .on('start', function (commandLine) {
+            const result = new WsData_1.WsData(WsData_1.CmdType.file_video_trans_progress);
+            result.context = 0;
+            wss.sendData(result.encode());
+        })
+            .on('progress', function (progress) {
+            const result = new WsData_1.WsData(WsData_1.CmdType.file_video_trans_progress);
+            result.context = progress.percent.toFixed(0);
+            wss.sendData(result.encode());
+        })
+            .on('error', function (err, stdout, stderr) {
+            wss.ws.close();
+        })
+            .on('end', function () {
+            const result = new WsData_1.WsData(WsData_1.CmdType.file_video_trans_progress);
+            result.context = 100;
+            wss.sendData(result.encode());
+        })
+            .save(sysPathNew);
+    }
+    uncompress(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const pojo = data.context;
+            user_service_1.userService.check_user_auth(pojo.token, user_req_1.UserAuth.filecat_file_context_update_upload_created_copy_decompression);
+            const source_file = decodeURIComponent(pojo.source_file);
+            const tar_dir = decodeURIComponent((_a = pojo.tar_dir) !== null && _a !== void 0 ? _a : "");
+            const directoryPath = decodeURIComponent(path_1.default.dirname(source_file));
+            const root_path = setting_service_1.settingService.getFileRootPath(pojo.token);
+            const targetFolder = path_1.default.join(root_path, directoryPath, tar_dir);
+            user_service_1.userService.check_user_path(pojo.token, targetFolder);
+            user_service_1.userService.check_user_only_path(pojo.token, targetFolder);
+            const wss = data.wss;
+            if (tar_dir) {
+                yield FileUtil_1.FileUtil.mkdirSync(path_1.default.join(targetFolder), { recursive: true });
+            }
+            const sysSourcePath = path_1.default.join(root_path, source_file);
+            user_service_1.userService.check_user_path(pojo.token, sysSourcePath);
+            const outHanle = (value) => {
+                if (value === -1) {
+                    wss.ws.close();
+                    return;
+                }
+                const result = new WsData_1.WsData(WsData_1.CmdType.file_uncompress_progress);
+                result.context = value;
+                wss.sendData(result.encode());
+            };
+            if (pojo.format === file_pojo_1.FileCompressType.tar) {
+                this.unTar(sysSourcePath, targetFolder, outHanle);
+            }
+            else if (pojo.format === file_pojo_1.FileCompressType.zip) {
+                this.unZip(sysSourcePath, targetFolder, outHanle);
+            }
+            else if (pojo.format === file_pojo_1.FileCompressType.gzip) {
+                this.unTar(sysSourcePath, targetFolder, outHanle, true);
+            }
+            else if (pojo.format === file_pojo_1.FileCompressType.rar) {
+                try {
+                    yield this.unRar(sysSourcePath, targetFolder, outHanle);
+                }
+                catch (e) {
+                    wss.ws.close();
+                }
+            }
+            else {
+                wss.ws.close();
+            }
+        });
+    }
+    FileCompress(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pojo = data.context;
+            user_service_1.userService.check_user_auth(pojo.token, user_req_1.UserAuth.filecat_file_context_update_upload_created_copy_decompression);
+            const files = pojo.filePaths;
+            const root_path = setting_service_1.settingService.getFileRootPath(pojo.token);
+            const wss = data.wss;
+            const filePaths = [], directorys = [];
+            for (const file of files) {
+                const name = path_1.default.join(root_path, decodeURIComponent(file));
+                user_service_1.userService.check_user_path(pojo.token, name);
+                user_service_1.userService.check_user_only_path(pojo.token, name);
+                try {
+                    const stats = yield FileUtil_1.FileUtil.statSync(name);
+                    if (stats.isFile()) {
+                        filePaths.push(name);
+                    }
+                    else {
+                        directorys.push(name);
+                    }
+                }
+                catch (e) {
+                }
+            }
+            let format;
+            switch (pojo.format) {
+                case file_pojo_1.FileCompressType.gzip:
+                    format = file_pojo_1.FileCompressType.tar;
+                    break;
+                default:
+                    format = pojo.format;
+            }
+            const targerFilePath = path_1.default.join(root_path, decodeURIComponent(pojo.tar_filename));
+            this.compress(format, pojo.compress_level, targerFilePath, filePaths, directorys, (value) => {
+                if (value === -1) {
+                    wss.ws.close();
+                    return;
+                }
+                const result = new WsData_1.WsData(WsData_1.CmdType.file_compress_progress);
+                result.context = value;
+                wss.sendData(result.encode());
+            }, pojo.format === file_pojo_1.FileCompressType.gzip);
+        });
+    }
+    studio_get_item(param_path, token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = {
+                list: []
+            };
+            const sysPath = path_1.default.join(setting_service_1.settingService.getFileRootPath(token), param_path ? decodeURIComponent(param_path) : "");
+            user_service_1.userService.check_user_path(token, sysPath);
+            if (!(yield FileUtil_1.FileUtil.access(sysPath))) {
+                return (0, Result_1.Fail)("路径不存在", Result_pojo_1.RCode.Fail);
+            }
+            const stats = yield FileUtil_1.FileUtil.statSync(sysPath);
+            if (stats.isFile()) {
+                return (0, Result_1.Fail)("是文件", Result_pojo_1.RCode.Fail);
+            }
+            const items = yield FileUtil_1.FileUtil.readdirSync(sysPath);
+            for (const item of items) {
+                const filePath = path_1.default.join(sysPath, item);
+                let stats = null;
+                try {
+                    stats = yield FileUtil_1.FileUtil.statSync(filePath);
+                }
+                catch (e) {
+                    continue;
+                }
+                result.list.push({
+                    type: stats.isFile() ? "file" : "folder",
+                    name: item,
+                    size: stats.size
+                });
+            }
+            return result;
+        });
+    }
+    getDiskSizeForPath(fpath) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pojo = {};
+            try {
+                const diskData = yield systeminformation_1.default.fsSize();
+                const dirPath = path_1.default.resolve(fpath);
+                let targetDisk;
+                diskData.forEach(disk => {
+                    if (dirPath.startsWith(disk.mount)) {
+                        if (!targetDisk) {
+                            targetDisk = disk;
+                            return;
+                        }
+                        else {
+                            if (disk.mount.length > targetDisk.mount.length) {
+                                targetDisk = disk;
+                            }
+                        }
+                    }
+                });
+                if (targetDisk) {
+                    pojo.path = dirPath;
+                    pojo.name = path_1.default.basename(fpath);
+                    pojo.total_size = (0, ValueUtil_1.formatFileSize)(targetDisk.size);
+                    pojo.left_size = (0, ValueUtil_1.formatFileSize)(targetDisk.available);
+                    pojo.fs_type = targetDisk.type;
+                }
+            }
+            catch (error) {
+                console.error('Error fetching disk information:', error);
+                return pojo;
+            }
+            return pojo;
+        });
+    }
+    isFirstByte(byte, encoding = "utf8") {
+        if (byte === undefined || byte < 0 || byte > 255)
+            throw 'Invalid byte';
+        switch (encoding.toLowerCase()) {
+            case 'utf8':
+            case 'utf-8':
+                return (byte & 0xE0) === 0xC0 || (byte & 0xF0) === 0xE0 || (byte & 0xF8) === 0xF0;
+            case 'ascii':
+            case 'latin1':
+            case 'iso-8859-1':
+            case 'windows-1252':
+                return true;
+            case 'gbk':
+            case 'gb2312':
+                return byte >= 0x81 && byte <= 0xFE;
+            case 'big5':
+                return byte >= 0x81 && byte <= 0xFE;
+            default:
+                throw 'Unsupported encoding for isFirstByte';
+        }
+    }
+    convertToUtf8(input, fromEncoding) {
+        if (fromEncoding === 'utf8' || fromEncoding === 'utf-8') {
+            return Buffer.isBuffer(input) ? input.toString('utf8') : input;
+        }
+        let buf;
+        if (typeof input === 'string') {
+            buf = iconv.encode(input, fromEncoding);
+        }
+        else if (Buffer.isBuffer(input)) {
+            buf = input;
+        }
+        else {
+            throw new Error('输入必须是 Buffer 或字符串');
+        }
+        const str = iconv.decode(buf, fromEncoding);
+        return str;
+    }
+    go_forward_log(pojo, file_path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let linesRead = 0;
+            let haveReadSize = 0;
+            const fd = yield FileUtil_1.FileUtil.open(file_path, "r");
+            let max_count = 100;
+            while (haveReadSize < pojo.once_max_size) {
+                if (max_count <= 0) {
+                    break;
+                }
+                max_count--;
+                const buffer = Buffer.alloc(10240);
+                let { bytesRead } = yield fd.read(buffer, 0, buffer.length, pojo.position);
+                let done = false;
+                let last_h = -1;
+                for (let i = 0, ch_byte_i = bytesRead - 1; i < bytesRead; i++) {
+                    if (buffer[i] === 10 || i === ch_byte_i) {
+                        let index = i;
+                        if (i === ch_byte_i && (buffer[i] & 0x80) !== 0) {
+                            for (let j = i; j > last_h; j--) {
+                                if (this.isFirstByte(buffer[j], pojo.encoding)) {
+                                    index = j - 1;
+                                    break;
+                                }
+                            }
+                        }
+                        linesRead++;
+                        const now_str_start = last_h + 1;
+                        const next_str_start = index + 1;
+                        pojo.context_list.push(this.convertToUtf8(buffer.subarray(now_str_start, next_str_start), pojo.encoding));
+                        pojo.context_start_position_list.push(pojo.position + now_str_start);
+                        pojo.context_position_list.push(pojo.position + next_str_start);
+                        if (linesRead >= pojo.line) {
+                            done = true;
+                            break;
+                        }
+                        last_h = index;
+                    }
+                }
+                if (done || bytesRead === 0) {
+                    break;
+                }
+                else {
+                    haveReadSize += last_h;
+                    pojo.position += last_h + 1;
+                }
+            }
+            yield fd.close();
+            return pojo;
+        });
+    }
+    find_back_enter_index(pojo_1, file_path_1) {
+        return __awaiter(this, arguments, void 0, function* (pojo, file_path, max_len = 10240) {
+            const fd = yield FileUtil_1.FileUtil.open(file_path, "r");
+            let buffer_len = max_len;
+            if (pojo.position < buffer_len) {
+                buffer_len = pojo.position;
+            }
+            let buffer = Buffer.alloc(buffer_len);
+            const position = pojo.position - buffer.length;
+            const { bytesRead } = yield fd.read(buffer, 0, buffer.length, position);
+            for (let i = bytesRead; i >= 0; i--) {
+                let index = i;
+                if (buffer[i] === 10 || i === 0) {
+                    if ((buffer[i] & 0x80) !== 0) {
+                        for (let j = 0; j < bytesRead; j++) {
+                            if (this.isFirstByte(buffer[j], pojo.encoding)) {
+                                index = j - 1;
+                                break;
+                            }
+                        }
+                    }
+                    const now_str_start = index === 0 && pojo.position === 0 ? 0 : index + 1;
+                    pojo.position = position + now_str_start;
+                    yield fd.close();
+                    return;
+                }
+            }
+            yield fd.close();
+            pojo.position = position;
+        });
+    }
+    go_back_log(pojo, file_path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let linesRead = 0;
+            let haveReadSize = 0;
+            const fd = yield FileUtil_1.FileUtil.open(file_path, "r");
+            let buffer_len = 10240;
+            let max_count = 100;
+            while (haveReadSize < pojo.once_max_size) {
+                if (max_count <= 0) {
+                    break;
+                }
+                max_count--;
+                if (pojo.position < buffer_len) {
+                    buffer_len = pojo.position;
+                }
+                let buffer = Buffer.alloc(buffer_len);
+                pojo.position = pojo.position - buffer.length;
+                const { bytesRead } = yield fd.read(buffer, 0, buffer.length, pojo.position);
+                let done = false;
+                let last_h = bytesRead;
+                for (let i = bytesRead; i >= 0; i--) {
+                    let index = i;
+                    if (buffer[i] === 10 || i === 0) {
+                        if (i === 0 && pojo.position !== 0 && (buffer[i] & 0x80) !== 0) {
+                            for (let j = 0; j < last_h; j++) {
+                                if (this.isFirstByte(buffer[j], pojo.encoding)) {
+                                    index = j - 1;
+                                    break;
+                                }
+                            }
+                        }
+                        linesRead++;
+                        const now_str_start = index === 0 && pojo.position === 0 ? 0 : index + 1;
+                        const next_str_start = last_h + 1;
+                        pojo.context_list.push(this.convertToUtf8(buffer.subarray(now_str_start, next_str_start), pojo.encoding));
+                        pojo.context_start_position_list.push(pojo.position + now_str_start);
+                        pojo.context_position_list.push(pojo.position + next_str_start);
+                        if (linesRead >= pojo.line) {
+                            done = true;
+                            break;
+                        }
+                        last_h = index;
+                    }
+                }
+                if (done || bytesRead === 0 || (last_h <= 0 && pojo.position === 0)) {
+                    break;
+                }
+                else {
+                    haveReadSize += (bytesRead - last_h);
+                    pojo.position -= last_h - 1;
+                }
+            }
+            yield fd.close();
+            return pojo;
+        });
+    }
+    log_viewer(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pojo = data.context;
+            pojo.context = "";
+            pojo.context_list = [];
+            pojo.context_position_list = [];
+            pojo.context_start_position_list = [];
+            const root_path = setting_service_1.settingService.getFileRootPath(pojo.token);
+            const file_path = path_1.default.join(root_path, decodeURIComponent(pojo.path));
+            user_service_1.userService.check_user_path(data.wss.token, file_path);
+            const stats = yield FileUtil_1.FileUtil.statSync(file_path);
+            const fileSize = stats.size;
+            pojo.max_size = fileSize;
+            if ((pojo.position <= 0 && pojo.back) || (!pojo.back && pojo.position >= fileSize)) {
+                pojo.context = '';
+                return pojo;
+            }
+            if (pojo.back)
+                return this.go_back_log(pojo, file_path);
+            if (pojo.find_back_enter_index)
+                this.find_back_enter_index(pojo, file_path, 100);
+            return this.go_forward_log(pojo, file_path);
+        });
+    }
+    log_viewer_watch(data) {
+        const pojo = data.context;
+        if (this.file_change_watcher_map.has(pojo.token)) {
+            return;
+        }
+        const wss = data.wss;
+        pojo.context = "";
+        pojo.context_list = [];
+        pojo.context_position_list = [];
+        pojo.context_start_position_list = [];
+        const root_path = setting_service_1.settingService.getFileRootPath(pojo.token);
+        const file_path = path_1.default.join(root_path, decodeURIComponent(pojo.path));
+        user_service_1.userService.check_user_path(wss.token, file_path);
+        let watcher = chokidar.watch(file_path, {
+            persistent: true,
+            usePolling: true,
+        });
+        this.file_change_watcher_map.set(pojo.token, watcher);
+        wss.setClose(() => {
+            watcher.close();
+            this.file_change_watcher_map.delete(pojo.token);
+        });
+        let bytesRead = pojo.max_size;
+        watcher.on('change', (changedFilePath) => {
+            if (changedFilePath === file_path) {
+                fs_1.default.stat(file_path, (err, stats) => {
+                    if (err) {
+                        console.error('Failed to get file stats:', err);
+                        watcher.close();
+                        this.file_change_watcher_map.delete(pojo.token);
+                        return;
+                    }
+                    if (stats.size > bytesRead) {
+                        const newStream = fs_1.default.createReadStream(file_path, { encoding: 'utf8', start: bytesRead });
+                        newStream.on('data', (chunk) => {
+                            const str = chunk.toString();
+                            let now_str_start = bytesRead;
+                            let next_str_start = bytesRead + chunk.length + 1;
+                            let index = 0;
+                            for (let i = 0; i < str.length; i++) {
+                                if (!/^\s$/.test(str[i])) {
+                                    break;
+                                }
+                                else if (str[i] === '\n' && chunk.length - 1 > i) {
+                                    index = i + 1;
+                                    now_str_start = bytesRead + index;
+                                    next_str_start + index;
+                                    break;
+                                }
+                            }
+                            pojo.context_list.push(str.slice(index, chunk.length));
+                            pojo.context_start_position_list.push(now_str_start);
+                            pojo.context_position_list.push(next_str_start);
+                            pojo.max_size = bytesRead + chunk.length;
+                            const result = new WsData_1.WsData(WsData_1.CmdType.log_viewer_watch);
+                            result.context = pojo;
+                            wss.sendData(result.encode());
+                            bytesRead += Buffer.byteLength(chunk, 'utf8');
+                            pojo.context_list = [];
+                            pojo.context_position_list = [];
+                            pojo.context_start_position_list = [];
+                        });
+                    }
+                });
+            }
+        });
+        watcher.on('error', (error) => {
+            watcher.close();
+            this.file_change_watcher_map.delete(pojo.token);
+        });
+    }
+}
+exports.FileService = FileService;
+exports.FileServiceImpl = new FileService();
+//# sourceMappingURL=file.service.js.map