2020-06-15 18:23:51 +02:00
|
|
|
import { ipcMain } from 'electron';
|
2021-02-13 18:45:16 +01:00
|
|
|
import faker from 'faker';
|
|
|
|
import moment from 'moment';
|
2020-09-24 13:09:01 +02:00
|
|
|
import { sqlEscaper } from 'common/libs/sqlEscaper';
|
2021-02-13 18:45:16 +01:00
|
|
|
import { TEXT, LONG_TEXT, NUMBER, FLOAT, BLOB, BIT, DATE, DATETIME } from 'common/fieldTypes';
|
2020-09-24 13:09:01 +02:00
|
|
|
import fs from 'fs';
|
2020-06-15 18:23:51 +02:00
|
|
|
|
|
|
|
export default (connections) => {
|
2020-10-16 17:26:47 +02:00
|
|
|
ipcMain.handle('get-table-columns', async (event, params) => {
|
2020-06-15 18:23:51 +02:00
|
|
|
try {
|
2020-10-16 17:26:47 +02:00
|
|
|
const result = await connections[params.uid].getTableColumns(params);
|
2020-06-15 18:23:51 +02:00
|
|
|
return { status: 'success', response: result };
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2020-12-07 17:51:48 +01:00
|
|
|
ipcMain.handle('get-table-data', async (event, { uid, schema, table, sortParams }) => {
|
2020-06-15 18:23:51 +02:00
|
|
|
try {
|
2020-12-07 17:51:48 +01:00
|
|
|
const query = connections[uid]
|
2020-09-24 13:09:01 +02:00
|
|
|
.select('*')
|
|
|
|
.schema(schema)
|
|
|
|
.from(table)
|
2020-12-07 17:51:48 +01:00
|
|
|
.limit(1000);
|
|
|
|
|
|
|
|
if (sortParams && sortParams.field && sortParams.dir)
|
|
|
|
query.orderBy({ [sortParams.field]: sortParams.dir.toUpperCase() });
|
|
|
|
|
|
|
|
const result = await query.run({ details: true });
|
2020-09-24 13:09:01 +02:00
|
|
|
|
2020-06-15 18:23:51 +02:00
|
|
|
return { status: 'success', response: result };
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
2020-08-14 18:07:29 +02:00
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2020-11-20 17:24:02 +01:00
|
|
|
ipcMain.handle('get-table-indexes', async (event, params) => {
|
|
|
|
try {
|
|
|
|
const result = await connections[params.uid].getTableIndexes(params);
|
|
|
|
|
|
|
|
return { status: 'success', response: result };
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2020-10-16 17:26:47 +02:00
|
|
|
ipcMain.handle('get-key-usage', async (event, params) => {
|
2020-08-14 18:07:29 +02:00
|
|
|
try {
|
2020-10-16 17:26:47 +02:00
|
|
|
const result = await connections[params.uid].getKeyUsage(params);
|
2020-09-24 13:09:01 +02:00
|
|
|
|
2020-08-14 18:07:29 +02:00
|
|
|
return { status: 'success', response: result };
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
2020-06-15 18:23:51 +02:00
|
|
|
}
|
|
|
|
});
|
2020-06-27 15:14:08 +02:00
|
|
|
|
2020-08-18 18:03:59 +02:00
|
|
|
ipcMain.handle('update-table-cell', async (event, params) => {
|
2020-06-27 15:14:08 +02:00
|
|
|
try {
|
2020-09-24 13:09:01 +02:00
|
|
|
let escapedParam;
|
|
|
|
let reload = false;
|
|
|
|
const id = typeof params.id === 'number' ? params.id : `"${params.id}"`;
|
|
|
|
|
2021-02-10 18:24:28 +01:00
|
|
|
if ([...NUMBER, ...FLOAT].includes(params.type))
|
2020-09-24 13:09:01 +02:00
|
|
|
escapedParam = params.content;
|
|
|
|
else if ([...TEXT, ...LONG_TEXT].includes(params.type))
|
|
|
|
escapedParam = `"${sqlEscaper(params.content)}"`;
|
|
|
|
else if (BLOB.includes(params.type)) {
|
|
|
|
if (params.content) {
|
|
|
|
const fileBlob = fs.readFileSync(params.content);
|
|
|
|
escapedParam = `0x${fileBlob.toString('hex')}`;
|
|
|
|
reload = true;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
escapedParam = '""';
|
|
|
|
}
|
2021-02-04 09:20:52 +01:00
|
|
|
else if ([...BIT].includes(params.type)) {
|
|
|
|
escapedParam = `b'${sqlEscaper(params.content)}'`;
|
|
|
|
reload = true;
|
|
|
|
}
|
2020-09-24 13:09:01 +02:00
|
|
|
else
|
|
|
|
escapedParam = `"${sqlEscaper(params.content)}"`;
|
|
|
|
|
2021-01-30 14:58:12 +01:00
|
|
|
if (params.primary) {
|
|
|
|
await connections[params.uid]
|
|
|
|
.update({ [params.field]: `= ${escapedParam}` })
|
|
|
|
.schema(params.schema)
|
|
|
|
.from(params.table)
|
|
|
|
.where({ [params.primary]: `= ${id}` })
|
|
|
|
.run();
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
const { row } = params;
|
|
|
|
reload = true;
|
|
|
|
|
|
|
|
for (const key in row) {
|
|
|
|
if (typeof row[key] === 'string')
|
|
|
|
row[key] = `'${row[key]}'`;
|
|
|
|
|
|
|
|
row[key] = `= ${row[key]}`;
|
|
|
|
}
|
|
|
|
|
|
|
|
await connections[params.uid]
|
|
|
|
.schema(params.schema)
|
|
|
|
.update({ [params.field]: `= ${escapedParam}` })
|
|
|
|
.from(params.table)
|
|
|
|
.where(row)
|
|
|
|
.limit(1)
|
|
|
|
.run();
|
|
|
|
}
|
2020-09-24 13:09:01 +02:00
|
|
|
|
|
|
|
return { status: 'success', response: { reload } };
|
2020-06-27 15:14:08 +02:00
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
|
|
|
});
|
2020-07-23 19:10:14 +02:00
|
|
|
|
2021-01-30 14:58:12 +01:00
|
|
|
ipcMain.handle('delete-table-rows', async (event, params) => {
|
2021-01-28 18:33:29 +01:00
|
|
|
if (params.primary) {
|
|
|
|
const idString = params.rows.map(row => typeof row[params.primary] === 'string'
|
|
|
|
? `"${row[params.primary]}"`
|
|
|
|
: row[params.primary]).join(',');
|
|
|
|
|
|
|
|
try {
|
|
|
|
const result = await connections[params.uid]
|
|
|
|
.schema(params.schema)
|
|
|
|
.delete(params.table)
|
|
|
|
.where({ [params.primary]: `IN (${idString})` })
|
|
|
|
.run();
|
|
|
|
|
|
|
|
return { status: 'success', response: result };
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
2020-07-23 19:10:14 +02:00
|
|
|
}
|
2021-01-28 18:33:29 +01:00
|
|
|
else {
|
|
|
|
try {
|
|
|
|
for (const row of params.rows) {
|
|
|
|
for (const key in row) {
|
|
|
|
if (typeof row[key] === 'string')
|
|
|
|
row[key] = `'${row[key]}'`;
|
|
|
|
|
|
|
|
row[key] = `= ${row[key]}`;
|
|
|
|
}
|
|
|
|
|
|
|
|
await connections[params.uid]
|
|
|
|
.schema(params.schema)
|
|
|
|
.delete(params.table)
|
|
|
|
.where(row)
|
|
|
|
.limit(1)
|
|
|
|
.run();
|
|
|
|
}
|
|
|
|
|
|
|
|
return { status: 'success', response: [] };
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
2020-07-23 19:10:14 +02:00
|
|
|
}
|
|
|
|
});
|
2020-08-12 18:12:30 +02:00
|
|
|
|
2020-08-18 18:03:59 +02:00
|
|
|
ipcMain.handle('insert-table-rows', async (event, params) => {
|
2020-08-12 18:12:30 +02:00
|
|
|
try {
|
2020-09-24 13:09:01 +02:00
|
|
|
const insertObj = {};
|
|
|
|
for (const key in params.row) {
|
|
|
|
const type = params.fields[key];
|
|
|
|
let escapedParam;
|
|
|
|
|
|
|
|
if (params.row[key] === null)
|
|
|
|
escapedParam = 'NULL';
|
2021-02-10 18:24:28 +01:00
|
|
|
else if ([...NUMBER, ...FLOAT].includes(type))
|
2020-09-24 13:09:01 +02:00
|
|
|
escapedParam = params.row[key];
|
|
|
|
else if ([...TEXT, ...LONG_TEXT].includes(type))
|
|
|
|
escapedParam = `"${sqlEscaper(params.row[key])}"`;
|
|
|
|
else if (BLOB.includes(type)) {
|
|
|
|
if (params.row[key]) {
|
|
|
|
const fileBlob = fs.readFileSync(params.row[key]);
|
|
|
|
escapedParam = `0x${fileBlob.toString('hex')}`;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
escapedParam = '""';
|
|
|
|
}
|
|
|
|
else
|
|
|
|
escapedParam = `"${sqlEscaper(params.row[key])}"`;
|
|
|
|
|
|
|
|
insertObj[key] = escapedParam;
|
|
|
|
}
|
|
|
|
|
2021-02-08 11:46:57 +01:00
|
|
|
const rows = new Array(+params.repeat).fill(insertObj);
|
|
|
|
|
|
|
|
await connections[params.uid]
|
|
|
|
.schema(params.schema)
|
|
|
|
.into(params.table)
|
|
|
|
.insert(rows)
|
|
|
|
.run();
|
2020-09-24 13:09:01 +02:00
|
|
|
|
2020-08-12 18:12:30 +02:00
|
|
|
return { status: 'success' };
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
|
|
|
});
|
2020-08-17 15:10:19 +02:00
|
|
|
|
2021-02-13 18:45:16 +01:00
|
|
|
ipcMain.handle('insert-table-fake-rows', async (event, params) => {
|
|
|
|
try {
|
|
|
|
const rows = [];
|
|
|
|
|
|
|
|
for (let i = 0; i < +params.repeat; i++) {
|
|
|
|
const insertObj = {};
|
|
|
|
|
|
|
|
for (const key in params.row) {
|
|
|
|
const type = params.fields[key];
|
|
|
|
let escapedParam;
|
|
|
|
|
|
|
|
if (!('group' in params.row[key]) || params.row[key].group === 'manual') { // Manual value
|
|
|
|
if (params.row[key].value === null)
|
|
|
|
escapedParam = 'NULL';
|
|
|
|
else if ([...NUMBER, ...FLOAT].includes(type))
|
|
|
|
escapedParam = params.row[key].value;
|
|
|
|
else if ([...TEXT, ...LONG_TEXT].includes(type))
|
|
|
|
escapedParam = `"${sqlEscaper(params.row[key].value)}"`;
|
|
|
|
else if (BLOB.includes(type)) {
|
|
|
|
if (params.row[key].value) {
|
|
|
|
const fileBlob = fs.readFileSync(params.row[key].value);
|
|
|
|
escapedParam = `0x${fileBlob.toString('hex')}`;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
escapedParam = '""';
|
|
|
|
}
|
|
|
|
else
|
|
|
|
escapedParam = `"${sqlEscaper(params.row[key].value)}"`;
|
|
|
|
|
|
|
|
insertObj[key] = escapedParam;
|
|
|
|
}
|
|
|
|
else { // Faker value
|
|
|
|
let fakeValue = faker[params.row[key].group][params.row[key].method]();
|
|
|
|
|
|
|
|
if ([...TEXT, ...LONG_TEXT].includes(type))
|
|
|
|
fakeValue = `"${sqlEscaper(fakeValue)}"`;
|
|
|
|
else if ([...DATE, ...DATETIME].includes(type))
|
|
|
|
fakeValue = `"${moment(fakeValue).format('YYYY-MM-DD HH:mm:ss.SSSSSS')}"`;
|
|
|
|
|
|
|
|
insertObj[key] = fakeValue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
rows.push(insertObj);
|
|
|
|
}
|
|
|
|
|
|
|
|
await connections[params.uid]
|
|
|
|
.schema(params.schema)
|
|
|
|
.into(params.table)
|
|
|
|
.insert(rows)
|
|
|
|
.run();
|
|
|
|
|
|
|
|
return { status: 'success' };
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2020-10-23 16:21:36 +02:00
|
|
|
ipcMain.handle('get-foreign-list', async (event, { uid, schema, table, column, description }) => {
|
2020-08-17 15:10:19 +02:00
|
|
|
try {
|
2020-10-16 17:26:47 +02:00
|
|
|
const query = connections[uid]
|
|
|
|
.select(`${column} AS foreignColumn`)
|
|
|
|
.schema(schema)
|
|
|
|
.from(table)
|
2020-09-24 13:09:01 +02:00
|
|
|
.orderBy('foreignColumn ASC');
|
|
|
|
|
2020-10-16 17:26:47 +02:00
|
|
|
if (description)
|
|
|
|
query.select(`LEFT(${description}, 20) AS foreignDescription`);
|
2020-09-24 13:09:01 +02:00
|
|
|
|
|
|
|
const results = await query.run();
|
|
|
|
|
2020-08-17 15:10:19 +02:00
|
|
|
return { status: 'success', response: results };
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
|
|
|
});
|
2020-11-13 12:39:40 +01:00
|
|
|
|
2020-12-03 13:00:54 +01:00
|
|
|
ipcMain.handle('create-table', async (event, params) => {
|
|
|
|
try {
|
|
|
|
await connections[params.uid].createTable(params);
|
|
|
|
return { status: 'success' };
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2020-11-13 12:39:40 +01:00
|
|
|
ipcMain.handle('alter-table', async (event, params) => {
|
|
|
|
try {
|
|
|
|
await connections[params.uid].alterTable(params);
|
|
|
|
return { status: 'success' };
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
|
|
|
});
|
2020-12-03 16:15:10 +01:00
|
|
|
|
|
|
|
ipcMain.handle('truncate-table', async (event, params) => {
|
|
|
|
try {
|
|
|
|
await connections[params.uid].truncateTable(params);
|
|
|
|
return { status: 'success' };
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
ipcMain.handle('drop-table', async (event, params) => {
|
|
|
|
try {
|
|
|
|
await connections[params.uid].dropTable(params);
|
|
|
|
return { status: 'success' };
|
|
|
|
}
|
|
|
|
catch (err) {
|
|
|
|
return { status: 'error', response: err.toString() };
|
|
|
|
}
|
|
|
|
});
|
2020-06-15 18:23:51 +02:00
|
|
|
};
|