mirror of https://gitee.com/godoos/godoos.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
479 lines
14 KiB
479 lines
14 KiB
import * as fs from '@/api/net/files';
|
|
import { joinknowledge } from '@/api/net/knowledge';
|
|
import { shareCreate } from "@/api/net/share";
|
|
import { eventBus } from '@/interfaces/event';
|
|
import { getFileType } from '@/router/filemaplist';
|
|
import { errMsg, noticeMsg, promptMsg, promptPwd, successMsg } from '@/utils/msg';
|
|
import { defineStore } from 'pinia';
|
|
import { ref } from 'vue';
|
|
import { useRouter } from 'vue-router';
|
|
export const useFileSystemStore = defineStore('filesystem', () => {
|
|
const currentPath: any = ref('')
|
|
const currentShareFile: any = ref({});
|
|
const router = useRouter()
|
|
const initChoose = {
|
|
ifShow: false,
|
|
isSave: false,
|
|
paths: [] as string[],
|
|
exts: [] as string[],
|
|
ext: '',
|
|
defName: '',
|
|
content: ''
|
|
}
|
|
const choose = ref({ ...initChoose })
|
|
const pwdPathMap: any = ref({})
|
|
|
|
// 加入知识库
|
|
const joinKnowledge = async (path: string) => {
|
|
const res = await joinknowledge(path)
|
|
if (res.success) {
|
|
successMsg(res.message);
|
|
} else {
|
|
errMsg(res.message);
|
|
}
|
|
refreshPaths()
|
|
}
|
|
|
|
// 读取知识库盘
|
|
|
|
|
|
const setPwdPathMap = (path: string, pwd?: string) => {
|
|
if (pwd && pwd !== '') {
|
|
pwdPathMap.value[path] = pwd;
|
|
}
|
|
};
|
|
|
|
const getPwdPathMap = (path: string) => {
|
|
const pwd = pwdPathMap.value[path] || '';
|
|
return pwd;
|
|
};
|
|
|
|
const getFilesInPath = async (path: string, pwd?: string) => {
|
|
currentPath.value = path;
|
|
setPwdPathMap(path, pwd);
|
|
const res = await fs.read(path, getPwdPathMap(path));
|
|
if (!res.success) {
|
|
pwd = await promptPwd();
|
|
if (!pwd) return;
|
|
setPwdPathMap(path, pwd);
|
|
const res = await fs.read(path, pwd);
|
|
//console.log(res)
|
|
if (!res.success) {
|
|
noticeMsg('密码错误', '提示', 'error');
|
|
return [];
|
|
} else {
|
|
return res.data;
|
|
}
|
|
}
|
|
return res.data;
|
|
};
|
|
const initFolder = (path: string) => {
|
|
currentPath.value = path;
|
|
}
|
|
const getUniqueFilePath = async (filePath: string, defname: string, ext: string, path: string, sp: string, i: number): Promise<string> => {
|
|
const isExits = await fs.exists(filePath);
|
|
//console.log(isExits)
|
|
if (isExits) {
|
|
return getUniqueFilePath(`${path}${sp}${defname}(${i})${ext}`, defname, ext, path, sp, i + 1);
|
|
}
|
|
return filePath;
|
|
};
|
|
const getUniquePath = async (path: string): Promise<string> => {
|
|
const sp = path.charAt(0);
|
|
const baseName = fs.basename(path);
|
|
const arr = baseName.split('.');
|
|
//console.log(arr)
|
|
const defname = arr[0];
|
|
const ext = arr[1] ? `.${arr[1]}` : '';
|
|
const dir = arr[1] ? fs.dirname(path) : path;
|
|
let newFilePath = arr[1] ? `${dir}${sp}${defname}${ext}` : `${path}`;
|
|
//console.log(newFilePath)
|
|
newFilePath = await getUniqueFilePath(newFilePath, defname, ext, dir, sp, 1);
|
|
return newFilePath;
|
|
};
|
|
const handleNewFile = async (defname: string, ext: string) => {
|
|
const path = currentPath.value;
|
|
//console.log(path)
|
|
const sp = path.charAt(0);
|
|
let newFilePath = `${path}${sp}${defname}${ext}`;
|
|
newFilePath = await getUniqueFilePath(newFilePath, defname, ext, path, sp, 1);
|
|
//console.log(newFilePath);
|
|
await fs.writeFile(newFilePath, '');
|
|
refreshPaths()
|
|
}
|
|
const handleReadFile = async (filePath: string, pwd?: string) => {
|
|
setPwdPathMap(filePath, pwd);
|
|
const res = await fs.readFile(filePath, getPwdPathMap(filePath));
|
|
if (!res.success) {
|
|
pwd = await promptPwd();
|
|
if (!pwd) return;
|
|
setPwdPathMap(filePath, pwd);
|
|
const res = await fs.readFile(filePath, pwd);
|
|
if (!res.success) {
|
|
noticeMsg('密码错误', '提示', 'error');
|
|
return;
|
|
}
|
|
else {
|
|
return res.data;
|
|
}
|
|
}
|
|
return res.data;
|
|
}
|
|
const handlePwdFile = async (path: string) => {
|
|
const pwd = await promptPwd();
|
|
if (!pwd) return;
|
|
const res = await fs.pwd(path, pwd);
|
|
refreshPaths()
|
|
return res;
|
|
}
|
|
const handleUnpwdFile = async (filePath: string) => {
|
|
const pwd = await promptPwd();
|
|
if (!pwd) return;
|
|
const res = await fs.unpwd(filePath, pwd);
|
|
refreshPaths()
|
|
return res;
|
|
}
|
|
const handleWriteFile = async (filePath: string, data: any, pwd?: string) => {
|
|
//console.log('data:', data)
|
|
setPwdPathMap(filePath, pwd);
|
|
let res = await fs.writeFile(filePath, data, getPwdPathMap(filePath));
|
|
if (!res) {
|
|
const pwd = await promptPwd();
|
|
if (!pwd) return;
|
|
setPwdPathMap(filePath, pwd);
|
|
res = await fs.writeFile(filePath, data, pwd);
|
|
}
|
|
refreshPaths()
|
|
return res
|
|
}
|
|
const refreshPaths = () => {
|
|
eventBus.emit('refreshDesktop');
|
|
}
|
|
|
|
const handleSerach = async (path: string, query: string) => {
|
|
const res = await fs.search(path, query);
|
|
return res || [];
|
|
}
|
|
const handleDeleteFile = async (path: string) => {
|
|
if (!path) return;
|
|
await fs.rmdir(path)
|
|
//console.log(dirname(path))
|
|
refreshPaths()
|
|
}
|
|
const handleDeleteFiles = async (filePaths: string[]) => {
|
|
for (const filePath of filePaths) {
|
|
await fs.rmdir(filePath)
|
|
}
|
|
refreshPaths()
|
|
}
|
|
const handleNewDir = async (dirname: string) => {
|
|
const path = currentPath.value;
|
|
//console.log(path)
|
|
const sp = path.charAt(0);
|
|
let newDirPath = `${path}${sp}${dirname}`;
|
|
newDirPath = await getUniqueFilePath(`${newDirPath}`, dirname, '', path, sp, 1);
|
|
await fs.mkdir(newDirPath);
|
|
refreshPaths()
|
|
}
|
|
const handleRenameFile = async (oldPath: string) => {
|
|
if (!oldPath) return;
|
|
//const sp = oldPath.charAt(0);
|
|
const oldName = fs.basename(oldPath);
|
|
const newName = await promptMsg('请输入新文件名', '重命名', oldName);
|
|
//console.log(newName)
|
|
if (!newName || newName == '') return;
|
|
const parentpath = fs.getParentPath(oldPath);
|
|
const newFilePath = fs.join(parentpath, newName);
|
|
await fs.rename(oldPath, newFilePath);
|
|
refreshPaths()
|
|
}
|
|
const handleShareFile = async (data: any) => {
|
|
const res = await shareCreate(JSON.stringify(data));
|
|
refreshPaths()
|
|
return res;
|
|
}
|
|
|
|
const openfile = async (file: any) => {
|
|
if (file.isPwd) {
|
|
const pwd = await promptPwd();
|
|
if (pwd) {
|
|
setPwdPathMap(file.path, pwd);
|
|
} else {
|
|
errMsg('请输入密码');
|
|
return;
|
|
}
|
|
}
|
|
if (file.isDirectory) {
|
|
router.push({ path: '/computer', query: { path: file.path } });
|
|
} else {
|
|
if (file.ext == 'exe') {
|
|
router.push('/' + file.title);
|
|
} else {
|
|
//file.content = ''
|
|
//console.log(file)
|
|
const fileMap = getFileType(file.ext)
|
|
if (fileMap) {
|
|
file.editor = fileMap.editor;
|
|
file.hasPrview = fileMap.hasPrview;
|
|
file.eventType = fileMap.eventType;
|
|
file.exts = fileMap.ext;
|
|
}
|
|
router.push({ path: '/viewer', query: file });
|
|
}
|
|
}
|
|
}
|
|
const openFile = async (file: any) => {
|
|
if (typeof file == 'string') {
|
|
const f = await fs.stat(file)
|
|
await openfile(f)
|
|
} else {
|
|
await openfile(file)
|
|
}
|
|
}
|
|
|
|
const openEditor = (file: any) => {
|
|
file.content = ''
|
|
file.action = 'edit';
|
|
// router.push({ path: '/viewer', query: file });
|
|
openFile(file)
|
|
}
|
|
const moveFiles = async (filePaths: string[], targetPath: string) => {
|
|
const toFile = await fs.stat(targetPath);
|
|
if (toFile?.isDirectory) {
|
|
for (const filePath of filePaths) {
|
|
//console.log(filePath)
|
|
let newPath = fs.join(targetPath, fs.basename(filePath));
|
|
//console.log(newPath)
|
|
newPath = await getUniquePath(newPath);
|
|
//console.log(newPath)
|
|
await fs.rename(filePath, newPath);
|
|
}
|
|
refreshPaths()
|
|
}
|
|
}
|
|
const copyFiles = async (filePaths: string[], targetPath: string) => {
|
|
const toFile = await fs.stat(targetPath);
|
|
if (toFile?.isDirectory) {
|
|
for (const filePath of filePaths) {
|
|
let newPath = fs.join(targetPath, fs.basename(filePath));
|
|
newPath = await getUniquePath(newPath);
|
|
await fs.copy(filePath, newPath);
|
|
}
|
|
refreshPaths()
|
|
}
|
|
}
|
|
const handleUnzipFile = async (filePath: string) => {
|
|
await fs.unzip(filePath);
|
|
refreshPaths()
|
|
}
|
|
const handleFavorite = async (filePath: string) => {
|
|
await fs.favorite(filePath);
|
|
refreshPaths()
|
|
}
|
|
const handleZipFile = async (filePath: string, ext: string) => {
|
|
await fs.zip(filePath, ext);
|
|
refreshPaths()
|
|
noticeMsg('压缩成功');
|
|
}
|
|
const handleFileStat = async (filePath: string) => {
|
|
return await fs.stat(filePath);
|
|
}
|
|
const chooseFiles = (exts: string[] = []) => {
|
|
choose.value.ifShow = true;
|
|
choose.value.isSave = false;
|
|
choose.value.exts = exts;
|
|
router.push({ path: '/computer' });
|
|
}
|
|
const saveFiles = async (defname: string, ext: string, content: any) => {
|
|
choose.value.ifShow = true;
|
|
choose.value.isSave = true;
|
|
choose.value.ext = ext;
|
|
if (!defname || defname == '') {
|
|
defname = await promptMsg('请输入文件名', '文件名', '');
|
|
}
|
|
//defname = defname ?? prompt('请输入文件名') ?? '';
|
|
|
|
if (!defname) {
|
|
return;
|
|
}
|
|
|
|
if (!defname.endsWith(ext)) {
|
|
defname = `${defname}.${ext}`;
|
|
}
|
|
|
|
choose.value.defName = defname;
|
|
choose.value.content = content;
|
|
const extArr = {
|
|
'/C/Users/Documents/Word': ['docx'],
|
|
'/C/Users/Documents/PPT': ['pptx'],
|
|
'/C/Users/Documents/Markdown': ['md'],
|
|
'/C/Users/Documents/Execl': ['xlsx', 'xls'],
|
|
'/C/Users/Documents/Mind': ['mind'],
|
|
'/C/Users/Documents/Kanban': ['kb'],
|
|
'/C/Users/Documents/Baiban': ['bb'],
|
|
'/C/Users/Documents/Screenshot': ['screenshot'],
|
|
'/C/Users/Documents/ScreenRecoding': ['screentRecording'],
|
|
'/C/Users/Pictures': ['png', 'jpg', 'webp', 'gif', 'bmp', 'tiff'],
|
|
'/C/Users/Music': ['mp3'],
|
|
'/C/Users/Videos': ['mp4']
|
|
}
|
|
let savePath = '/D'
|
|
if (ext !== '') {
|
|
for (const [key, value] of Object.entries(extArr)) {
|
|
if (value.includes(ext)) {
|
|
savePath = key;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
router.push({ path: '/computer', query: { path: savePath } });
|
|
}
|
|
const clearChoose = () => {
|
|
choose.value = { ...initChoose };
|
|
}
|
|
const parserFormData = (content: any, contentType: any) => {
|
|
return fs.parserFormData(content, contentType);
|
|
}
|
|
const reStoreFiles = async (dirPath: string) => {
|
|
await fs.restore(dirPath);
|
|
refreshPaths()
|
|
}
|
|
function uploadFile(accept: string = '*/*') {
|
|
const fileInput = ref<HTMLInputElement | null>(null);
|
|
|
|
// 创建隐藏的文件输入元素
|
|
const createFileInput = () => {
|
|
const input = document.createElement('input');
|
|
input.type = 'file';
|
|
input.accept = accept;
|
|
input.multiple = true;
|
|
input.style.display = 'none';
|
|
input.addEventListener('change', handleFileChange);
|
|
document.body.appendChild(input);
|
|
fileInput.value = input;
|
|
};
|
|
|
|
// 触发文件选择对话框
|
|
const triggerFileInput = () => {
|
|
if (fileInput.value) {
|
|
fileInput.value.click();
|
|
}
|
|
};
|
|
|
|
// 处理文件选择事件
|
|
const handleFileChange = (event: Event) => {
|
|
const target = event.target as HTMLInputElement;
|
|
if (target.files && target.files.length > 0) {
|
|
//const file = target.files[0];
|
|
onFileSelected(target.files);
|
|
}
|
|
// 移除文件输入元素
|
|
if (fileInput.value) {
|
|
fileInput.value.remove();
|
|
fileInput.value = null;
|
|
}
|
|
};
|
|
|
|
// 创建并触发文件输入元素
|
|
createFileInput();
|
|
triggerFileInput();
|
|
}
|
|
async function onFileSelected(list: any) {
|
|
if (!list) return;
|
|
const len = list.length
|
|
const path = fs.dirname(currentPath.value);
|
|
for (let i = 0; i < len; i++) {
|
|
//setProgress((i / len) * 100);
|
|
await new Promise((resolve) => {
|
|
const item = list?.[i];
|
|
//console.log(item)
|
|
if (!item) return;
|
|
const reader = new FileReader();
|
|
//读取成功
|
|
reader.onload = function () {
|
|
};
|
|
reader.onloadstart = function () {
|
|
//console.log('读取开始');
|
|
};
|
|
reader.onloadend = async function () {
|
|
await handleWriteFile(fs.join(path, item.name), reader.result as any)
|
|
resolve(true);
|
|
};
|
|
reader.onabort = function () {
|
|
//console.log('中断');
|
|
};
|
|
reader.onerror = function () {
|
|
//console.log('读取失败');
|
|
};
|
|
reader.onprogress = function () {
|
|
//const scale = ev.loaded / ev.total;
|
|
//setProgress(scale);
|
|
};
|
|
reader.readAsArrayBuffer(item);
|
|
});
|
|
}
|
|
//setProgress(100);
|
|
}
|
|
async function downloadFile(filePath: string) {
|
|
try {
|
|
const fileContent = await handleReadFile(filePath);
|
|
if (!fileContent) {
|
|
noticeMsg('文件读取失败', '提示', 'error');
|
|
return;
|
|
}
|
|
|
|
const blob = new Blob([fileContent], { type: 'application/octet-stream' });
|
|
const url = URL.createObjectURL(blob);
|
|
const a = document.createElement('a');
|
|
a.href = url;
|
|
a.download = fs.basename(filePath);
|
|
document.body.appendChild(a);
|
|
a.click();
|
|
document.body.removeChild(a);
|
|
URL.revokeObjectURL(url);
|
|
//noticeMsg('文件下载成功', '提示', 'success');
|
|
} catch (error) {
|
|
noticeMsg('文件下载失败', '提示', 'error');
|
|
console.error(error);
|
|
}
|
|
}
|
|
return {
|
|
// editFilePath,
|
|
currentPath,
|
|
choose,
|
|
currentShareFile,
|
|
fs,
|
|
initFolder,
|
|
getFilesInPath,
|
|
getUniquePath,
|
|
handleNewFile,
|
|
handleDeleteFiles,
|
|
handleDeleteFile,
|
|
handleWriteFile,
|
|
handlePwdFile,
|
|
handleUnpwdFile,
|
|
handleRenameFile,
|
|
handleShareFile,
|
|
handleUnzipFile,
|
|
handleZipFile,
|
|
handleFavorite,
|
|
handleFileStat,
|
|
handleSerach,
|
|
refreshPaths,
|
|
reStoreFiles,
|
|
handleNewDir,
|
|
openFile,
|
|
handleReadFile,
|
|
openEditor,
|
|
moveFiles,
|
|
copyFiles,
|
|
chooseFiles,
|
|
clearChoose,
|
|
saveFiles,
|
|
parserFormData,
|
|
uploadFile,
|
|
downloadFile,
|
|
joinKnowledge,
|
|
|
|
};
|
|
});
|