[CP-2079] Merge enums used in invoking methods between main and renderer

packages/app/src/__deprecated__/main/main.ts

@@ -24,11 +24,7 @@ import registerCopyFileListener from "App/__deprecated__/main/functions/register
 import registerWriteGzipListener from "App/__deprecated__/main/functions/register-write-gzip-listener"
 import registerRmdirListener from "App/__deprecated__/main/functions/register-rmdir-listener"
 import registerArchiveFilesListener from "App/__deprecated__/main/functions/register-archive-files-listener"
-import registerReadFileListener from "App/file-system/listeners/read-file.listener"
 import createDownloadListenerRegistrar from "App/__deprecated__/main/functions/create-download-listener-registrar"
-import registerEncryptFileListener from "App/file-system/listeners/encrypt-file.listener"
-import registerDecryptFileListener from "App/file-system/listeners/decrypt-file.listener"
-import registerUnlinkFileListener from "App/file-system/listeners/unlink-file.listener"
 import {
   registerDownloadHelpHandler,
   removeDownloadHelpHandler,
@@ -196,10 +192,6 @@ const createWindow = async () => {
   registerRmdirListener()
   registerWriteGzipListener()
   registerArchiveFilesListener()
-  registerEncryptFileListener()
-  registerReadFileListener()
-  registerUnlinkFileListener()
-  registerDecryptFileListener()
   registerMetadataAllGetValueListener()
   registerMetadataGetValueListener()
   registerMetadataSetValueListener()

packages/app/src/analytic-data-tracker/constants/controller.constant.ts

@@ -3,24 +3,12 @@
  * For licensing, see https://github.com/mudita/mudita-center/blob/master/LICENSE.md
  */
 
-export const ControllerPrefix = "analytic-data-tracker"
-
 export enum IpcAnalyticDataTrackerEvent {
-  Track = "track",
-  TrackUnique = "track-unique",
-  TrackWithoutDeviceCheck = "track-without-device-check",
-  TrackUniqueWithoutDeviceCheck = "track-unique-without-device-check",
-  ToggleTracking = "toggle-tracking",
-  SetExternalUsageDevice = "set-external-usage-device",
-  SetVisitorMetadata = "set-visitor-metadata",
-}
-
-export enum IpcAnalyticDataTrackerRequest {
-  Track = "analytic-data-tracker-track",
-  TrackUnique = "analytic-data-tracker-track-unique",
-  TrackWithoutDeviceCheck = "analytic-data-tracker-track-without-device-check",
-  TrackUniqueWithoutDeviceCheck = "analytic-data-tracker-track-unique-without-device-check",
-  ToggleTracking = "analytic-data-tracker-toggle-tracking",
-  SetExternalUsageDevice = "analytic-data-tracker-set-external-usage-device",
-  SetVisitorMetadata = "analytic-data-tracker-set-visitor-metadata",
+  Track = "analytic_track",
+  TrackUnique = "analytic_track-unique",
+  TrackWithoutDeviceCheck = "analytic_track-without-device-check",
+  TrackUniqueWithoutDeviceCheck = "analytic_track-unique-without-device-check",
+  ToggleTracking = "analytic_toggle-tracking",
+  SetExternalUsageDevice = "analytic_set-external-usage-device",
+  SetVisitorMetadata = "analytic_set-visitor-metadata",
 }

packages/app/src/analytic-data-tracker/controllers/analytic-data-tracker.controller.ts

@@ -3,18 +3,14 @@
  * For licensing, see https://github.com/mudita/mudita-center/blob/master/LICENSE.md
  */
 
-import { Controller, IpcEvent } from "App/core/decorators"
-import {
-  ControllerPrefix,
-  IpcAnalyticDataTrackerEvent,
-} from "App/analytic-data-tracker/constants"
+import { IpcEvent } from "App/core/decorators"
+import { IpcAnalyticDataTrackerEvent } from "App/analytic-data-tracker/constants"
 import {
   AnalyticDataTrackerClass,
   VisitorMetadata,
 } from "App/analytic-data-tracker/services"
 import { TrackEvent } from "App/analytic-data-tracker/types"
 
-@Controller(ControllerPrefix)
 export class AnalyticDataTrackerController {
   constructor(private tracker: AnalyticDataTrackerClass) {}
 

packages/app/src/analytic-data-tracker/requests/set-external-usage-device.request.ts

@@ -4,13 +4,13 @@
  */
 
 import { ipcRenderer } from "electron-better-ipc"
-import { IpcAnalyticDataTrackerRequest } from "App/analytic-data-tracker/constants"
+import { IpcAnalyticDataTrackerEvent } from "App/analytic-data-tracker/constants"
 
 export const setExternalUsageDeviceRequest = async (
   flag: boolean
 ): Promise<void> => {
   return ipcRenderer.callMain(
-    IpcAnalyticDataTrackerRequest.SetExternalUsageDevice,
+    IpcAnalyticDataTrackerEvent.SetExternalUsageDevice,
     flag
   )
 }

packages/app/src/analytic-data-tracker/requests/set-visitor-metadata.request.ts

@@ -4,14 +4,14 @@
  */
 
 import { ipcRenderer } from "electron-better-ipc"
-import { IpcAnalyticDataTrackerRequest } from "App/analytic-data-tracker/constants"
+import { IpcAnalyticDataTrackerEvent } from "App/analytic-data-tracker/constants"
 import { VisitorMetadata } from "App/analytic-data-tracker/services"
 
 export const setVisitorMetadataRequest = async (
   visitorMetadata: VisitorMetadata
 ): Promise<void> => {
   return ipcRenderer.callMain(
-    IpcAnalyticDataTrackerRequest.SetVisitorMetadata,
+    IpcAnalyticDataTrackerEvent.SetVisitorMetadata,
     visitorMetadata
   )
 }

packages/app/src/analytic-data-tracker/requests/toggle-tracking.request.ts

@@ -4,8 +4,8 @@
  */
 
 import { ipcRenderer } from "electron-better-ipc"
-import { IpcAnalyticDataTrackerRequest } from "App/analytic-data-tracker/constants"
+import { IpcAnalyticDataTrackerEvent } from "App/analytic-data-tracker/constants"
 
 export const toggleTrackingRequest = async (flag: boolean): Promise<void> => {
-  return ipcRenderer.callMain(IpcAnalyticDataTrackerRequest.ToggleTracking, flag)
+  return ipcRenderer.callMain(IpcAnalyticDataTrackerEvent.ToggleTracking, flag)
 }

packages/app/src/analytic-data-tracker/requests/track-unique-without-device-check.request.ts

@@ -4,14 +4,14 @@
  */
 
 import { ipcRenderer } from "electron-better-ipc"
-import { IpcAnalyticDataTrackerRequest } from "App/analytic-data-tracker/constants"
+import { IpcAnalyticDataTrackerEvent } from "App/analytic-data-tracker/constants"
 import { TrackEvent } from "App/analytic-data-tracker/types"
 
 export const trackUniqueWithoutDeviceCheckRequest = async (
   event: TrackEvent
 ): Promise<void> => {
   return ipcRenderer.callMain(
-    IpcAnalyticDataTrackerRequest.TrackUniqueWithoutDeviceCheck,
+    IpcAnalyticDataTrackerEvent.TrackUniqueWithoutDeviceCheck,
     event
   )
 }

packages/app/src/analytic-data-tracker/requests/track-unique.request.ts

@@ -4,9 +4,9 @@
  */
 
 import { ipcRenderer } from "electron-better-ipc"
-import { IpcAnalyticDataTrackerRequest } from "App/analytic-data-tracker/constants"
+import { IpcAnalyticDataTrackerEvent } from "App/analytic-data-tracker/constants"
 import { TrackEvent } from "App/analytic-data-tracker/types"
 
 export const trackUniqueRequest = async (event: TrackEvent): Promise<void> => {
-  return ipcRenderer.callMain(IpcAnalyticDataTrackerRequest.TrackUnique, event)
+  return ipcRenderer.callMain(IpcAnalyticDataTrackerEvent.TrackUnique, event)
 }

packages/app/src/analytic-data-tracker/requests/track-without-device-check.request.ts

@@ -4,14 +4,14 @@
  */
 
 import { ipcRenderer } from "electron-better-ipc"
-import { IpcAnalyticDataTrackerRequest } from "App/analytic-data-tracker/constants"
+import { IpcAnalyticDataTrackerEvent } from "App/analytic-data-tracker/constants"
 import { TrackEvent } from "App/analytic-data-tracker/types"
 
 export const trackWithoutDeviceCheckRequest = async (
   event: TrackEvent
 ): Promise<void> => {
   return ipcRenderer.callMain(
-    IpcAnalyticDataTrackerRequest.TrackWithoutDeviceCheck,
+    IpcAnalyticDataTrackerEvent.TrackWithoutDeviceCheck,
     event
   )
 }

packages/app/src/analytic-data-tracker/requests/track.request.ts

@@ -4,9 +4,9 @@
  */
 
 import { ipcRenderer } from "electron-better-ipc"
-import { IpcAnalyticDataTrackerRequest } from "App/analytic-data-tracker/constants"
+import { IpcAnalyticDataTrackerEvent } from "App/analytic-data-tracker/constants"
 import { TrackEvent } from "App/analytic-data-tracker/types"
 
 export const trackRequest = async (event: TrackEvent): Promise<void> => {
-  return ipcRenderer.callMain(IpcAnalyticDataTrackerRequest.Track, event)
+  return ipcRenderer.callMain(IpcAnalyticDataTrackerEvent.Track, event)
 }

packages/app/src/backup/constants/controller.constant.ts

@@ -6,13 +6,7 @@
 export const ControllerPrefix = "backup"
 
 export enum IpcBackupEvent {
-  LoadBackups = "load-backups",
-  CreateBackup = "create-backup",
-  RestoreBackup = "restore-backup",
-}
-
-export enum IpcBackupRequest {
-  LoadBackups = "backup-load-backups",
-  CreateBackup = "backup-create-backup",
-  RestoreBackup = "backup-restore-backup",
+  LoadBackups = "backup_load-backups",
+  CreateBackup = "backup_create-backup",
+  RestoreBackup = "backup_restore-backup",
 }

packages/app/src/backup/controllers/backup.controller.ts

@@ -3,22 +3,17 @@
  * For licensing, see https://github.com/mudita/mudita-center/blob/master/LICENSE.md
  */
 
-import { Controller, IpcEvent } from "App/core/decorators"
+import { IpcEvent } from "App/core/decorators"
 import { ResultObject } from "App/core/builder"
 import { Backup } from "App/backup/dto"
-import {
-  BackupError,
-  ControllerPrefix,
-  IpcBackupEvent,
-} from "App/backup/constants"
+import { BackupError, IpcBackupEvent } from "App/backup/constants"
 import {
   BackupCreateService,
   BackupRestoreService,
   LoadBackupService,
 } from "App/backup/services"
 import { CreateDeviceBackup, RestoreDeviceBackup } from "App/backup/types"
 
-@Controller(ControllerPrefix)
 export class BackupController {
   constructor(
     private backupCreateService: BackupCreateService,

packages/app/src/backup/requests/create-backup.request.ts

@@ -5,11 +5,11 @@
 
 import { ipcRenderer } from "electron-better-ipc"
 import { ResultObject } from "App/core/builder"
-import { IpcBackupRequest } from "App/backup/constants"
+import { IpcBackupEvent } from "App/backup/constants"
 import { CreateDeviceBackup } from "App/backup/types"
 
 export const createBackupRequest = async (
   options: CreateDeviceBackup
 ): Promise<ResultObject<string[]>> => {
-  return ipcRenderer.callMain(IpcBackupRequest.CreateBackup, options)
+  return ipcRenderer.callMain(IpcBackupEvent.CreateBackup, options)
 }

packages/app/src/backup/requests/load-backups.request.ts

@@ -5,11 +5,11 @@
 
 import { ipcRenderer } from "electron-better-ipc"
 import { ResultObject } from "App/core/builder"
-import { IpcBackupRequest } from "App/backup/constants"
+import { IpcBackupEvent } from "App/backup/constants"
 import { Backup } from "App/backup/dto"
 
 export const loadBackupsRequest = async (
   options: string
 ): Promise<ResultObject<Backup[]>> => {
-  return ipcRenderer.callMain(IpcBackupRequest.LoadBackups, options)
+  return ipcRenderer.callMain(IpcBackupEvent.LoadBackups, options)
 }

packages/app/src/backup/requests/restore-backup.request.ts

@@ -5,11 +5,11 @@
 
 import { ipcRenderer } from "electron-better-ipc"
 import { ResultObject } from "App/core/builder"
-import { BackupError, IpcBackupRequest } from "App/backup/constants"
+import { BackupError, IpcBackupEvent } from "App/backup/constants"
 import { RestoreDeviceBackup } from "App/backup/types"
 
 export const restoreBackupRequest = async (
   options: RestoreDeviceBackup
 ): Promise<ResultObject<boolean, BackupError>> => {
-  return ipcRenderer.callMain(IpcBackupRequest.RestoreBackup, options)
+  return ipcRenderer.callMain(IpcBackupEvent.RestoreBackup, options)
 }

packages/app/src/contacts/constants/controller.constant.ts

@@ -3,16 +3,8 @@
  * For licensing, see https://github.com/mudita/mudita-center/blob/master/LICENSE.md
  */
 
-export const ControllerPrefix = "contact"
-
 export enum IpcContactEvent {
-  CreateContact = "create-contact",
-  EditContact = "edit-contact",
-  DeleteContacts = "delete-contacts",
-}
-
-export enum IpcContactRequest {
-  CreateContact = "contact-create-contact",
-  EditContact = "contact-edit-contact",
-  DeleteContacts = "contact-delete-contacts",
+  CreateContact = "contact_create-contact",
+  EditContact = "contact_edit-contact",
+  DeleteContacts = "contact_delete-contacts",
 }

packages/app/src/contacts/controllers/contact.controller.ts

@@ -3,13 +3,12 @@
  * For licensing, see https://github.com/mudita/mudita-center/blob/master/LICENSE.md
  */
 
-import { Controller, IpcEvent } from "App/core/decorators"
+import { IpcEvent } from "App/core/decorators"
 import { ContactService } from "App/contacts/services"
 import { RequestResponse } from "App/core/types/request-response.interface"
-import { ControllerPrefix, IpcContactEvent } from "App/contacts/constants"
+import { IpcContactEvent } from "App/contacts/constants"
 import { Contact, ContactID } from "App/contacts/reducers"
 
-@Controller(ControllerPrefix)
 export class ContactController {
   constructor(private contactService: ContactService) {}
 

packages/app/src/contacts/requests/create-contact.request.ts

@@ -4,12 +4,12 @@
  */
 
 import { ipcRenderer } from "electron-better-ipc"
-import { IpcContactRequest } from "App/contacts/constants"
+import { IpcContactEvent } from "App/contacts/constants"
 import { Contact, NewContact } from "App/contacts/reducers/contacts.interface"
 import { RequestResponse } from "App/core/types/request-response.interface"
 
 export const createContactRequest = async (
   newContact: NewContact
 ): Promise<RequestResponse<Contact>> => {
-  return ipcRenderer.callMain(IpcContactRequest.CreateContact, newContact)
+  return ipcRenderer.callMain(IpcContactEvent.CreateContact, newContact)
 }

packages/app/src/contacts/requests/delete-contacts.request.ts

@@ -4,15 +4,12 @@
  */
 
 import { ipcRenderer } from "electron-better-ipc"
-import { IpcContactRequest } from "App/contacts/constants"
+import { IpcContactEvent } from "App/contacts/constants"
 import { ContactID } from "App/contacts/reducers/contacts.interface"
 import { RequestResponse } from "App/core/types/request-response.interface"
 
 export const deleteContactsRequest = async (
   contactIds: ContactID[]
 ): Promise<RequestResponse<ContactID[]>> => {
-  return await ipcRenderer.callMain(
-    IpcContactRequest.DeleteContacts,
-    contactIds
-  )
+  return await ipcRenderer.callMain(IpcContactEvent.DeleteContacts, contactIds)
 }

packages/app/src/contacts/requests/edit-contact.request.ts

@@ -4,10 +4,12 @@
  */
 
 import { ipcRenderer } from "electron-better-ipc"
-import { IpcContactRequest } from "App/contacts/constants"
+import { IpcContactEvent } from "App/contacts/constants"
 import { Contact } from "App/contacts/reducers/contacts.interface"
 import { RequestResponse } from "App/core/types/request-response.interface"
 
-export const editContactRequest = (contact: Contact): Promise<RequestResponse<Contact>> => {
-  return ipcRenderer.callMain(IpcContactRequest.EditContact, contact)
+export const editContactRequest = (
+  contact: Contact
+): Promise<RequestResponse<Contact>> => {
+  return ipcRenderer.callMain(IpcContactEvent.EditContact, contact)
 }

packages/app/src/core/application.module.ts

@@ -21,7 +21,6 @@ import {
 } from "App/core/initializers"
 import { Module } from "App/core/types"
 import { FileSystemService } from "App/file-system/services/file-system.service.refactored"
-import { FileSystemModule } from "App/file-system/file-system.module"
 import { IndexStorageModule } from "App/index-storage/index-storage.module"
 import { DataSyncModule } from "App/data-sync/data-sync.module"
 import { ContactModule } from "App/contacts/contact.module"
@@ -48,7 +47,6 @@ import {
 export class ApplicationModule {
   public modules: Module[] = [
     DeviceInfoModule,
-    FileSystemModule,
     IndexStorageModule,
     OutboxModule,
     AnalyticDataTrackerModule,

packages/app/src/core/initializers/controller.initializer.ts

@@ -10,12 +10,6 @@ import { EventDefinition, Controller } from "App/core/types"
 export class ControllerInitializer {
   public initialize(controllers: Controller[]): void {
     controllers.forEach((controller) => {
-      // AUTO DISABLED - fix me if you like :)
-      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-      const prefix = Reflect.getMetadata(
-        ReflectKey.Prefix,
-        controller.constructor
-      )
       // AUTO DISABLED - fix me if you like :)
       // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
       const events: EventDefinition[] = Reflect.getMetadata(
@@ -26,7 +20,7 @@ export class ControllerInitializer {
       events.forEach((event) => {
         // AUTO DISABLED - fix me if you like :)
         // eslint-disable-next-line @typescript-eslint/restrict-template-expressions, @typescript-eslint/require-await
-        ipcMain.answerRenderer(`${prefix}-${event.name}`, async (data) => {
+        ipcMain.answerRenderer(event.name, (data) => {
           // AUTO DISABLED - fix me if you like :)
           // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-explicit-any
           return (controller as Record<string, any>)[event.methodName](data)