2022-04-15 14:56:13 +02:00
|
|
|
import * as antares from 'common/interfaces/antares';
|
|
|
|
import * as workers from 'common/interfaces/workers';
|
2023-08-18 15:57:31 +02:00
|
|
|
import { dialog, ipcMain } from 'electron';
|
2022-04-15 23:13:23 +02:00
|
|
|
import * as fs from 'fs';
|
2023-12-02 09:31:54 +01:00
|
|
|
import { Worker } from 'worker_threads';
|
2020-09-25 12:39:58 +02:00
|
|
|
|
2023-09-13 19:21:08 +02:00
|
|
|
import { validateSender } from '../libs/misc/validateSender';
|
|
|
|
|
2022-04-15 14:56:13 +02:00
|
|
|
export default (connections: {[key: string]: antares.Client}) => {
|
2023-12-02 09:31:54 +01:00
|
|
|
let exporter: Worker = null;
|
2023-12-02 11:35:20 +01:00
|
|
|
let importer: Worker = null;
|
2021-10-29 12:58:37 +02:00
|
|
|
|
2021-03-17 11:15:14 +01:00
|
|
|
ipcMain.handle('create-schema', async (event, params) => {
|
2023-09-13 19:21:08 +02:00
|
|
|
if (!validateSender(event.senderFrame)) return { status: 'error', response: 'Unauthorized process' };
|
|
|
|
|
2020-09-25 12:39:58 +02:00
|
|
|
try {
|
2021-03-17 11:15:14 +01:00
|
|
|
await connections[params.uid].createSchema(params);
|
2020-09-25 12:39:58 +02:00
|
|
|
|
2020-09-29 16:43:20 +02:00
|
|
|
return { status: 'success' };
|
2020-09-25 12:39:58 +02:00
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2021-03-17 11:15:14 +01:00
|
|
|
ipcMain.handle('update-schema', async (event, params) => {
|
2023-09-13 19:21:08 +02:00
|
|
|
if (!validateSender(event.senderFrame)) return { status: 'error', response: 'Unauthorized process' };
|
|
|
|
|
2020-10-03 12:11:42 +02:00
|
|
|
try {
|
2021-03-17 11:15:14 +01:00
|
|
|
await connections[params.uid].alterSchema(params);
|
2020-10-03 12:11:42 +02:00
|
|
|
|
|
|
|
return { status: 'success' };
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2021-03-17 11:15:14 +01:00
|
|
|
ipcMain.handle('delete-schema', async (event, params) => {
|
2023-09-13 19:21:08 +02:00
|
|
|
if (!validateSender(event.senderFrame)) return { status: 'error', response: 'Unauthorized process' };
|
|
|
|
|
2020-10-01 15:08:35 +02:00
|
|
|
try {
|
2021-03-17 11:15:14 +01:00
|
|
|
await connections[params.uid].dropSchema(params);
|
2020-10-01 15:08:35 +02:00
|
|
|
|
|
|
|
return { status: 'success' };
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2021-03-17 11:15:14 +01:00
|
|
|
ipcMain.handle('get-schema-collation', async (event, params) => {
|
2023-09-13 19:21:08 +02:00
|
|
|
if (!validateSender(event.senderFrame)) return { status: 'error', response: 'Unauthorized process' };
|
|
|
|
|
2020-10-03 12:11:42 +02:00
|
|
|
try {
|
2021-10-29 12:58:37 +02:00
|
|
|
const collation = await connections[params.uid].getDatabaseCollation(
|
|
|
|
params
|
|
|
|
);
|
2020-10-03 12:11:42 +02:00
|
|
|
|
2021-10-29 12:58:37 +02:00
|
|
|
return {
|
|
|
|
status: 'success',
|
2022-04-15 14:56:13 +02:00
|
|
|
response: collation
|
2021-10-29 12:58:37 +02:00
|
|
|
};
|
2020-10-03 12:11:42 +02:00
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2021-01-23 15:50:21 +01:00
|
|
|
ipcMain.handle('get-structure', async (event, params) => {
|
2023-09-13 19:21:08 +02:00
|
|
|
if (!validateSender(event.senderFrame)) return { status: 'error', response: 'Unauthorized process' };
|
|
|
|
|
2020-09-25 12:39:58 +02:00
|
|
|
try {
|
2023-01-19 14:32:37 +01:00
|
|
|
const structure: unknown = await connections[params.uid].getStructure(
|
2021-10-29 12:58:37 +02:00
|
|
|
params.schemas
|
|
|
|
);
|
2020-09-25 12:39:58 +02:00
|
|
|
|
|
|
|
return { status: 'success', response: structure };
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
ipcMain.handle('get-collations', async (event, uid) => {
|
2023-09-13 19:21:08 +02:00
|
|
|
if (!validateSender(event.senderFrame)) return { status: 'error', response: 'Unauthorized process' };
|
|
|
|
|
2020-09-25 12:39:58 +02:00
|
|
|
try {
|
|
|
|
const result = await connections[uid].getCollations();
|
|
|
|
|
|
|
|
return { status: 'success', response: result };
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
ipcMain.handle('get-variables', async (event, uid) => {
|
2023-09-13 19:21:08 +02:00
|
|
|
if (!validateSender(event.senderFrame)) return { status: 'error', response: 'Unauthorized process' };
|
|
|
|
|
2020-09-25 12:39:58 +02:00
|
|
|
try {
|
|
|
|
const result = await connections[uid].getVariables();
|
|
|
|
|
|
|
|
return { status: 'success', response: result };
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2020-11-16 17:16:39 +01:00
|
|
|
ipcMain.handle('get-engines', async (event, uid) => {
|
2023-09-13 19:21:08 +02:00
|
|
|
if (!validateSender(event.senderFrame)) return { status: 'error', response: 'Unauthorized process' };
|
|
|
|
|
2020-11-16 17:16:39 +01:00
|
|
|
try {
|
2022-11-16 10:12:44 +01:00
|
|
|
const result: unknown = await connections[uid].getEngines();
|
2020-11-16 17:16:39 +01:00
|
|
|
|
|
|
|
return { status: 'success', response: result };
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2021-02-01 16:31:48 +01:00
|
|
|
ipcMain.handle('get-version', async (event, uid) => {
|
2023-09-13 19:21:08 +02:00
|
|
|
if (!validateSender(event.senderFrame)) return { status: 'error', response: 'Unauthorized process' };
|
|
|
|
|
2021-02-01 16:31:48 +01:00
|
|
|
try {
|
|
|
|
const result = await connections[uid].getVersion();
|
|
|
|
|
|
|
|
return { status: 'success', response: result };
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2021-03-03 19:31:05 +01:00
|
|
|
ipcMain.handle('get-processes', async (event, uid) => {
|
2023-09-13 19:21:08 +02:00
|
|
|
if (!validateSender(event.senderFrame)) return { status: 'error', response: 'Unauthorized process' };
|
|
|
|
|
2021-03-03 19:31:05 +01:00
|
|
|
try {
|
|
|
|
const result = await connections[uid].getProcesses();
|
|
|
|
|
|
|
|
return { status: 'success', response: result };
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2021-09-26 11:19:48 +02:00
|
|
|
ipcMain.handle('kill-process', async (event, { uid, pid }) => {
|
2023-09-13 19:21:08 +02:00
|
|
|
if (!validateSender(event.senderFrame)) return { status: 'error', response: 'Unauthorized process' };
|
|
|
|
|
2021-09-26 11:19:48 +02:00
|
|
|
try {
|
|
|
|
const result = await connections[uid].killProcess(pid);
|
|
|
|
|
|
|
|
return { status: 'success', response: result };
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2020-09-29 16:43:20 +02:00
|
|
|
ipcMain.handle('use-schema', async (event, { uid, schema }) => {
|
2023-09-13 19:21:08 +02:00
|
|
|
if (!validateSender(event.senderFrame)) return { status: 'error', response: 'Unauthorized process' };
|
|
|
|
|
2020-09-29 16:43:20 +02:00
|
|
|
if (!schema) return;
|
|
|
|
|
|
|
|
try {
|
|
|
|
await connections[uid].use(schema);
|
|
|
|
return { status: 'success' };
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2022-02-16 09:14:46 +01:00
|
|
|
ipcMain.handle('raw-query', async (event, { uid, query, schema, tabUid, autocommit }) => {
|
2023-09-13 19:21:08 +02:00
|
|
|
if (!validateSender(event.senderFrame)) return { status: 'error', response: 'Unauthorized process' };
|
|
|
|
|
2020-09-25 12:39:58 +02:00
|
|
|
if (!query) return;
|
|
|
|
|
|
|
|
try {
|
2021-07-21 14:40:29 +02:00
|
|
|
const result = await connections[uid].raw(query, {
|
|
|
|
nest: true,
|
|
|
|
details: true,
|
|
|
|
schema,
|
2022-02-16 09:14:46 +01:00
|
|
|
tabUid,
|
2023-01-19 14:32:37 +01:00
|
|
|
autocommit
|
2021-07-21 14:40:29 +02:00
|
|
|
});
|
2020-09-25 12:39:58 +02:00
|
|
|
|
|
|
|
return { status: 'success', response: result };
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
|
|
|
});
|
2021-10-29 12:58:37 +02:00
|
|
|
|
2022-02-18 18:16:13 +01:00
|
|
|
ipcMain.handle('export', (event, { uid, type, tables, ...rest }) => {
|
2023-09-13 19:21:08 +02:00
|
|
|
if (!validateSender(event.senderFrame)) return { status: 'error', response: 'Unauthorized process' };
|
|
|
|
|
2022-05-17 19:11:31 +02:00
|
|
|
if (exporter !== null) {
|
2023-12-02 09:31:54 +01:00
|
|
|
exporter.terminate();
|
2022-05-17 19:11:31 +02:00
|
|
|
return;
|
|
|
|
}
|
2021-10-29 12:58:37 +02:00
|
|
|
|
2022-04-15 14:56:13 +02:00
|
|
|
return new Promise((resolve/*, reject */) => {
|
2022-02-18 18:16:13 +01:00
|
|
|
(async () => {
|
|
|
|
if (fs.existsSync(rest.outputFile)) { // If file exists ask for replace
|
|
|
|
const result = await dialog.showMessageBox({
|
|
|
|
type: 'warning',
|
|
|
|
message: `File ${rest.outputFile} already exists. Do you want to replace it?`,
|
|
|
|
detail: 'A file with the same name already exists in the target folder. Replacing it will overwrite its current contents.',
|
|
|
|
buttons: ['Cancel', 'Replace'],
|
|
|
|
defaultId: 0,
|
|
|
|
cancelId: 0
|
|
|
|
});
|
|
|
|
|
|
|
|
if (result.response !== 1) {
|
|
|
|
resolve({
|
|
|
|
type: 'error',
|
|
|
|
response: 'Operation aborted'
|
|
|
|
});
|
|
|
|
return;
|
|
|
|
}
|
2021-10-29 12:58:37 +02:00
|
|
|
}
|
2022-02-18 18:16:13 +01:00
|
|
|
|
2023-12-02 09:31:54 +01:00
|
|
|
// Init exporter thread
|
2023-12-02 11:21:48 +01:00
|
|
|
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
|
|
|
|
// @ts-ignore
|
|
|
|
exporter = new Worker(new URL('../workers/exporter', import.meta.url));
|
2023-11-26 16:42:30 +01:00
|
|
|
|
2023-12-02 09:31:54 +01:00
|
|
|
exporter.postMessage({
|
2022-02-18 18:16:13 +01:00
|
|
|
type: 'init',
|
|
|
|
client: {
|
|
|
|
name: type,
|
|
|
|
config: await connections[uid].getDbConfig()
|
|
|
|
},
|
|
|
|
tables,
|
|
|
|
options: rest
|
2023-12-02 14:21:34 +01:00
|
|
|
});
|
2022-02-18 18:16:13 +01:00
|
|
|
|
|
|
|
// Exporter message listener
|
2023-12-01 14:18:40 +01:00
|
|
|
exporter.stdout.on('data', (buff: Buffer) => {
|
|
|
|
let message;
|
|
|
|
try { // Ignore non-JSON data (console.log output)
|
|
|
|
message = JSON.parse(buff.toString());
|
|
|
|
}
|
|
|
|
catch (_) {
|
|
|
|
if (process.env.NODE_ENV === 'development') console.log('EXPORTER:', buff.toString());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
const { type, payload } = message as workers.WorkerIpcMessage;
|
|
|
|
|
2022-02-18 18:16:13 +01:00
|
|
|
switch (type) {
|
|
|
|
case 'export-progress':
|
|
|
|
event.sender.send('export-progress', payload);
|
|
|
|
break;
|
|
|
|
case 'end':
|
2023-12-02 09:31:54 +01:00
|
|
|
setTimeout(() => { // Ensures that writing thread has finished
|
2023-12-02 11:21:48 +01:00
|
|
|
exporter?.terminate();
|
2022-03-05 17:00:05 +01:00
|
|
|
exporter = null;
|
|
|
|
}, 2000);
|
2022-02-18 18:16:13 +01:00
|
|
|
resolve({ status: 'success', response: payload });
|
|
|
|
break;
|
|
|
|
case 'cancel':
|
2023-12-02 11:21:48 +01:00
|
|
|
exporter?.terminate();
|
2022-02-18 18:16:13 +01:00
|
|
|
exporter = null;
|
|
|
|
resolve({ status: 'error', response: 'Operation cancelled' });
|
|
|
|
break;
|
|
|
|
case 'error':
|
2023-12-02 11:21:48 +01:00
|
|
|
exporter?.terminate();
|
2022-02-18 18:16:13 +01:00
|
|
|
exporter = null;
|
|
|
|
resolve({ status: 'error', response: payload });
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2023-12-01 14:18:40 +01:00
|
|
|
exporter.on('close', code => {
|
2022-02-18 18:16:13 +01:00
|
|
|
exporter = null;
|
|
|
|
resolve({ status: 'error', response: `Operation ended with code: ${code}` });
|
|
|
|
});
|
|
|
|
})();
|
|
|
|
});
|
2021-10-29 12:58:37 +02:00
|
|
|
});
|
|
|
|
|
2023-09-13 19:21:08 +02:00
|
|
|
ipcMain.handle('abort-export', async (event) => {
|
|
|
|
if (!validateSender(event.senderFrame)) return { status: 'error', response: 'Unauthorized process' };
|
|
|
|
|
2021-10-29 12:58:37 +02:00
|
|
|
let willAbort = false;
|
|
|
|
|
|
|
|
if (exporter) {
|
|
|
|
const result = await dialog.showMessageBox({
|
|
|
|
type: 'warning',
|
|
|
|
message: 'Are you sure you want to abort the export',
|
|
|
|
buttons: ['Cancel', 'Abort'],
|
|
|
|
defaultId: 0,
|
|
|
|
cancelId: 0
|
|
|
|
});
|
|
|
|
|
|
|
|
if (result.response === 1) {
|
|
|
|
willAbort = true;
|
2023-12-02 09:31:54 +01:00
|
|
|
exporter.postMessage({ type: 'cancel' });
|
2021-10-29 12:58:37 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return { status: 'success', response: { willAbort } };
|
|
|
|
});
|
2021-12-28 15:30:07 +01:00
|
|
|
|
|
|
|
ipcMain.handle('import-sql', async (event, options) => {
|
2023-09-13 19:21:08 +02:00
|
|
|
if (!validateSender(event.senderFrame)) return { status: 'error', response: 'Unauthorized process' };
|
|
|
|
|
2022-05-17 19:11:31 +02:00
|
|
|
if (importer !== null) {
|
2023-12-02 11:35:20 +01:00
|
|
|
importer.terminate();
|
2022-05-17 19:11:31 +02:00
|
|
|
return;
|
|
|
|
}
|
2021-12-28 15:30:07 +01:00
|
|
|
|
2022-04-15 14:56:13 +02:00
|
|
|
return new Promise((resolve/*, reject */) => {
|
2022-02-24 13:14:57 +01:00
|
|
|
(async () => {
|
|
|
|
const dbConfig = await connections[options.uid].getDbConfig();
|
2021-12-28 15:30:07 +01:00
|
|
|
|
2023-12-02 11:35:20 +01:00
|
|
|
// Init importer thread
|
|
|
|
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
|
|
|
|
// @ts-ignore
|
|
|
|
importer = new Worker(new URL('../workers/importer', import.meta.url));
|
2023-11-26 16:42:30 +01:00
|
|
|
|
2023-12-02 11:35:20 +01:00
|
|
|
importer.postMessage({
|
2022-02-24 13:14:57 +01:00
|
|
|
type: 'init',
|
|
|
|
dbConfig,
|
|
|
|
options
|
2023-12-02 14:21:34 +01:00
|
|
|
});
|
2021-12-28 15:30:07 +01:00
|
|
|
|
2022-02-24 13:14:57 +01:00
|
|
|
// Importer message listener
|
2023-12-01 14:18:40 +01:00
|
|
|
importer.stdout.on('data', (buff: Buffer) => {
|
|
|
|
let message;
|
|
|
|
try { // Ignore non-JSON data (console.log output)
|
|
|
|
message = JSON.parse(buff.toString());
|
|
|
|
}
|
|
|
|
catch (_) {
|
|
|
|
if (process.env.NODE_ENV === 'development') console.log('IMPORTER:', buff.toString());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
const { type, payload } = message as workers.WorkerIpcMessage;
|
|
|
|
|
2022-02-24 13:14:57 +01:00
|
|
|
switch (type) {
|
|
|
|
case 'import-progress':
|
|
|
|
event.sender.send('import-progress', payload);
|
|
|
|
break;
|
2022-03-05 18:55:11 +01:00
|
|
|
case 'query-error':
|
|
|
|
event.sender.send('query-error', payload);
|
|
|
|
break;
|
2022-02-24 13:14:57 +01:00
|
|
|
case 'end':
|
2022-03-10 10:23:22 +01:00
|
|
|
setTimeout(() => { // Ensures that writing process has finished
|
2023-12-02 11:35:20 +01:00
|
|
|
importer?.terminate();
|
2022-03-10 10:23:22 +01:00
|
|
|
importer = null;
|
|
|
|
}, 2000);
|
2022-02-24 13:14:57 +01:00
|
|
|
resolve({ status: 'success', response: payload });
|
|
|
|
break;
|
|
|
|
case 'cancel':
|
2023-12-02 11:35:20 +01:00
|
|
|
importer.terminate();
|
2022-02-24 13:14:57 +01:00
|
|
|
importer = null;
|
|
|
|
resolve({ status: 'error', response: 'Operation cancelled' });
|
|
|
|
break;
|
|
|
|
case 'error':
|
2023-12-02 11:35:20 +01:00
|
|
|
importer.terminate();
|
2022-02-24 13:14:57 +01:00
|
|
|
importer = null;
|
|
|
|
resolve({ status: 'error', response: payload });
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
});
|
2023-11-26 16:42:30 +01:00
|
|
|
|
2023-12-01 14:18:40 +01:00
|
|
|
importer.on('close', code => {
|
2023-11-26 16:42:30 +01:00
|
|
|
importer = null;
|
|
|
|
resolve({ status: 'error', response: `Operation ended with code: ${code}` });
|
|
|
|
});
|
2022-02-24 13:14:57 +01:00
|
|
|
})();
|
|
|
|
});
|
2021-12-28 15:30:07 +01:00
|
|
|
});
|
|
|
|
|
2023-09-13 19:21:08 +02:00
|
|
|
ipcMain.handle('abort-import-sql', async (event) => {
|
|
|
|
if (!validateSender(event.senderFrame)) return { status: 'error', response: 'Unauthorized process' };
|
|
|
|
|
2021-12-28 15:30:07 +01:00
|
|
|
let willAbort = false;
|
|
|
|
|
|
|
|
if (importer) {
|
|
|
|
const result = await dialog.showMessageBox({
|
|
|
|
type: 'warning',
|
|
|
|
message: 'Are you sure you want to abort the import',
|
|
|
|
buttons: ['Cancel', 'Abort'],
|
|
|
|
defaultId: 0,
|
|
|
|
cancelId: 0
|
|
|
|
});
|
|
|
|
|
|
|
|
if (result.response === 1) {
|
|
|
|
willAbort = true;
|
2023-12-02 11:35:20 +01:00
|
|
|
importer.postMessage({ type: 'cancel' });
|
2021-12-28 15:30:07 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return { status: 'success', response: { willAbort } };
|
|
|
|
});
|
2022-03-01 22:15:33 +01:00
|
|
|
|
2022-02-16 09:14:46 +01:00
|
|
|
ipcMain.handle('kill-tab-query', async (event, { uid, tabUid }) => {
|
2023-09-13 19:21:08 +02:00
|
|
|
if (!validateSender(event.senderFrame)) return { status: 'error', response: 'Unauthorized process' };
|
|
|
|
|
2022-02-16 09:14:46 +01:00
|
|
|
if (!tabUid) return;
|
|
|
|
|
|
|
|
try {
|
|
|
|
await connections[uid].killTabQuery(tabUid);
|
|
|
|
return { status: 'success' };
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
ipcMain.handle('commit-tab', async (event, { uid, tabUid }) => {
|
2023-09-13 19:21:08 +02:00
|
|
|
if (!validateSender(event.senderFrame)) return { status: 'error', response: 'Unauthorized process' };
|
|
|
|
|
2022-02-16 09:14:46 +01:00
|
|
|
if (!tabUid) return;
|
|
|
|
|
|
|
|
try {
|
|
|
|
await connections[uid].commitTab(tabUid);
|
|
|
|
return { status: 'success' };
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
ipcMain.handle('rollback-tab', async (event, { uid, tabUid }) => {
|
2023-09-13 19:21:08 +02:00
|
|
|
if (!validateSender(event.senderFrame)) return { status: 'error', response: 'Unauthorized process' };
|
|
|
|
|
2022-02-16 09:14:46 +01:00
|
|
|
if (!tabUid) return;
|
|
|
|
|
|
|
|
try {
|
|
|
|
await connections[uid].rollbackTab(tabUid);
|
|
|
|
return { status: 'success' };
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
ipcMain.handle('destroy-connection-to-commit', async (event, { uid, tabUid }) => {
|
2023-09-13 19:21:08 +02:00
|
|
|
if (!validateSender(event.senderFrame)) return { status: 'error', response: 'Unauthorized process' };
|
|
|
|
|
2022-02-16 09:14:46 +01:00
|
|
|
if (!tabUid) return;
|
|
|
|
|
|
|
|
try {
|
|
|
|
await connections[uid].destroyConnectionToCommit(tabUid);
|
|
|
|
return { status: 'success' };
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
|
|
|
});
|
2020-09-25 12:39:58 +02:00
|
|
|
};
|