vodorod/parcer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: lint

Browse Source
This commit is contained in:
karishmas6
2024-10-12 15:55:43 +05:30
parent 4981a515a7
commit 41947b8542
1 changed files with 159 additions and 159 deletions
Download Patch File Download Diff File Expand all files Collapse all files

246
server/src/api/record.ts
View File

@@ -173,187 +173,187 @@ router.get("/robots/:id/runs/:runId", requireAPIKey, async (req: Request, res: R
async function readyForRunHandler(browserId: string, id: string) { async function readyForRunHandler(browserId: string, id: string) {
try { try {
const interpretation = await executeRun(id); const interpretation = await executeRun(id);
if (interpretation) { if (interpretation) {
logger.log('info', `Interpretation of ${id} succeeded`); logger.log('info', `Interpretation of ${id} succeeded`);
} else { } else {
logger.log('error', `Interpretation of ${id} failed`); logger.log('error', `Interpretation of ${id} failed`);
await destroyRemoteBrowser(browserId); await destroyRemoteBrowser(browserId);
} }
resetRecordingState(browserId, id); resetRecordingState(browserId, id);
} catch (error: any) { } catch (error: any) {
logger.error(`Error during readyForRunHandler: ${error.message}`); logger.error(`Error during readyForRunHandler: ${error.message}`);
await destroyRemoteBrowser(browserId); await destroyRemoteBrowser(browserId);
} }
} }
function resetRecordingState(browserId: string, id: string) { function resetRecordingState(browserId: string, id: string) {
browserId = ''; browserId = '';
id = ''; id = '';
} }
async function executeRun(id: string) { async function executeRun(id: string) {
try { try {
const run = await Run.findOne({ where: { runId: id } }); const run = await Run.findOne({ where: { runId: id } });
if (!run) { if (!run) {
return { return {
success: false, success: false,
error: 'Run not found' error: 'Run not found'
}
} }
}
const plainRun = run.toJSON(); const plainRun = run.toJSON();
const recording = await Robot.findOne({ where: { 'recording_meta.id': plainRun.robotMetaId }, raw: true }); const recording = await Robot.findOne({ where: { 'recording_meta.id': plainRun.robotMetaId }, raw: true });
if (!recording) { if (!recording) {
return { return {
success: false, success: false,
error: 'Recording not found' error: 'Recording not found'
}
} }
}
plainRun.status = 'running'; plainRun.status = 'running';
const browser = browserPool.getRemoteBrowser(plainRun.browserId); const browser = browserPool.getRemoteBrowser(plainRun.browserId);
if (!browser) { if (!browser) {
throw new Error('Could not access browser'); throw new Error('Could not access browser');
} }
const currentPage = await browser.getCurrentPage(); const currentPage = await browser.getCurrentPage();
if (!currentPage) { if (!currentPage) {
throw new Error('Could not create a new page'); throw new Error('Could not create a new page');
} }
const interpretationInfo = await browser.interpreter.InterpretRecording( const interpretationInfo = await browser.interpreter.InterpretRecording(
recording.recording, currentPage, plainRun.interpreterSettings); recording.recording, currentPage, plainRun.interpreterSettings);
await destroyRemoteBrowser(plainRun.browserId); await destroyRemoteBrowser(plainRun.browserId);
await run.update({ await run.update({
...run, ...run,
status: 'success', status: 'success',
finishedAt: new Date().toLocaleString(), finishedAt: new Date().toLocaleString(),
browserId: plainRun.browserId, browserId: plainRun.browserId,
log: interpretationInfo.log.join('\n'), log: interpretationInfo.log.join('\n'),
serializableOutput: interpretationInfo.serializableOutput, serializableOutput: interpretationInfo.serializableOutput,
binaryOutput: interpretationInfo.binaryOutput, binaryOutput: interpretationInfo.binaryOutput,
}); });
return true; return true;
} catch (error: any) { } catch (error: any) {
logger.log('info', `Error while running a recording with id: ${id} - ${error.message}`); logger.log('info', `Error while running a recording with id: ${id} - ${error.message}`);
console.log(error.message); console.log(error.message);
return false; return false;
} }
} }
async function createWorkflowAndStoreMetadata(id: string, userId: string) { async function createWorkflowAndStoreMetadata(id: string, userId: string) {
if (!id) { if (!id) {
id = uuid(); id = uuid();
} }
const recording = await Robot.findOne({ const recording = await Robot.findOne({
where: { where: {
'recording_meta.id': id 'recording_meta.id': id
}, },
raw: true raw: true
}); });
if (!recording || !recording.recording_meta || !recording.recording_meta.id) { if (!recording || !recording.recording_meta || !recording.recording_meta.id) {
return { return {
success: false, success: false,
error: 'Recording not found' error: 'Recording not found'
}; };
} }
const proxyConfig = await getDecryptedProxyConfig(userId); const proxyConfig = await getDecryptedProxyConfig(userId);
let proxyOptions: any = {}; let proxyOptions: any = {};
if (proxyConfig.proxy_url) { if (proxyConfig.proxy_url) {
proxyOptions = { proxyOptions = {
server: proxyConfig.proxy_url, server: proxyConfig.proxy_url,
...(proxyConfig.proxy_username && proxyConfig.proxy_password && { ...(proxyConfig.proxy_username && proxyConfig.proxy_password && {
username: proxyConfig.proxy_username, username: proxyConfig.proxy_username,
password: proxyConfig.proxy_password, password: proxyConfig.proxy_password,
}), }),
}; };
} }
try { try {
const browserId = createRemoteBrowserForRun({ const browserId = createRemoteBrowserForRun({
browser: chromium, browser: chromium,
launchOptions: { launchOptions: {
headless: true, headless: true,
proxy: proxyOptions.server ? proxyOptions : undefined, proxy: proxyOptions.server ? proxyOptions : undefined,
}
});
const run = await Run.create({
status: 'Running',
name: recording.recording_meta.name,
robotId: recording.id,
robotMetaId: recording.recording_meta.id,
startedAt: new Date().toLocaleString(),
finishedAt: '',
browserId: id,
interpreterSettings: { maxConcurrency: 1, maxRepeats: 1, debug: true },
log: '',
runId: id,
serializableOutput: {},
binaryOutput: {},
});
const plainRun = run.toJSON();
return {
browserId,
runId: plainRun.runId,
} }
});
const run = await Run.create({
status: 'Running',
name: recording.recording_meta.name,
robotId: recording.id,
robotMetaId: recording.recording_meta.id,
startedAt: new Date().toLocaleString(),
finishedAt: '',
browserId: id,
interpreterSettings: { maxConcurrency: 1, maxRepeats: 1, debug: true },
log: '',
runId: id,
serializableOutput: {},
binaryOutput: {},
});
const plainRun = run.toJSON();
return {
browserId,
runId: plainRun.runId,
}
} catch (e) { } catch (e) {
const { message } = e as Error; const { message } = e as Error;
logger.log('info', `Error while scheduling a run with id: ${id}`); logger.log('info', `Error while scheduling a run with id: ${id}`);
console.log(message); console.log(message);
return { return {
success: false, success: false,
error: message, error: message,
}; };
} }
} }
export async function handleRunRecording(id: string, userId: string) { export async function handleRunRecording(id: string, userId: string) {
try { try {
const result = await createWorkflowAndStoreMetadata(id, userId); const result = await createWorkflowAndStoreMetadata(id, userId);
const { browserId, runId: newRunId } = result; const { browserId, runId: newRunId } = result;
if (!browserId || !newRunId || !userId) { if (!browserId || !newRunId || !userId) {
throw new Error('browserId or runId or userId is undefined'); throw new Error('browserId or runId or userId is undefined');
} }
const socket = io(`http://localhost:8080/${browserId}`, { const socket = io(`http://localhost:8080/${browserId}`, {
transports: ['websocket'], transports: ['websocket'],
rejectUnauthorized: false rejectUnauthorized: false
}); });
socket.on('ready-for-run', () => readyForRunHandler(browserId, newRunId)); socket.on('ready-for-run', () => readyForRunHandler(browserId, newRunId));
logger.log('info', `Running recording: ${id}`); logger.log('info', `Running recording: ${id}`);
socket.on('disconnect', () => { socket.on('disconnect', () => {
cleanupSocketListeners(socket, browserId, newRunId); cleanupSocketListeners(socket, browserId, newRunId);
}); });
} catch (error: any) { } catch (error: any) {
logger.error('Error running recording:', error); logger.error('Error running recording:', error);
} }
} }
function cleanupSocketListeners(socket: Socket, browserId: string, id: string) { function cleanupSocketListeners(socket: Socket, browserId: string, id: string) {
socket.off('ready-for-run', () => readyForRunHandler(browserId, id)); socket.off('ready-for-run', () => readyForRunHandler(browserId, id));
logger.log('info', `Cleaned up listeners for browserId: ${browserId}, runId: ${id}`); logger.log('info', `Cleaned up listeners for browserId: ${browserId}, runId: ${id}`);
} }
router.post("/robots/:id/runs", requireAPIKey, async (req: Request, res: Response) => { router.post("/robots/:id/runs", requireAPIKey, async (req: Request, res: Response) => {