833 lines
28 KiB
JavaScript
833 lines
28 KiB
JavaScript
const express = require('express');
|
|
const router = express.Router();
|
|
const { spawn } = require('child_process');
|
|
const path = require('path');
|
|
const db = require('../utils/db');
|
|
|
|
// Debug middleware MUST be first
|
|
router.use((req, res, next) => {
|
|
console.log(`[CSV Route Debug] ${req.method} ${req.path}`);
|
|
next();
|
|
});
|
|
|
|
// Store active processes and their progress
|
|
let activeImport = null;
|
|
let importProgress = null;
|
|
let activeFullUpdate = null;
|
|
let activeFullReset = null;
|
|
|
|
// SSE clients for progress updates
|
|
const updateClients = new Set();
|
|
const importClients = new Set();
|
|
const resetClients = new Set();
|
|
const resetMetricsClients = new Set();
|
|
const calculateMetricsClients = new Set();
|
|
const fullUpdateClients = new Set();
|
|
const fullResetClients = new Set();
|
|
|
|
// Helper to send progress to specific clients
|
|
function sendProgressToClients(clients, data) {
|
|
// If data is a string, send it directly
|
|
// If it's an object, convert it to JSON
|
|
const message = typeof data === 'string'
|
|
? `data: ${data}\n\n`
|
|
: `data: ${JSON.stringify(data)}\n\n`;
|
|
|
|
clients.forEach(client => {
|
|
try {
|
|
client.write(message);
|
|
// Immediately flush the response
|
|
if (typeof client.flush === 'function') {
|
|
client.flush();
|
|
}
|
|
} catch (error) {
|
|
// Silently remove failed client
|
|
clients.delete(client);
|
|
}
|
|
});
|
|
}
|
|
|
|
// Helper to run a script and stream progress
|
|
function runScript(scriptPath, type, clients) {
|
|
return new Promise((resolve, reject) => {
|
|
// Kill any existing process of this type
|
|
let activeProcess;
|
|
switch (type) {
|
|
case 'update':
|
|
if (activeFullUpdate) {
|
|
try { activeFullUpdate.kill(); } catch (e) { }
|
|
}
|
|
activeProcess = activeFullUpdate;
|
|
break;
|
|
case 'reset':
|
|
if (activeFullReset) {
|
|
try { activeFullReset.kill(); } catch (e) { }
|
|
}
|
|
activeProcess = activeFullReset;
|
|
break;
|
|
}
|
|
|
|
const child = spawn('node', [scriptPath], {
|
|
stdio: ['inherit', 'pipe', 'pipe']
|
|
});
|
|
|
|
switch (type) {
|
|
case 'update':
|
|
activeFullUpdate = child;
|
|
break;
|
|
case 'reset':
|
|
activeFullReset = child;
|
|
break;
|
|
}
|
|
|
|
let output = '';
|
|
|
|
child.stdout.on('data', (data) => {
|
|
const text = data.toString();
|
|
output += text;
|
|
|
|
// Split by lines to handle multiple JSON outputs
|
|
const lines = text.split('\n');
|
|
lines.filter(line => line.trim()).forEach(line => {
|
|
try {
|
|
// Try to parse as JSON but don't let it affect the display
|
|
const jsonData = JSON.parse(line);
|
|
// Only end the process if we get a final status
|
|
if (jsonData.status === 'complete' || jsonData.status === 'error' || jsonData.status === 'cancelled') {
|
|
if (jsonData.status === 'complete' && !jsonData.operation?.includes('complete')) {
|
|
// Don't close for intermediate completion messages
|
|
sendProgressToClients(clients, line);
|
|
return;
|
|
}
|
|
// Close only on final completion/error/cancellation
|
|
switch (type) {
|
|
case 'update':
|
|
activeFullUpdate = null;
|
|
break;
|
|
case 'reset':
|
|
activeFullReset = null;
|
|
break;
|
|
}
|
|
if (jsonData.status === 'error') {
|
|
reject(new Error(jsonData.error || 'Unknown error'));
|
|
} else {
|
|
resolve({ output });
|
|
}
|
|
}
|
|
} catch (e) {
|
|
// Not JSON, just display as is
|
|
}
|
|
// Always send the raw line
|
|
sendProgressToClients(clients, line);
|
|
});
|
|
});
|
|
|
|
child.stderr.on('data', (data) => {
|
|
const text = data.toString();
|
|
console.error(text);
|
|
// Send stderr output directly too
|
|
sendProgressToClients(clients, text);
|
|
});
|
|
|
|
child.on('close', (code) => {
|
|
switch (type) {
|
|
case 'update':
|
|
activeFullUpdate = null;
|
|
break;
|
|
case 'reset':
|
|
activeFullReset = null;
|
|
break;
|
|
}
|
|
|
|
if (code !== 0) {
|
|
const error = `Script ${scriptPath} exited with code ${code}`;
|
|
sendProgressToClients(clients, error);
|
|
reject(new Error(error));
|
|
}
|
|
// Don't resolve here - let the completion message from the script trigger the resolve
|
|
});
|
|
|
|
child.on('error', (err) => {
|
|
switch (type) {
|
|
case 'update':
|
|
activeFullUpdate = null;
|
|
break;
|
|
case 'reset':
|
|
activeFullReset = null;
|
|
break;
|
|
}
|
|
sendProgressToClients(clients, err.message);
|
|
reject(err);
|
|
});
|
|
});
|
|
}
|
|
|
|
// Progress endpoints
|
|
router.get('/:type/progress', (req, res) => {
|
|
const { type } = req.params;
|
|
if (!['update', 'reset'].includes(type)) {
|
|
return res.status(400).json({ error: 'Invalid operation type' });
|
|
}
|
|
|
|
res.writeHead(200, {
|
|
'Content-Type': 'text/event-stream',
|
|
'Cache-Control': 'no-cache',
|
|
'Connection': 'keep-alive',
|
|
'Access-Control-Allow-Origin': req.headers.origin || '*',
|
|
'Access-Control-Allow-Credentials': 'true'
|
|
});
|
|
|
|
// Add this client to the correct set
|
|
const clients = type === 'update' ? fullUpdateClients : fullResetClients;
|
|
clients.add(res);
|
|
|
|
// Send initial connection message
|
|
sendProgressToClients(new Set([res]), JSON.stringify({
|
|
status: 'running',
|
|
operation: 'Initializing connection...'
|
|
}));
|
|
|
|
// Handle client disconnect
|
|
req.on('close', () => {
|
|
clients.delete(res);
|
|
});
|
|
});
|
|
|
|
// Debug endpoint to verify route registration
|
|
router.get('/test', (req, res) => {
|
|
console.log('CSV test endpoint hit');
|
|
res.json({ message: 'CSV routes are working' });
|
|
});
|
|
|
|
// Route to check import status
|
|
router.get('/status', (req, res) => {
|
|
console.log('CSV status endpoint hit');
|
|
res.json({
|
|
active: !!activeImport,
|
|
progress: importProgress
|
|
});
|
|
});
|
|
|
|
// Add calculate-metrics status endpoint
|
|
router.get('/calculate-metrics/status', (req, res) => {
|
|
const calculateMetrics = require('../../scripts/calculate-metrics');
|
|
const progress = calculateMetrics.getProgress();
|
|
|
|
// Only consider it active if both the process is running and we have progress
|
|
const isActive = !!activeImport && !!progress;
|
|
|
|
res.json({
|
|
active: isActive,
|
|
progress: isActive ? progress : null
|
|
});
|
|
});
|
|
|
|
// Route to update CSV files
|
|
router.post('/update', async (req, res, next) => {
|
|
if (activeImport) {
|
|
return res.status(409).json({ error: 'Import already in progress' });
|
|
}
|
|
|
|
try {
|
|
const scriptPath = path.join(__dirname, '..', '..', 'scripts', 'update-csv.js');
|
|
|
|
if (!require('fs').existsSync(scriptPath)) {
|
|
return res.status(500).json({ error: 'Update script not found' });
|
|
}
|
|
|
|
activeImport = spawn('node', [scriptPath]);
|
|
|
|
activeImport.stdout.on('data', (data) => {
|
|
const output = data.toString().trim();
|
|
|
|
try {
|
|
// Try to parse as JSON
|
|
const jsonData = JSON.parse(output);
|
|
sendProgressToClients(updateClients, {
|
|
status: 'running',
|
|
...jsonData
|
|
});
|
|
} catch (e) {
|
|
// If not JSON, send as plain progress
|
|
sendProgressToClients(updateClients, {
|
|
status: 'running',
|
|
progress: output
|
|
});
|
|
}
|
|
});
|
|
|
|
activeImport.stderr.on('data', (data) => {
|
|
const error = data.toString().trim();
|
|
try {
|
|
// Try to parse as JSON
|
|
const jsonData = JSON.parse(error);
|
|
sendProgressToClients(updateClients, {
|
|
status: 'error',
|
|
...jsonData
|
|
});
|
|
} catch {
|
|
sendProgressToClients(updateClients, {
|
|
status: 'error',
|
|
error
|
|
});
|
|
}
|
|
});
|
|
|
|
await new Promise((resolve, reject) => {
|
|
activeImport.on('close', (code) => {
|
|
// Don't treat cancellation (code 143/SIGTERM) as an error
|
|
if (code === 0 || code === 143) {
|
|
sendProgressToClients(updateClients, {
|
|
status: 'complete',
|
|
operation: code === 143 ? 'Operation cancelled' : 'Update complete'
|
|
});
|
|
resolve();
|
|
} else {
|
|
const errorMsg = `Update process exited with code ${code}`;
|
|
sendProgressToClients(updateClients, {
|
|
status: 'error',
|
|
error: errorMsg
|
|
});
|
|
reject(new Error(errorMsg));
|
|
}
|
|
activeImport = null;
|
|
importProgress = null;
|
|
});
|
|
});
|
|
|
|
res.json({ success: true });
|
|
} catch (error) {
|
|
console.error('Error updating CSV files:', error);
|
|
activeImport = null;
|
|
importProgress = null;
|
|
sendProgressToClients(updateClients, {
|
|
status: 'error',
|
|
error: error.message
|
|
});
|
|
next(error);
|
|
}
|
|
});
|
|
|
|
// Route to import CSV files
|
|
router.post('/import', async (req, res) => {
|
|
if (activeImport) {
|
|
return res.status(409).json({ error: 'Import already in progress' });
|
|
}
|
|
|
|
try {
|
|
const scriptPath = path.join(__dirname, '..', '..', 'scripts', 'import-csv.js');
|
|
|
|
if (!require('fs').existsSync(scriptPath)) {
|
|
return res.status(500).json({ error: 'Import script not found' });
|
|
}
|
|
|
|
// Get test limits from request body
|
|
const { products = 0, orders = 10000, purchaseOrders = 10000 } = req.body;
|
|
|
|
// Create environment variables for the script
|
|
const env = {
|
|
...process.env,
|
|
PRODUCTS_TEST_LIMIT: products.toString(),
|
|
ORDERS_TEST_LIMIT: orders.toString(),
|
|
PURCHASE_ORDERS_TEST_LIMIT: purchaseOrders.toString()
|
|
};
|
|
|
|
activeImport = spawn('node', [scriptPath], { env });
|
|
|
|
activeImport.stdout.on('data', (data) => {
|
|
const output = data.toString().trim();
|
|
|
|
try {
|
|
// Try to parse as JSON
|
|
const jsonData = JSON.parse(output);
|
|
sendProgressToClients(importClients, {
|
|
status: 'running',
|
|
...jsonData
|
|
});
|
|
} catch {
|
|
// If not JSON, send as plain progress
|
|
sendProgressToClients(importClients, {
|
|
status: 'running',
|
|
progress: output
|
|
});
|
|
}
|
|
});
|
|
|
|
activeImport.stderr.on('data', (data) => {
|
|
const error = data.toString().trim();
|
|
try {
|
|
// Try to parse as JSON
|
|
const jsonData = JSON.parse(error);
|
|
sendProgressToClients(importClients, {
|
|
status: 'error',
|
|
...jsonData
|
|
});
|
|
} catch {
|
|
sendProgressToClients(importClients, {
|
|
status: 'error',
|
|
error
|
|
});
|
|
}
|
|
});
|
|
|
|
await new Promise((resolve, reject) => {
|
|
activeImport.on('close', (code) => {
|
|
// Don't treat cancellation (code 143/SIGTERM) as an error
|
|
if (code === 0 || code === 143) {
|
|
sendProgressToClients(importClients, {
|
|
status: 'complete',
|
|
operation: code === 143 ? 'Operation cancelled' : 'Import complete'
|
|
});
|
|
resolve();
|
|
} else {
|
|
sendProgressToClients(importClients, {
|
|
status: 'error',
|
|
error: `Process exited with code ${code}`
|
|
});
|
|
reject(new Error(`Import process exited with code ${code}`));
|
|
}
|
|
activeImport = null;
|
|
importProgress = null;
|
|
});
|
|
});
|
|
|
|
res.json({ success: true });
|
|
} catch (error) {
|
|
console.error('Error importing CSV files:', error);
|
|
activeImport = null;
|
|
importProgress = null;
|
|
sendProgressToClients(importClients, {
|
|
status: 'error',
|
|
error: error.message
|
|
});
|
|
res.status(500).json({ error: 'Failed to import CSV files', details: error.message });
|
|
}
|
|
});
|
|
|
|
// Route to cancel active process
|
|
router.post('/cancel', (req, res) => {
|
|
let killed = false;
|
|
|
|
// Get the operation type from the request
|
|
const { type } = req.query;
|
|
const clients = type === 'update' ? fullUpdateClients : fullResetClients;
|
|
const activeProcess = type === 'update' ? activeFullUpdate : activeFullReset;
|
|
|
|
if (activeProcess) {
|
|
try {
|
|
activeProcess.kill('SIGTERM');
|
|
if (type === 'update') {
|
|
activeFullUpdate = null;
|
|
} else {
|
|
activeFullReset = null;
|
|
}
|
|
killed = true;
|
|
sendProgressToClients(clients, JSON.stringify({
|
|
status: 'cancelled',
|
|
operation: 'Operation cancelled'
|
|
}));
|
|
} catch (err) {
|
|
console.error(`Error killing ${type} process:`, err);
|
|
}
|
|
}
|
|
|
|
if (killed) {
|
|
res.json({ success: true });
|
|
} else {
|
|
res.status(404).json({ error: 'No active process to cancel' });
|
|
}
|
|
});
|
|
|
|
// Route to reset database
|
|
router.post('/reset', async (req, res) => {
|
|
if (activeImport) {
|
|
return res.status(409).json({ error: 'Import already in progress' });
|
|
}
|
|
|
|
try {
|
|
const scriptPath = path.join(__dirname, '..', '..', 'scripts', 'reset-db.js');
|
|
|
|
if (!require('fs').existsSync(scriptPath)) {
|
|
return res.status(500).json({ error: 'Reset script not found' });
|
|
}
|
|
|
|
activeImport = spawn('node', [scriptPath]);
|
|
|
|
activeImport.stdout.on('data', (data) => {
|
|
const output = data.toString().trim();
|
|
|
|
try {
|
|
// Try to parse as JSON
|
|
const jsonData = JSON.parse(output);
|
|
sendProgressToClients(resetClients, {
|
|
status: 'running',
|
|
...jsonData
|
|
});
|
|
} catch (e) {
|
|
// If not JSON, send as plain progress
|
|
sendProgressToClients(resetClients, {
|
|
status: 'running',
|
|
progress: output
|
|
});
|
|
}
|
|
});
|
|
|
|
activeImport.stderr.on('data', (data) => {
|
|
const error = data.toString().trim();
|
|
try {
|
|
// Try to parse as JSON
|
|
const jsonData = JSON.parse(error);
|
|
sendProgressToClients(resetClients, {
|
|
status: 'error',
|
|
...jsonData
|
|
});
|
|
} catch {
|
|
sendProgressToClients(resetClients, {
|
|
status: 'error',
|
|
error
|
|
});
|
|
}
|
|
});
|
|
|
|
await new Promise((resolve, reject) => {
|
|
activeImport.on('close', (code) => {
|
|
// Don't treat cancellation (code 143/SIGTERM) as an error
|
|
if (code === 0 || code === 143) {
|
|
sendProgressToClients(resetClients, {
|
|
status: 'complete',
|
|
operation: code === 143 ? 'Operation cancelled' : 'Reset complete'
|
|
});
|
|
resolve();
|
|
} else {
|
|
const errorMsg = `Reset process exited with code ${code}`;
|
|
sendProgressToClients(resetClients, {
|
|
status: 'error',
|
|
error: errorMsg
|
|
});
|
|
reject(new Error(errorMsg));
|
|
}
|
|
activeImport = null;
|
|
importProgress = null;
|
|
});
|
|
});
|
|
|
|
res.json({ success: true });
|
|
} catch (error) {
|
|
console.error('Error resetting database:', error);
|
|
activeImport = null;
|
|
importProgress = null;
|
|
sendProgressToClients(resetClients, {
|
|
status: 'error',
|
|
error: error.message
|
|
});
|
|
res.status(500).json({ error: 'Failed to reset database', details: error.message });
|
|
}
|
|
});
|
|
|
|
// Add reset-metrics endpoint
|
|
router.post('/reset-metrics', async (req, res) => {
|
|
if (activeImport) {
|
|
res.status(400).json({ error: 'Operation already in progress' });
|
|
return;
|
|
}
|
|
|
|
try {
|
|
// Set active import to prevent concurrent operations
|
|
activeImport = {
|
|
type: 'reset-metrics',
|
|
status: 'running',
|
|
operation: 'Starting metrics reset'
|
|
};
|
|
|
|
// Send initial response
|
|
res.status(200).json({ message: 'Reset metrics started' });
|
|
|
|
// Send initial progress through SSE
|
|
sendProgressToClients(resetMetricsClients, {
|
|
status: 'running',
|
|
operation: 'Starting metrics reset'
|
|
});
|
|
|
|
// Run the reset metrics script
|
|
const resetMetrics = require('../../scripts/reset-metrics');
|
|
await resetMetrics();
|
|
|
|
// Send completion through SSE
|
|
sendProgressToClients(resetMetricsClients, {
|
|
status: 'complete',
|
|
operation: 'Metrics reset completed'
|
|
});
|
|
|
|
activeImport = null;
|
|
} catch (error) {
|
|
console.error('Error during metrics reset:', error);
|
|
|
|
// Send error through SSE
|
|
sendProgressToClients(resetMetricsClients, {
|
|
status: 'error',
|
|
error: error.message || 'Failed to reset metrics'
|
|
});
|
|
|
|
activeImport = null;
|
|
res.status(500).json({ error: error.message || 'Failed to reset metrics' });
|
|
}
|
|
});
|
|
|
|
// Add calculate-metrics endpoint
|
|
router.post('/calculate-metrics', async (req, res) => {
|
|
if (activeImport) {
|
|
return res.status(409).json({ error: 'Import already in progress' });
|
|
}
|
|
|
|
try {
|
|
const scriptPath = path.join(__dirname, '..', '..', 'scripts', 'calculate-metrics.js');
|
|
|
|
if (!require('fs').existsSync(scriptPath)) {
|
|
return res.status(500).json({ error: 'Calculate metrics script not found' });
|
|
}
|
|
|
|
activeImport = spawn('node', [scriptPath]);
|
|
let wasCancelled = false;
|
|
|
|
activeImport.stdout.on('data', (data) => {
|
|
const output = data.toString().trim();
|
|
|
|
try {
|
|
// Try to parse as JSON
|
|
const jsonData = JSON.parse(output);
|
|
importProgress = {
|
|
status: 'running',
|
|
...jsonData.progress
|
|
};
|
|
sendProgressToClients(calculateMetricsClients, importProgress);
|
|
} catch (e) {
|
|
// If not JSON, send as plain progress
|
|
importProgress = {
|
|
status: 'running',
|
|
progress: output
|
|
};
|
|
sendProgressToClients(calculateMetricsClients, importProgress);
|
|
}
|
|
});
|
|
|
|
activeImport.stderr.on('data', (data) => {
|
|
if (wasCancelled) return; // Don't send errors if cancelled
|
|
|
|
const error = data.toString().trim();
|
|
try {
|
|
// Try to parse as JSON
|
|
const jsonData = JSON.parse(error);
|
|
importProgress = {
|
|
status: 'error',
|
|
...jsonData.progress
|
|
};
|
|
sendProgressToClients(calculateMetricsClients, importProgress);
|
|
} catch {
|
|
importProgress = {
|
|
status: 'error',
|
|
error
|
|
};
|
|
sendProgressToClients(calculateMetricsClients, importProgress);
|
|
}
|
|
});
|
|
|
|
await new Promise((resolve, reject) => {
|
|
activeImport.on('close', (code, signal) => {
|
|
wasCancelled = signal === 'SIGTERM' || code === 143;
|
|
activeImport = null;
|
|
|
|
if (code === 0 || wasCancelled) {
|
|
if (wasCancelled) {
|
|
importProgress = {
|
|
status: 'cancelled',
|
|
operation: 'Operation cancelled'
|
|
};
|
|
sendProgressToClients(calculateMetricsClients, importProgress);
|
|
} else {
|
|
importProgress = {
|
|
status: 'complete',
|
|
operation: 'Metrics calculation complete'
|
|
};
|
|
sendProgressToClients(calculateMetricsClients, importProgress);
|
|
}
|
|
resolve();
|
|
} else {
|
|
importProgress = null;
|
|
reject(new Error(`Metrics calculation process exited with code ${code}`));
|
|
}
|
|
});
|
|
});
|
|
|
|
res.json({ success: true });
|
|
} catch (error) {
|
|
console.error('Error calculating metrics:', error);
|
|
activeImport = null;
|
|
importProgress = null;
|
|
|
|
// Only send error if it wasn't a cancellation
|
|
if (!error.message?.includes('code 143') && !error.message?.includes('SIGTERM')) {
|
|
sendProgressToClients(calculateMetricsClients, {
|
|
status: 'error',
|
|
error: error.message
|
|
});
|
|
res.status(500).json({ error: 'Failed to calculate metrics', details: error.message });
|
|
} else {
|
|
res.json({ success: true });
|
|
}
|
|
}
|
|
});
|
|
|
|
// Route to import from production database
|
|
router.post('/import-from-prod', async (req, res) => {
|
|
if (activeImport) {
|
|
return res.status(409).json({ error: 'Import already in progress' });
|
|
}
|
|
|
|
try {
|
|
const importFromProd = require('../../scripts/import-from-prod');
|
|
|
|
// Set up progress handler
|
|
const progressHandler = (data) => {
|
|
importProgress = data;
|
|
sendProgressToClients(importClients, data);
|
|
};
|
|
|
|
// Start the import process
|
|
importFromProd.outputProgress = progressHandler;
|
|
activeImport = importFromProd; // Store the module for cancellation
|
|
|
|
// Run the import in the background
|
|
importFromProd.main().catch(error => {
|
|
console.error('Error in import process:', error);
|
|
activeImport = null;
|
|
importProgress = {
|
|
status: error.message === 'Import cancelled' ? 'cancelled' : 'error',
|
|
operation: 'Import process',
|
|
error: error.message
|
|
};
|
|
sendProgressToClients(importClients, importProgress);
|
|
}).finally(() => {
|
|
activeImport = null;
|
|
});
|
|
|
|
res.json({ message: 'Import from production started' });
|
|
} catch (error) {
|
|
console.error('Error starting production import:', error);
|
|
activeImport = null;
|
|
res.status(500).json({ error: error.message || 'Failed to start production import' });
|
|
}
|
|
});
|
|
|
|
// POST /csv/full-update - Run full update script
|
|
router.post('/full-update', async (req, res) => {
|
|
try {
|
|
const scriptPath = path.join(__dirname, '../../scripts/full-update.js');
|
|
runScript(scriptPath, 'update', fullUpdateClients)
|
|
.catch(error => {
|
|
console.error('Update failed:', error);
|
|
});
|
|
res.status(202).json({ message: 'Update started' });
|
|
} catch (error) {
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
// POST /csv/full-reset - Run full reset script
|
|
router.post('/full-reset', async (req, res) => {
|
|
try {
|
|
const scriptPath = path.join(__dirname, '../../scripts/full-reset.js');
|
|
runScript(scriptPath, 'reset', fullResetClients)
|
|
.catch(error => {
|
|
console.error('Reset failed:', error);
|
|
});
|
|
res.status(202).json({ message: 'Reset started' });
|
|
} catch (error) {
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
// GET /history/import - Get recent import history
|
|
router.get('/history/import', async (req, res) => {
|
|
try {
|
|
const pool = req.app.locals.pool;
|
|
const { rows } = await pool.query(`
|
|
SELECT
|
|
id,
|
|
start_time,
|
|
end_time,
|
|
status,
|
|
error_message,
|
|
rows_processed::integer,
|
|
files_processed::integer
|
|
FROM import_history
|
|
ORDER BY start_time DESC
|
|
LIMIT 20
|
|
`);
|
|
res.json(rows || []);
|
|
} catch (error) {
|
|
console.error('Error fetching import history:', error);
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
// GET /history/calculate - Get recent calculation history
|
|
router.get('/history/calculate', async (req, res) => {
|
|
try {
|
|
const pool = req.app.locals.pool;
|
|
const { rows } = await pool.query(`
|
|
SELECT
|
|
id,
|
|
start_time,
|
|
end_time,
|
|
status,
|
|
error_message,
|
|
modules_processed::integer,
|
|
total_modules::integer
|
|
FROM calculate_history
|
|
ORDER BY start_time DESC
|
|
LIMIT 20
|
|
`);
|
|
res.json(rows || []);
|
|
} catch (error) {
|
|
console.error('Error fetching calculate history:', error);
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
// GET /status/modules - Get module calculation status
|
|
router.get('/status/modules', async (req, res) => {
|
|
try {
|
|
const pool = req.app.locals.pool;
|
|
const { rows } = await pool.query(`
|
|
SELECT
|
|
module_name,
|
|
last_calculation_timestamp::timestamp
|
|
FROM calculate_status
|
|
ORDER BY module_name
|
|
`);
|
|
res.json(rows || []);
|
|
} catch (error) {
|
|
console.error('Error fetching module status:', error);
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
// GET /status/tables - Get table sync status
|
|
router.get('/status/tables', async (req, res) => {
|
|
try {
|
|
const pool = req.app.locals.pool;
|
|
const { rows } = await pool.query(`
|
|
SELECT
|
|
table_name,
|
|
last_sync_timestamp::timestamp
|
|
FROM sync_status
|
|
ORDER BY table_name
|
|
`);
|
|
res.json(rows || []);
|
|
} catch (error) {
|
|
console.error('Error fetching table status:', error);
|
|
res.status(500).json({ error: error.message });
|
|
}
|
|
});
|
|
|
|
module.exports = router;
|