refactor: collect error message strings in text.ts

Author: PhilippMa

src/ElectronBackend/main/listeners.ts

@@ -24,6 +24,7 @@ import {
   PackageInfo,
   SaveFileArgs,
 } from '../../shared/shared-types';
+import { text } from '../../shared/text';
 import { writeFile, writeOpossumFile } from '../../shared/write-file';
 import { LoadedFileFormat } from '../enums/enums';
 import {
@@ -206,31 +207,31 @@ export function getImportFileConvertAndLoadListener(
       opossumFilePath: string,
     ) => {
       if (!resourceFilePath.trim() || !fs.existsSync(resourceFilePath)) {
-        throw new Error('Input file does not exist');
+        throw new Error(text.backendError.inputFileDoesNotExist);
       }
 
       try {
         fs.accessSync(resourceFilePath, fs.constants.R_OK);
       } catch (error) {
-        throw new Error('Permission error: cannot read input file');
+        throw new Error(text.backendError.inputFilePermissionError);
       }
 
       if (!opossumFilePath.trim()) {
-        throw new Error('No .opossum save location selected');
+        throw new Error(text.backendError.opossumFileNotSelected);
       }
 
       if (!opossumFilePath.endsWith('.opossum')) {
-        throw new Error('Output file name must have .opossum extension');
+        throw new Error(text.backendError.opossumFileWrongExtension);
       }
 
       if (!fs.existsSync(path.dirname(opossumFilePath))) {
-        throw new Error('Output directory does not exist');
+        throw new Error(text.backendError.opossumFileDirectoryDoesNotExist);
       }
 
       try {
         fs.accessSync(path.dirname(opossumFilePath), fs.constants.W_OK);
       } catch (error) {
-        throw new Error('Permission error: cannot write to output directory');
+        throw new Error(text.backendError.opossumFilePermissionError);
       }
 
       logger.info('Converting input file to .opossum format');
@@ -263,19 +264,19 @@ export function getMergeFileAndLoadListener(
       fileType: FileType,
     ) => {
       if (!inputFilePath.trim() || !fs.existsSync(inputFilePath)) {
-        throw new Error('Input file does not exist');
+        throw new Error(text.backendError.inputFileDoesNotExist);
       }
 
       try {
         fs.accessSync(inputFilePath, fs.constants.R_OK);
       } catch (error) {
-        throw new Error('Permission error: cannot read input file');
+        throw new Error(text.backendError.inputFilePermissionError);
       }
 
       const currentOpossumFilePath = getGlobalBackendState().opossumFilePath;
 
       if (!currentOpossumFilePath) {
-        throw new Error('No open file to merge into');
+        throw new Error(text.backendError.noOpenFileToMergeInto);
       }
 
       try {
@@ -284,9 +285,7 @@ export function getMergeFileAndLoadListener(
           `${currentOpossumFilePath}.backup`,
         );
       } catch (error) {
-        throw new Error(
-          'Unable to create backup of currently open Opossum file',
-        );
+        throw new Error(text.backendError.cantCreateBackup);
       }
 
       logger.info('Merging input file into current .opossum file');

src/ElectronBackend/opossum-file/ExternalFileConverter.ts

@@ -2,6 +2,7 @@
 // SPDX-FileCopyrightText: TNG Technology Consulting GmbH <https://www.tngtech.com>
 //
 // SPDX-License-Identifier: Apache-2.0
+import { text } from '../../shared/text';
 import { FileConverter } from './FileConverter';
 
 export abstract class ExternalFileConverter extends FileConverter {
@@ -22,7 +23,7 @@ export abstract class ExternalFileConverter extends FileConverter {
         toBeConvertedFilePath,
       ]);
     } catch (error) {
-      throw new Error(`Input file is not a valid ${this.fileTypeName} file`);
+      throw new Error(text.backendError.inputFileInvalid(this.fileTypeName));
     }
   }
 }

src/ElectronBackend/opossum-file/FileConverter.ts

@@ -8,6 +8,8 @@ import fs from 'fs';
 import { join } from 'path';
 import { promisify } from 'util';
 
+import { text } from '../../shared/text';
+
 export abstract class FileConverter {
   protected abstract readonly fileTypeSwitch: string;
   protected abstract readonly fileTypeName: string;
@@ -48,7 +50,7 @@ export abstract class FileConverter {
         opossumFilePath,
       ]);
     } catch (error) {
-      throw new Error(`Input file is not a valid ${this.fileTypeName} file`);
+      throw new Error(text.backendError.inputFileInvalid(this.fileTypeName));
     }
 
     if (preConvertedFilePath) {

src/ElectronBackend/opossum-file/LegacyFileConverter.ts

@@ -8,6 +8,7 @@ import path from 'path';
 import zlib from 'zlib';
 
 import { legacyOutputFileEnding } from '../../Frontend/shared-constants';
+import { text } from '../../shared/text';
 import { writeOpossumFile } from '../../shared/write-file';
 import { getFilePathWithAppendix } from '../utils/getFilePathWithAppendix';
 import { FileConverter } from './FileConverter';
@@ -82,7 +83,7 @@ export class LegacyFileConverter extends FileConverter {
         output: this.readOutputJson(pathToInputJson),
       });
     } catch (error) {
-      throw new Error('Input file is not a valid Legacy Opossum file');
+      throw new Error(text.backendError.inputFileInvalid(this.fileTypeName));
     }
   }
 

src/shared/text.ts

@@ -336,4 +336,17 @@ export const text = {
           : `Select file to merge (${fileFormat.extensions.map((ext) => `.${ext}`).join('/')})`,
     },
   },
+  backendError: {
+    inputFileDoesNotExist: 'Input file does not exist',
+    inputFilePermissionError: 'Permission error: cannot read input file',
+    inputFileInvalid: (fileTypeName: string) =>
+      `Input file is not a valid ${fileTypeName} file`,
+    opossumFileNotSelected: 'No .opossum save location selected',
+    opossumFileWrongExtension: 'Output file name must have .opossum extension',
+    opossumFileDirectoryDoesNotExist: 'Output directory does not exist',
+    opossumFilePermissionError:
+      'Permission error: cannot write to output directory',
+    noOpenFileToMergeInto: 'No open file to merge into',
+    cantCreateBackup: 'Unable to create backup of currently open Opossum file',
+  },
 } as const;