filecat 5.32.0 → 5.32.2

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

@@ -0,0 +1,1276 @@
+"use strict";
+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 get_bin_dependency_1 = require("../bin/get_bin_dependency");
+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 } = (0, get_bin_dependency_1.get_bin_dependency)("node-process-watcher", false);
+const ListUtil_1 = require("../../../common/ListUtil");
+const path_util_1 = require("../../../common/path_util");
+const DataUtil_1 = require("../data/DataUtil");
+const data_type_1 = require("../data/data_type");
+const shell_service_1 = require("../shell/shell.service");
+const archiver = require('archiver');
+const mime = require('mime-types');
+const chokidar = require('chokidar');
+const iconv = require('iconv-lite');
+class FileService {
+    constructor() {
+        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'`);
+        }
+    }
+    async get_file_base_info(token, param_path) {
+        let sysPath = decodeURIComponent(param_path);
+        const root_path = setting_service_1.settingService.getFileRootPath(token);
+        if ((0, path_util_1.isAbsolutePath)(sysPath)) {
+        }
+        else {
+            sysPath = path_1.default.join(root_path, sysPath);
+        }
+        user_service_1.userService.check_user_path(token, sysPath);
+        const stat = await FileUtil_1.FileUtil.statSync(sysPath);
+        return {
+            name: path_1.default.basename(sysPath),
+            path: sysPath,
+            size: stat.size,
+            isFile: stat.isFile(),
+            isSymbolicLink: stat.isSymbolicLink(),
+            createdAt: stat.birthtime?.getTime(),
+            modifiedAt: stat.mtime?.getTime(),
+            accessedAt: stat.atime?.getTime(),
+            mode: stat.mode,
+            uid: stat.uid,
+            uname: (0, shell_service_1.getSys)() === user_req_1.SysEnum.win ? node_process_watcher?.get_file_owner(sysPath)?.username : node_process_watcher?.get_username_by_uid(stat.uid)
+        };
+    }
+    async getFile(param_path, token) {
+        const result = {
+            files: [],
+            folders: []
+        };
+        const root_path = setting_service_1.settingService.getFileRootPath(token);
+        let sysPath = decodeURIComponent(param_path);
+        if ((0, path_util_1.isAbsolutePath)(sysPath)) {
+        }
+        else {
+            sysPath = path_1.default.join(root_path, sysPath);
+        }
+        user_service_1.userService.check_user_path(token, sysPath);
+        if (!await FileUtil_1.FileUtil.access(sysPath)) {
+            return (0, Result_1.Fail)("路径不存在", Result_pojo_1.RCode.Fail);
+        }
+        const stats = await FileUtil_1.FileUtil.statSync(sysPath);
+        if (stats.isFile()) {
+            const name = path_1.default.basename(sysPath);
+            const buffer = await FileUtil_1.FileUtil.readFileSync(sysPath);
+            const pojo = (0, Result_1.Sucess)(buffer.toString(), Result_pojo_1.RCode.PreFile);
+            pojo.message = name;
+            return pojo;
+        }
+        const items = await FileUtil_1.FileUtil.readdirSync(sysPath);
+        for (const item of items) {
+            const filePath = path_1.default.join(sysPath, item);
+            let stats = null;
+            try {
+                stats = await FileUtil_1.FileUtil.statSync(filePath);
+            }
+            catch (e) {
+                continue;
+            }
+            const mtime = stats ? new Date(stats.mtime).getTime() : 0;
+            if (stats && stats.isFile()) {
+                const type = (0, FileMenuType_1.getFileFormat)(item);
+                result.files?.push({
+                    type: type,
+                    name: item,
+                    mtime: mtime,
+                    size: stats.size,
+                    isLink: stats?.isSymbolicLink(),
+                    path: path_1.default.join(param_path, item)
+                });
+            }
+            else if (stats && stats.isDirectory()) {
+                result.folders?.push({
+                    type: file_pojo_1.FileTypeEnum.folder,
+                    name: item,
+                    mtime: mtime,
+                    isLink: stats?.isSymbolicLink(),
+                    path: param_path
+                });
+            }
+            else {
+                result.files?.push({
+                    type: file_pojo_1.FileTypeEnum.dev,
+                    name: item,
+                    mtime: mtime,
+                    size: stats?.size,
+                    path: path_1.default.join(param_path, item)
+                });
+            }
+        }
+        return (0, Result_1.Sucess)(result);
+    }
+    async get_list(token, param_path, page_num, page_size, search) {
+        const result = {
+            files: []
+        };
+        const root_path = setting_service_1.settingService.getFileRootPath(token);
+        const sysPath = path_1.default.join(root_path, param_path ? decodeURIComponent(param_path) : "");
+        user_service_1.userService.check_user_path(token, sysPath);
+        let items = await FileUtil_1.FileUtil.readdirSync(sysPath);
+        items = (0, ListUtil_1.list_paginate)(items, page_num, page_size).list;
+        for (const item of items) {
+            const filePath = path_1.default.join(sysPath, item);
+            let stats = null;
+            try {
+                stats = await FileUtil_1.FileUtil.statSync(filePath);
+            }
+            catch (e) {
+                console.log("读取错误", e);
+            }
+            let type;
+            let p;
+            let size;
+            if (!stats)
+                continue;
+            if (stats.isFile()) {
+                type = (0, FileMenuType_1.getFileFormat)(item);
+                p = path_1.default.join(param_path, item);
+                size = stats.size;
+            }
+            else if (stats.isDirectory()) {
+                type = file_pojo_1.FileTypeEnum.folder;
+                p = param_path;
+            }
+            else {
+                type = file_pojo_1.FileTypeEnum.dev;
+                p = path_1.default.join(param_path, item);
+                size = stats.size;
+            }
+            const mtime = stats ? new Date(stats.mtime).getTime() : 0;
+            const pojo = {
+                type,
+                name: item,
+                mtime: mtime,
+                size,
+                isLink: stats?.isSymbolicLink(),
+                path: p
+            };
+            result.files.push(pojo);
+        }
+        return (0, Result_1.Sucess)(result);
+    }
+    async get_folder_info(fpath, token, wss) {
+        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?.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?.stop_folder_size(sysPath);
+        });
+    }
+    async stop_folder_info(fpath, token) {
+        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?.stop_folder_size(sysPath);
+    }
+    async getFileInfo(type, fpath, token, wss) {
+        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 = await 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;
+    }
+    async uploadFile(filePath, req, res, token) {
+        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 (!await FileUtil_1.FileUtil.access(sysPath))
+                await 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);
+            }
+        });
+    }
+    async file_upload_pre(data) {
+        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 (!await FileUtil_1.FileUtil.access(sysPath))
+                await 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 (await FileUtil_1.FileUtil.access(sysPath)) {
+                    await FileUtil_1.FileUtil.unlinkSync(sysPath);
+                }
+            }
+            else if (await FileUtil_1.FileUtil.access(sysPath)) {
+                return { upload_data_size: value.upload_data_size };
+            }
+        }
+        file_compress_1.fileCompress.lifeStart(sysPath, upload_max_key, async (key) => {
+            this.file_upload_count_map.delete(upload_max_key);
+            value.writeStream.end();
+            value.buffer_list = null;
+            this.file_upload_count_map.delete(sysPath);
+        });
+        if (await FileUtil_1.FileUtil.access(sysPath)) {
+            await 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 };
+    }
+    async file_upload(data) {
+        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);
+        file_compress_1.fileCompress.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);
+        }
+    }
+    async deletes(token, filePath) {
+        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 (await FileUtil_1.FileUtil.access(p)) {
+                    p = await FileUtil_1.FileUtil.getUniqueFileName(p);
+                }
+                await this.cut_exec(sysPath, p);
+                return (0, Result_1.Sucess)("1");
+            }
+        }
+        const stats = await FileUtil_1.FileUtil.statSync(sysPath);
+        if (stats.isFile()) {
+            await FileUtil_1.FileUtil.unlinkSync(sysPath);
+        }
+        else {
+            await (0, rimraf_1.rimraf)(sysPath);
+        }
+        return (0, Result_1.Sucess)("1");
+    }
+    async save(token, context, filePath) {
+        if (context === null || context === undefined) {
+            return;
+        }
+        let sysPath = decodeURIComponent(filePath);
+        if ((0, path_util_1.isAbsolutePath)(sysPath)) {
+        }
+        else {
+            sysPath = path_1.default.join(setting_service_1.settingService.getFileRootPath(token), sysPath);
+        }
+        user_service_1.userService.check_user_path(token, sysPath);
+        user_service_1.userService.check_user_only_path(token, sysPath);
+        await FileUtil_1.FileUtil.writeFileSyncWithUtf8bom(sysPath, context);
+    }
+    async common_base64_save(token, filepath, base64_context, type) {
+        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) {
+            await FileUtil_1.FileUtil.writeFileSync(sysPath, binaryData);
+        }
+        else if (type === file_pojo_1.base64UploadType.part) {
+            await FileUtil_1.FileUtil.appendFileSync(sysPath, binaryData);
+        }
+    }
+    async cut(token, data) {
+        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) {
+            await this.cut_exec(decodeURIComponent(path_1.default.join(sysPath, file)), decodeURIComponent(path_1.default.join(toSysPath, path_1.default.basename(file))));
+        }
+    }
+    async cut_exec(source_path, to_file) {
+        await FileUtil_1.FileUtil.renameSync(source_path, to_file);
+        await (0, rimraf_1.rimraf)(source_path);
+    }
+    async copy(token, data) {
+        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));
+            await fs_extra_1.default.copy(filePath, decodeURIComponent(path_1.default.join(toSysPath, path_1.default.basename(file))), { overwrite: true });
+        }
+    }
+    async newFile(token, data) {
+        await this.todoNew(token, 2, data);
+    }
+    async newDir(token, data) {
+        await this.todoNew(token, 1, data);
+    }
+    async todoNew(token, type, data) {
+        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 (await FileUtil_1.FileUtil.access(sysPath)) {
+            return;
+        }
+        if (type === 1) {
+            await FileUtil_1.FileUtil.mkdirSync(sysPath, { recursive: true });
+        }
+        else {
+            await FileUtil_1.FileUtil.writeFileSync(sysPath, data.context ?? "");
+        }
+    }
+    async rename(token, data) {
+        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));
+        await 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?.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?.cache) {
+            res.setHeader('Cache-Control', 'public, max-age=86400 ');
+        }
+        else if (param?.cache_length) {
+            res.setHeader('Cache-Control', `public, max-age=${param.cache_length}`);
+        }
+        const readStream = fs_1.default.createReadStream(file_path);
+        readStream.pipe(res);
+    }
+    async download_for_private(ctx) {
+        let 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'];
+        const range = ctx.header("Range");
+        const res = ctx.res;
+        if (!Array.isArray(file)) {
+            const p = decodeURIComponent(file);
+            if ((0, path_util_1.isAbsolutePath)(p)) {
+                file = p;
+            }
+            else {
+                file = path_1.default.join(setting_service_1.settingService.getFileRootPath(token), decodeURIComponent(file));
+            }
+            user_service_1.userService.check_user_path(token, file);
+        }
+        else {
+            const files = file;
+            const new_files = [];
+            for (const file of files) {
+                let sysPath = decodeURIComponent(file);
+                if ((0, path_util_1.isAbsolutePath)(sysPath)) {
+                }
+                else {
+                    sysPath = path_1.default.join(setting_service_1.settingService.getFileRootPath(token), sysPath);
+                }
+                user_service_1.userService.check_user_path(token, sysPath);
+                new_files.push(sysPath);
+            }
+            file = new_files;
+        }
+        this.download({ file, token, cache, show, range, res });
+    }
+    async download_for_public(ctx) {
+        const file = ctx.query.file;
+        if (!file || !file.length) {
+            ctx.res.status(404).send('File not found');
+            return;
+        }
+        const cache = ctx.query['cache'];
+        const show = ctx.query['show'];
+        const range = ctx.header("Range");
+        const res = ctx.res;
+        const share_id = ctx.query['share_id'];
+        const share_token = ctx.query['share_token'];
+        const list = setting_service_1.settingService.get_share_file_list();
+        let item;
+        for (const i of list) {
+            if (i.id === share_id) {
+                const statics = DataUtil_1.DataUtil.get(data_type_1.data_common_key.share_file_list_key_download_statics, data_type_1.file_key.statics_tag) ?? {};
+                statics[i.id] = (statics[i.id] ?? 0) + 1;
+                DataUtil_1.DataUtil.set(data_type_1.data_common_key.share_file_list_key_download_statics, statics, data_type_1.file_key.statics_tag);
+                item = i;
+                break;
+            }
+        }
+        if (!item) {
+            res.status(400).send("未知分享");
+            return;
+        }
+        if (item.token) {
+            if (item.token !== share_token) {
+                res.status(400).send("token错误");
+                return;
+            }
+        }
+        this.download({ file, cache, show, range, res });
+    }
+    async download({ file, cache, show, range, res }) {
+        if (!Array.isArray(file)) {
+            const sysPath = decodeURIComponent(file);
+            const fileName = path_1.default.basename(sysPath);
+            const stats = await FileUtil_1.FileUtil.statSync(sysPath);
+            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) {
+                    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 });
+                res.status(206);
+                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(res);
+                return;
+            }
+            if (stats.isFile()) {
+                this.download_one_file(fileName, fileSize, sysPath, res, {
+                    cache: cache === "1",
+                    handle_type_: show === "1" ? "inline" : "attachment"
+                });
+            }
+            else {
+                res.attachment(path_1.default.basename(sysPath) + ".zip");
+                const archive = archiver('zip', { zlib: { level: 5 } });
+                archive.pipe(res);
+                archive.directory(sysPath, path_1.default.basename(sysPath));
+                archive.finalize();
+            }
+        }
+        else {
+            const files = file;
+            const archive = archiver('zip', {
+                zlib: { level: 5 }
+            });
+            res.attachment("output.zip");
+            res.set('Content-Type', 'application/octet-stream');
+            archive.pipe(res);
+            for (const file of files) {
+                const sysPath = decodeURIComponent(file);
+                const stats = await 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();
+        }
+    }
+    async 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));
+        (await setting_service_1.settingService.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);
+    }
+    async uncompress(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 source_file = decodeURIComponent(pojo.source_file);
+        const tar_dir = decodeURIComponent(pojo.tar_dir ?? "");
+        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) {
+            await 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());
+        };
+        await file_compress_1.fileCompress.handle_un(pojo.format, sysSourcePath, targetFolder, outHanle);
+    }
+    async FileCompress(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 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 = await FileUtil_1.FileUtil.statSync(name);
+                if (stats.isFile()) {
+                    filePaths.push(name);
+                }
+                else {
+                    directorys.push(name);
+                }
+            }
+            catch (e) {
+            }
+        }
+        const targerFilePath = path_1.default.join(root_path, decodeURIComponent(pojo.tar_filename));
+        const handle_progress = (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());
+            }
+        };
+        let format;
+        switch (pojo.format) {
+            case file_pojo_1.FileCompressType.tar:
+                format = "tar";
+                break;
+            case file_pojo_1.FileCompressType.gz:
+                await file_compress_1.fileCompress.compressGz(pojo.compress_level, targerFilePath, filePaths, directorys, handle_progress);
+                return;
+            case file_pojo_1.FileCompressType.rar:
+                return;
+            case file_pojo_1.FileCompressType.zip:
+                format = "zip";
+                break;
+            case file_pojo_1.FileCompressType.tar_gz:
+                format = "tar";
+                break;
+        }
+        await file_compress_1.fileCompress.compress(format, pojo.compress_level, targerFilePath, filePaths, directorys, handle_progress, pojo.format === file_pojo_1.FileCompressType.tar_gz);
+    }
+    async studio_get_item(param_path, token) {
+        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 (!await FileUtil_1.FileUtil.access(sysPath)) {
+            return (0, Result_1.Fail)("路径不存在", Result_pojo_1.RCode.Fail);
+        }
+        const stats = await FileUtil_1.FileUtil.statSync(sysPath);
+        if (stats.isFile()) {
+            return (0, Result_1.Fail)("是文件", Result_pojo_1.RCode.Fail);
+        }
+        const items = await FileUtil_1.FileUtil.readdirSync(sysPath);
+        for (const item of items) {
+            const filePath = path_1.default.join(sysPath, item);
+            let stats = null;
+            try {
+                stats = await FileUtil_1.FileUtil.statSync(filePath);
+            }
+            catch (e) {
+                continue;
+            }
+            result.list.push({
+                type: stats.isFile() ? "file" : "folder",
+                name: item,
+                size: stats.size
+            });
+        }
+        return result;
+    }
+    async getDiskSizeForPath(fpath) {
+        const pojo = {};
+        try {
+            const diskData = await 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;
+    }
+    async go_forward_log(pojo, file_path) {
+        let linesRead = 0;
+        let haveReadSize = 0;
+        const fd = await 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 } = await 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;
+            }
+        }
+        await fd.close();
+        return pojo;
+    }
+    async find_back_enter_index(pojo, file_path, max_len = 10240) {
+        const fd = await 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 } = await 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;
+                await fd.close();
+                return;
+            }
+        }
+        await fd.close();
+        pojo.position = position;
+    }
+    async go_back_log(pojo, file_path) {
+        let linesRead = 0;
+        let haveReadSize = 0;
+        const fd = await 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 } = await 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;
+            }
+        }
+        await fd.close();
+        return pojo;
+    }
+    async log_viewer(data) {
+        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 = await 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)
+            await this.find_back_enter_index(pojo, file_path, 100);
+        return this.go_forward_log(pojo, file_path);
+    }
+    log_viewer_watch_cancel(data) {
+        this.file_change_watcher_map.delete(data.wss.token);
+    }
+    log_viewer_watch(data) {
+        const pojo = data.context;
+        if (this.file_change_watcher_map.has(data.wss.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(data.wss.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(data.wss.token, watcher);
+        wss.setClose(() => {
+            watcher.close();
+            this.file_change_watcher_map.delete(data.wss.token);
+        });
+        let bytesRead = pojo.max_size;
+        watcher.on('change', (changedFilePath) => {
+            if (changedFilePath === file_path) {
+                if (!this.file_change_watcher_map.has(data.wss.token)) {
+                    watcher.close();
+                    return;
+                }
+                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(data.wss.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(data.wss.token);
+        });
+    }
+    async get_share_info(id, token) {
+        const list = setting_service_1.settingService.get_share_file_list();
+        let item;
+        for (const i of list) {
+            if (i.id === id) {
+                item = i;
+                break;
+            }
+        }
+        if (!item)
+            throw "未知分享";
+        if (item.token) {
+            if (token !== item.token) {
+                return (0, Result_1.Sucess)("", Result_pojo_1.RCode.need_token_share);
+            }
+        }
+        const result = {
+            is_dir: true,
+            files: []
+        };
+        const sysPath = decodeURIComponent(item.path);
+        const stats = await FileUtil_1.FileUtil.statSync(item.path);
+        if (stats.isFile()) {
+            result.is_dir = false;
+            const mtime = stats ? new Date(stats.mtime).getTime() : 0;
+            const name = path_1.default.basename(sysPath);
+            const pojo = {
+                type: (0, FileMenuType_1.getFileFormat)(name),
+                name: name,
+                mtime: mtime,
+                size: stats.size,
+                isLink: stats?.isSymbolicLink(),
+                path: sysPath
+            };
+            result.files.push(pojo);
+        }
+        else {
+            let items = await FileUtil_1.FileUtil.readdirSync(sysPath);
+            const param_path = item.path;
+            for (const item of items) {
+                const filePath = path_1.default.join(sysPath, item);
+                let stats = null;
+                try {
+                    stats = await FileUtil_1.FileUtil.statSync(filePath);
+                }
+                catch (e) {
+                    console.log("读取错误", e);
+                }
+                let type;
+                let p;
+                let size;
+                if (!stats)
+                    continue;
+                if (stats.isFile()) {
+                    type = (0, FileMenuType_1.getFileFormat)(item);
+                    p = path_1.default.join(param_path, item);
+                    size = stats.size;
+                }
+                else if (stats.isDirectory()) {
+                    continue;
+                }
+                else {
+                    type = file_pojo_1.FileTypeEnum.dev;
+                    p = path_1.default.join(param_path, item);
+                    size = stats.size;
+                }
+                const mtime = stats ? new Date(stats.mtime).getTime() : 0;
+                const pojo = {
+                    type,
+                    name: item,
+                    mtime: mtime,
+                    size,
+                    isLink: stats?.isSymbolicLink(),
+                    path: p
+                };
+                result.files.push(pojo);
+            }
+        }
+        return (0, Result_1.Sucess)(result);
+    }
+}
+exports.FileService = FileService;
+exports.FileServiceImpl = new FileService();
+//# sourceMappingURL=file.service.js.map