Fix: File can be exported now

Author: ShenKSPZ

app/main.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
-import {app, BrowserWindow, ipcMain, shell} from 'electron';
+import {app, BrowserWindow, ipcMain, shell, dialog} from 'electron';
 import * as path from 'path';
 import * as fs from 'fs';
 import * as os from 'os';
@@ -71,6 +71,62 @@ function createWindow(): BrowserWindow {
       }
     });
   });
+  
+  // Save file handler
+  ipcMain.handle('save-file', async (event, args) => {
+    try {
+      if (!win) return { success: false, error: 'Window not available' };
+      
+      const { fileBuffer, fileName, fileType } = args;
+      
+      // Show save dialog
+      const result = await dialog.showSaveDialog(win, {
+        title: 'Save File',
+        defaultPath: fileName,
+        filters: [
+          { name: 'All Files', extensions: ['*'] }
+        ]
+      });
+      
+      if (result.canceled || !result.filePath) {
+        return { success: false, canceled: true };
+      }
+      
+      // Convert base64 to buffer if needed
+      let buffer;
+      if (typeof fileBuffer === 'string') {
+        buffer = Buffer.from(fileBuffer, 'base64');
+      } else {
+        buffer = Buffer.from(fileBuffer);
+      }
+      
+      // Write file to disk
+      fs.writeFileSync(result.filePath, buffer);
+      
+      return { success: true, filePath: result.filePath };
+    } catch (error) {
+      console.error('Error saving file:', error);
+      return { success: false, error: String(error) };
+    }
+  });
+  
+  // Open file handler
+  ipcMain.handle('open-file', async (event, filePath) => {
+    try {
+      if (!filePath) return { success: false, error: 'No file path provided' };
+      
+      const result = await shell.openPath(filePath);
+      
+      if (result) {
+        return { success: false, error: result };
+      }
+      
+      return { success: true };
+    } catch (error) {
+      console.error('Error opening file:', error);
+      return { success: false, error: String(error) };
+    }
+  });
 
   // Window control handlers
 

app/preload.ts

@@ -26,4 +26,7 @@ contextBridge.exposeInMainWorld('electron', {
   // File and URL operations
   openUrl: (url: string) => ipcRenderer.send('open-url', url),
   openFolderByFile: (path: string) => ipcRenderer.send('open-folder-by-file', path),
+  saveFile: (fileBuffer: ArrayBuffer | string, fileName: string, fileType: string) => 
+    ipcRenderer.invoke('save-file', { fileBuffer, fileName, fileType }),
+  openFile: (filePath: string) => ipcRenderer.invoke('open-file', filePath),
 }); 

src/components/pages/FileManagementPage.tsx

@@ -257,16 +257,24 @@ export const FileManagementPage = () => {
   // Export file
   const handleExportFile = async (file: FileData) => {
     try {
-      const blob = new Blob([file.data], { type: file.type || 'application/octet-stream' });
-      const url = URL.createObjectURL(blob);
+      if (!window.electron || !window.electron.saveFile) {
+        console.error("Electron saveFile API not available");
+        return;
+      }
+      
+      const result = await window.electron.saveFile(
+        file.data, 
+        file.name, 
+        file.type || 'application/octet-stream'
+      );
 
-      const a = document.createElement('a');
-      a.href = url;
-      a.download = file.name;
-      document.body.appendChild(a);
-      a.click();
-      document.body.removeChild(a);
-      URL.revokeObjectURL(url);
+      if (!result.success) {
+        if (result.canceled) {
+          // User canceled the save dialog, no need to show error
+          return;
+        }
+        console.error("Error saving file:", result.error);
+      }
     } catch (error) {
       console.error("Error exporting file:", error);
     }
@@ -275,10 +283,32 @@ export const FileManagementPage = () => {
   // Open file
   const handleOpenFile = async (file: FileData) => {
     try {
-      // Use electron API to open the file
-      const blob = new Blob([file.data], { type: file.type || 'application/octet-stream' });
-      const url = URL.createObjectURL(blob);
-      window.electron.openUrl(url);
+      // First save the file to a temporary location
+      if (!window.electron || !window.electron.saveFile || !window.electron.openFile) {
+        console.error("Electron API not available");
+        return;
+      }
+      
+      // Save file to temp location and then open it
+      const saveResult = await window.electron.saveFile(
+        file.data,
+        file.name,
+        file.type || 'application/octet-stream'
+      );
+      
+      if (!saveResult.success || !saveResult.filePath) {
+        if (!saveResult.canceled) {
+          console.error("Error saving file:", saveResult.error);
+        }
+        return;
+      }
+      
+      // Now open the file with the default application
+      const openResult = await window.electron.openFile(saveResult.filePath);
+      
+      if (!openResult.success) {
+        console.error("Error opening file:", openResult.error);
+      }
     } catch (error) {
       console.error("Error opening file:", error);
     }
@@ -642,13 +672,13 @@ export const FileManagementPage = () => {
                         </td>
                         <td className="px-4 py-3">
                           <div className="flex items-center justify-center space-x-2">
-                            <button
+                            {/* <button
                               onClick={() => handleOpenFile(file)}
                               className="p-2 rounded-md message-icon-btn"
                               title={t("fileManagement.open")}
                             >
                               <FolderOpen size={16} />
-                            </button>
+                            </button> */}
                             <button
                               onClick={() => {
                                 setSelectedFile(file);

src/types/window.d.ts

@@ -14,5 +14,15 @@ interface Window {
     }>;
     openUrl: (url: string) => Promise<void>;
     onWindowMaximizedChange: (callback: (event: IpcRendererEvent, maximized: boolean) => void) => void;
+    saveFile: (fileBuffer: ArrayBuffer | string, fileName: string, fileType: string) => Promise<{
+      success: boolean;
+      filePath?: string;
+      canceled?: boolean;
+      error?: string;
+    }>;
+    openFile: (filePath: string) => Promise<{
+      success: boolean;
+      error?: string;
+    }>;
   };
 }