Check for unsaved changes before import/open/export

src/ElectronBackend/main/createWindow.ts

@@ -13,6 +13,8 @@ export async function createWindow(): Promise<BrowserWindow> {
   const mainWindow = new BrowserWindow({
     width: 1920,
     height: 1080,
+    minWidth: 500,
+    minHeight: 300,
     webPreferences: {
       contextIsolation: true,
       nodeIntegration: false,

src/ElectronBackend/main/listeners.ts

@@ -195,7 +195,7 @@ export function getImportFileConvertAndLoadListener(
       opossumFilePath: string,
     ) => {
       if (!resourceFilePath.trim() || !fs.existsSync(resourceFilePath)) {
-        throw new Error('Input file does not exists');
+        throw new Error('Input file does not exist');
       }
 
       if (!opossumFilePath.trim()) {

src/ElectronBackend/main/logger.ts

@@ -13,7 +13,10 @@ class Logger {
     message: string,
     { level }: Pick<Log, 'level'>,
   ): void {
-    BrowserWindow.getFocusedWindow()?.webContents.send(
+    // NOTE: there are situations where BrowserWindow.getAllWindows() returns a
+    // non-empty array but BrowserWindow.getFocusedWindow() returns null.
+    // Thus, using getAllWindows here is more robust than getFocusedWindow
+    BrowserWindow.getAllWindows()[0]?.webContents.send(
       AllowedFrontendChannels.Logging,
       {
         date: new Date(),

src/ElectronBackend/main/menu.ts

@@ -17,13 +17,7 @@ import {
   getIconBasedOnTheme,
   makeFirstIconVisibleAndSecondHidden,
 } from './iconHelpers';
-import {
-  getImportFileListener,
-  getOpenFileListener,
-  getSelectBaseURLListener,
-  setLoadingState,
-} from './listeners';
-import logger from './logger';
+import { getImportFileListener, getSelectBaseURLListener } from './listeners';
 import {
   getPathOfChromiumNoticeDocument,
   getPathOfNoticeDocument,
@@ -113,7 +107,10 @@ export async function createMenu(mainWindow: BrowserWindow): Promise<Menu> {
           ),
           label: 'Open File',
           accelerator: 'CmdOrCtrl+O',
-          click: getOpenFileListener(mainWindow, activateMenuItems),
+          click: () =>
+            mainWindow.webContents.send(
+              AllowedFrontendChannels.OpenFileWithUnsavedCheck,
+            ),
         },
         {
           icon: getIconBasedOnTheme(
@@ -155,8 +152,6 @@ export async function createMenu(mainWindow: BrowserWindow): Promise<Menu> {
                 'icons/follow-up-black.png',
               ),
               click: () => {
-                setLoadingState(mainWindow.webContents, true);
-                logger.info('Preparing data for follow-up export');
                 webContents.send(
                   AllowedFrontendChannels.ExportFileRequest,
                   ExportType.FollowUp,
@@ -172,8 +167,6 @@ export async function createMenu(mainWindow: BrowserWindow): Promise<Menu> {
               ),
               label: INITIALLY_DISABLED_ITEMS_INFO.compactComponentList.label,
               click: () => {
-                setLoadingState(mainWindow.webContents, true);
-                logger.info('Preparing data for compact component list export');
                 webContents.send(
                   AllowedFrontendChannels.ExportFileRequest,
                   ExportType.CompactBom,
@@ -189,10 +182,6 @@ export async function createMenu(mainWindow: BrowserWindow): Promise<Menu> {
               ),
               label: INITIALLY_DISABLED_ITEMS_INFO.detailedComponentList.label,
               click: () => {
-                setLoadingState(mainWindow.webContents, true);
-                logger.info(
-                  'Preparing data for detailed component list export',
-                );
                 webContents.send(
                   AllowedFrontendChannels.ExportFileRequest,
                   ExportType.DetailedBom,
@@ -208,8 +197,6 @@ export async function createMenu(mainWindow: BrowserWindow): Promise<Menu> {
               ),
               label: INITIALLY_DISABLED_ITEMS_INFO.spdxYAML.label,
               click: () => {
-                setLoadingState(mainWindow.webContents, true);
-                logger.info('Preparing data for SPDX (yaml) export');
                 webContents.send(
                   AllowedFrontendChannels.ExportFileRequest,
                   ExportType.SpdxDocumentYaml,
@@ -225,8 +212,6 @@ export async function createMenu(mainWindow: BrowserWindow): Promise<Menu> {
               ),
               label: INITIALLY_DISABLED_ITEMS_INFO.spdxJSON.label,
               click: () => {
-                setLoadingState(mainWindow.webContents, true);
-                logger.info('Preparing data for SPDX (json) export');
                 webContents.send(
                   AllowedFrontendChannels.ExportFileRequest,
                   ExportType.SpdxDocumentJson,

src/Frontend/Components/App/App.tsx

@@ -15,7 +15,6 @@ import { useSignalsWorker } from '../../web-workers/use-signals-worker';
 import { AuditView } from '../AuditView/AuditView';
 import { ErrorFallback } from '../ErrorFallback/ErrorFallback';
 import { GlobalPopup } from '../GlobalPopup/GlobalPopup';
-import { ImportDialogProvider } from '../ImportDialog/ImportDialogProvider';
 import { ProcessPopup } from '../ProcessPopup/ProcessPopup';
 import { ReportView } from '../ReportView/ReportView';
 import { TopBar } from '../TopBar/TopBar';
@@ -40,7 +39,6 @@ export function App() {
           <ErrorBoundary FallbackComponent={ErrorFallback}>
             <GlobalPopup />
             <ProcessPopup />
-            <ImportDialogProvider />
             <TopBar />
             {renderView()}
           </ErrorBoundary>

src/Frontend/Components/BackendCommunication/BackendCommunication.tsx

@@ -5,47 +5,40 @@
 // SPDX-License-Identifier: Apache-2.0
 import dayjs from 'dayjs';
 import { IpcRendererEvent } from 'electron';
-import pick from 'lodash/pick';
 
 import { AllowedFrontendChannels } from '../../../shared/ipc-channels';
 import {
-  Attributions,
   BaseURLForRootArgs,
-  ExportSpdxDocumentJsonArgs,
-  ExportSpdxDocumentYamlArgs,
-  ExportType,
   ParsedFileContent,
 } from '../../../shared/shared-types';
 import { PopupType } from '../../enums/enums';
 import { ROOT_PATH } from '../../shared-constants';
+import {
+  exportFileOrOpenUnsavedPopup,
+  openFileOrOpenUnsavedPopup,
+  showImportDialogOrOpenUnsavedPopup,
+} from '../../state/actions/popup-actions/popup-actions';
 import {
   resetResourceState,
   setBaseUrlsForSources,
 } from '../../state/actions/resource-actions/all-views-simple-actions';
 import { loadFromFile } from '../../state/actions/resource-actions/load-actions';
-import { openPopup } from '../../state/actions/view-actions/view-actions';
-import { useAppDispatch, useAppSelector } from '../../state/hooks';
 import {
-  getAttributionBreakpoints,
-  getBaseUrlsForSources,
-  getFilesWithChildren,
-  getFrequentLicensesTexts,
-  getManualData,
-  getResources,
-} from '../../state/selectors/resource-selectors';
+  openPopup,
+  setLoading,
+  writeLogMessage,
+} from '../../state/actions/view-actions/view-actions';
+import { useAppDispatch, useAppSelector } from '../../state/hooks';
+import { getBaseUrlsForSources } from '../../state/selectors/resource-selectors';
 import {
-  getAttributionsWithAllChildResourcesWithoutFolders,
-  getAttributionsWithResources,
-  removeSlashesFromFilesWithChildren,
-} from '../../util/get-attributions-with-resources';
-import { LoggingListener, useIpcRenderer } from '../../util/use-ipc-renderer';
+  ExportFileRequestListener,
+  IsLoadingListener,
+  LoggingListener,
+  ShowImportDialogListener,
+  useIpcRenderer,
+} from '../../util/use-ipc-renderer';
 
 export const BackendCommunication: React.FC = () => {
-  const resources = useAppSelector(getResources);
-  const manualData = useAppSelector(getManualData);
-  const attributionBreakpoints = useAppSelector(getAttributionBreakpoints);
-  const filesWithChildren = useAppSelector(getFilesWithChildren);
-  const frequentLicenseTexts = useAppSelector(getFrequentLicensesTexts);
   const baseUrlsForSources = useAppSelector(getBaseUrlsForSources);
   const dispatch = useAppDispatch();
 
@@ -58,118 +51,6 @@ export const BackendCommunication: React.FC = () => {
       dispatch(openPopup(PopupType.ProjectStatisticsPopup));
   }
 
-  function getExportFileRequestListener(
-    _: IpcRendererEvent,
-    exportType: ExportType,
-  ): void {
-    switch (exportType) {
-      case ExportType.SpdxDocumentJson:
-      case ExportType.SpdxDocumentYaml:
-        return getSpdxDocumentExportListener(exportType);
-      case ExportType.FollowUp:
-        return getFollowUpExportListener();
-      case ExportType.CompactBom:
-        return getCompactBomExportListener();
-      case ExportType.DetailedBom:
-        return getDetailedBomExportListener();
-    }
-  }
-
-  function getFollowUpExportListener(): void {
-    const followUpAttributions = pick(
-      manualData.attributions,
-      Object.keys(manualData.attributions).filter(
-        (attributionId) => manualData.attributions[attributionId].followUp,
-      ),
-    );
-
-    const followUpAttributionsWithResources =
-      getAttributionsWithAllChildResourcesWithoutFolders(
-        followUpAttributions,
-        manualData.attributionsToResources,
-        manualData.resourcesToAttributions,
-        resources || {},
-        attributionBreakpoints,
-        filesWithChildren,
-      );
-    const followUpAttributionsWithFormattedResources =
-      removeSlashesFromFilesWithChildren(
-        followUpAttributionsWithResources,
-        filesWithChildren,
-      );
-
-    window.electronAPI.exportFile({
-      type: ExportType.FollowUp,
-      followUpAttributionsWithResources:
-        followUpAttributionsWithFormattedResources,
-    });
-  }
-
-  function getSpdxDocumentExportListener(
-    exportType: ExportType.SpdxDocumentYaml | ExportType.SpdxDocumentJson,
-  ): void {
-    const attributions = Object.fromEntries(
-      Object.entries(manualData.attributions).map((entry) => {
-        const packageInfo = entry[1];
-
-        const licenseName = packageInfo.licenseName || '';
-        const isFrequentLicense =
-          licenseName && licenseName in frequentLicenseTexts;
-        const licenseText =
-          packageInfo.licenseText || isFrequentLicense
-            ? frequentLicenseTexts[licenseName]
-            : '';
-        return [
-          entry[0],
-          {
-            ...entry[1],
-            licenseText,
-          },
-        ];
-      }),
-    );
-
-    const args: ExportSpdxDocumentYamlArgs | ExportSpdxDocumentJsonArgs = {
-      type: exportType,
-      spdxAttributions: attributions,
-    };
-
-    window.electronAPI.exportFile(args);
-  }
-
-  function getDetailedBomExportListener(): void {
-    const bomAttributions = getBomAttributions(
-      manualData.attributions,
-      ExportType.DetailedBom,
-    );
-
-    const bomAttributionsWithResources = getAttributionsWithResources(
-      bomAttributions,
-      manualData.attributionsToResources,
-    );
-
-    const bomAttributionsWithFormattedResources =
-      removeSlashesFromFilesWithChildren(
-        bomAttributionsWithResources,
-        filesWithChildren,
-      );
-
-    window.electronAPI.exportFile({
-      type: ExportType.DetailedBom,
-      bomAttributionsWithResources: bomAttributionsWithFormattedResources,
-    });
-  }
-
-  function getCompactBomExportListener(): void {
-    window.electronAPI.exportFile({
-      type: ExportType.CompactBom,
-      bomAttributions: getBomAttributions(
-        manualData.attributions,
-        ExportType.CompactBom,
-      ),
-    });
-  }
-
   function resetLoadedFileListener(
     _: IpcRendererEvent,
     resetState: boolean,
@@ -220,6 +101,13 @@ export const BackendCommunication: React.FC = () => {
     }
   }
 
+  useIpcRenderer<IsLoadingListener>(
+    AllowedFrontendChannels.FileLoading,
+    (_, { isLoading }) => {
+      dispatch(setLoading(isLoading));
+    },
+    [dispatch],
+  );
   useIpcRenderer(AllowedFrontendChannels.FileLoaded, fileLoadedListener, [
     dispatch,
   ]);
@@ -230,8 +118,11 @@ export const BackendCommunication: React.FC = () => {
   );
   useIpcRenderer<LoggingListener>(
     AllowedFrontendChannels.Logging,
-    (_, { date, level, message }) =>
-      console[level](`${dayjs(date).format('HH:mm:ss.SSS')} ${message}`),
+    (_, log) => {
+      const { date, level, message } = log;
+      console[level](`${dayjs(date).format('HH:mm:ss.SSS')} ${message}`);
+      dispatch(writeLogMessage(log));
+    },
     [dispatch],
   );
   useIpcRenderer(
@@ -249,39 +140,26 @@ export const BackendCommunication: React.FC = () => {
     setBaseURLForRootListener,
     [dispatch, baseUrlsForSources],
   );
-  useIpcRenderer(
+  useIpcRenderer<ExportFileRequestListener>(
     AllowedFrontendChannels.ExportFileRequest,
-    getExportFileRequestListener,
-    [
-      manualData,
-      attributionBreakpoints,
-      frequentLicenseTexts,
-      filesWithChildren,
-    ],
+    (_, exportType) => dispatch(exportFileOrOpenUnsavedPopup(exportType)),
+    [dispatch],
   );
   useIpcRenderer(
     AllowedFrontendChannels.ShowUpdateAppPopup,
     showUpdateAppPopupListener,
     [dispatch],
   );
+  useIpcRenderer(
+    AllowedFrontendChannels.OpenFileWithUnsavedCheck,
+    () => dispatch(openFileOrOpenUnsavedPopup()),
+    [dispatch],
+  );
+  useIpcRenderer<ShowImportDialogListener>(
+    AllowedFrontendChannels.ImportFileShowDialog,
+    (_, fileFormat) => dispatch(showImportDialogOrOpenUnsavedPopup(fileFormat)),
+    [dispatch],
+  );
 
   return null;
 };
-
-export function getBomAttributions(
-  attributions: Attributions,
-  exportType: ExportType,
-): Attributions {
-  return pick(
-    attributions,
-    Object.keys(attributions).filter(
-      (attributionId) =>
-        !attributions[attributionId].followUp &&
-        !attributions[attributionId].firstParty &&
-        !(
-          exportType === ExportType.CompactBom &&
-          attributions[attributionId].excludeFromNotice
-        ),
-    ),
-  );
-}