mirror of
https://github.com/mudabbir-ahmad/Media-Aggregation-and-Sorting-System.git
synced 2026-10-07 19:40:20 +00:00
338 lines
11 KiB
JavaScript
338 lines
11 KiB
JavaScript
const express = require('express');
|
|
const jwt = require('jsonwebtoken');
|
|
const cors = require('cors');
|
|
const path = require('path');
|
|
const os = require('os');
|
|
const fs = require('fs');
|
|
const util = require('util');
|
|
const { execFile } = require('child_process');
|
|
const fileUpload = require('express-fileupload');
|
|
require('dotenv').config({ path: path.join(__dirname, '.env') });
|
|
|
|
const fetch = require('node-fetch');
|
|
const execFileAsync = util.promisify(execFile);
|
|
|
|
const SSH_OPTIONS = ['-o', 'StrictHostKeyChecking=no', '-o', 'UserKnownHostsFile=/dev/null'];
|
|
|
|
const NAS_CONFIG_PATH = path.join(__dirname, 'nas_config.txt');
|
|
let DEFAULT_PHOTO_DIR = '/home/user/photos';
|
|
try {
|
|
const raw = fs.readFileSync(NAS_CONFIG_PATH, 'utf8').trim();
|
|
if (raw) DEFAULT_PHOTO_DIR = raw.split('\n')[0].trim();
|
|
} catch (_) {}
|
|
|
|
function runCommand(cmd, args, options = {}) {
|
|
return execFileAsync(cmd, args, {
|
|
timeout: 30000,
|
|
maxBuffer: 10 * 1024 * 1024,
|
|
...options,
|
|
});
|
|
}
|
|
|
|
function buildScpArgs(conn, source, dest) {
|
|
const args = ['-P', String(conn.port || 22), ...SSH_OPTIONS];
|
|
if (conn.privateKeyPath) args.push('-i', conn.privateKeyPath);
|
|
args.push(source, dest);
|
|
return args;
|
|
}
|
|
|
|
function buildSftpArgs(conn, batchFilePath) {
|
|
const args = ['-P', String(conn.port || 22), ...SSH_OPTIONS, '-b', batchFilePath];
|
|
if (conn.privateKeyPath) args.push('-i', conn.privateKeyPath);
|
|
args.push(`${conn.username}@${conn.host}`);
|
|
return args;
|
|
}
|
|
|
|
async function runSftpBatch(conn, batchCommands) {
|
|
const batchFilePath = path.join(
|
|
os.tmpdir(),
|
|
`sftp_batch_${Date.now()}_${Math.random().toString(36).slice(2)}.txt`
|
|
);
|
|
fs.writeFileSync(batchFilePath, batchCommands.join('\n'), 'utf8');
|
|
try {
|
|
const args = buildSftpArgs(conn, batchFilePath);
|
|
if (conn.password) {
|
|
const sshpass = process.env.SSHPASS_PATH || 'sshpass';
|
|
return await runCommand(sshpass, ['-p', conn.password, 'sftp', ...args]);
|
|
}
|
|
return await runCommand('sftp', args);
|
|
} finally {
|
|
fs.unlinkSync(batchFilePath);
|
|
}
|
|
}
|
|
|
|
const app = express();
|
|
app.use(express.json());
|
|
app.use(express.urlencoded({ extended: true }));
|
|
app.use(fileUpload());
|
|
app.use(cors());
|
|
|
|
const SECRET_KEY = process.env.JWT_SECRET || 'your-secret-key-change-in-production';
|
|
const connections = new Map();
|
|
|
|
app.use((req, res, next) => {
|
|
console.log(`[${new Date().toISOString()}] ${req.method} ${req.path}`);
|
|
next();
|
|
});
|
|
|
|
function verifyToken(req, res, next) {
|
|
const authHeader = req.headers.authorization;
|
|
const token = authHeader?.split(' ')[1];
|
|
if (!token) return res.status(401).json({ error: 'No token provided' });
|
|
|
|
try {
|
|
const decoded = jwt.verify(token, SECRET_KEY);
|
|
req.connectionId = decoded.connectionId;
|
|
req.connection = connections.get(decoded.connectionId);
|
|
if (!req.connection) return res.status(401).json({ error: 'Connection expired or not found' });
|
|
next();
|
|
} catch (err) {
|
|
res.status(401).json({ error: 'Invalid token: ' + err.message });
|
|
}
|
|
}
|
|
|
|
app.get('/api/health', (req, res) => {
|
|
res.json({
|
|
status: 'ok',
|
|
timestamp: new Date().toISOString(),
|
|
activeConnections: connections.size,
|
|
defaultPhotoDir: DEFAULT_PHOTO_DIR,
|
|
});
|
|
});
|
|
|
|
app.get('/api/config/photo-dir', (req, res) => {
|
|
res.json({ photoDir: DEFAULT_PHOTO_DIR });
|
|
});
|
|
|
|
app.post('/api/sftp/connect', (req, res) => {
|
|
const { host, port = 22, username, password } = req.body;
|
|
if (!host || !username || !password) {
|
|
return res.status(400).json({ error: 'Missing required fields: host, username, password' });
|
|
}
|
|
|
|
const connectionId = `conn_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
|
|
connections.set(connectionId, { host, port, username, password, createdAt: new Date() });
|
|
|
|
const token = jwt.sign({ connectionId }, SECRET_KEY, { expiresIn: '24h' });
|
|
console.log(`Connection prepared: ${host}:${port} (${connectionId})`);
|
|
|
|
res.json({
|
|
success: true,
|
|
connectionToken: token,
|
|
message: `Connection prepared for ${host}:${port}`,
|
|
defaultPhotoDir: DEFAULT_PHOTO_DIR,
|
|
});
|
|
});
|
|
|
|
app.post('/api/sftp/list', verifyToken, async (req, res) => {
|
|
const { path: dirPath = DEFAULT_PHOTO_DIR } = req.body;
|
|
const conn = req.connection;
|
|
|
|
try {
|
|
const result = await runSftpBatch(conn, [`ls -l ${dirPath}`]);
|
|
const files = result.stdout
|
|
.split('\n')
|
|
.filter(Boolean)
|
|
.map((line) => {
|
|
const parts = line.split(/\s+/);
|
|
return {
|
|
name: parts.pop(),
|
|
isDirectory: parts[0]?.charAt(0) === 'd',
|
|
size: parseInt(parts[4], 10),
|
|
modifyTime: new Date(`${parts[5]} ${parts[6]} ${parts[7]} ${parts[8]}`),
|
|
permissions: parts[0],
|
|
};
|
|
});
|
|
|
|
res.json({ path: dirPath, files, count: files.length });
|
|
} catch (err) {
|
|
console.error('List directory error:', err.message);
|
|
res.status(500).json({ error: 'Failed to list directory: ' + err.message });
|
|
}
|
|
});
|
|
|
|
app.get('/api/sftp/download', verifyToken, async (req, res) => {
|
|
const { path: filePath } = req.query;
|
|
if (!filePath) return res.status(400).json({ error: 'Missing path parameter' });
|
|
|
|
const conn = req.connection;
|
|
const filename = path.basename(filePath);
|
|
const tempFilePath = path.join(os.tmpdir(), filename);
|
|
|
|
try {
|
|
await runCommand('scp', buildScpArgs(conn, `${conn.username}@${conn.host}:${filePath}`, tempFilePath));
|
|
res.download(tempFilePath, filename, () => {
|
|
try { fs.unlinkSync(tempFilePath); } catch (_) {}
|
|
});
|
|
} catch (err) {
|
|
console.error('Download error:', err.message);
|
|
res.status(500).json({ error: 'Download failed: ' + err.message });
|
|
}
|
|
});
|
|
|
|
app.post('/api/sftp/upload', verifyToken, async (req, res) => {
|
|
const { remotePath } = req.body;
|
|
if (!remotePath || !req.files?.file) {
|
|
return res.status(400).json({ error: 'Missing remotePath or file' });
|
|
}
|
|
|
|
const file = req.files.file;
|
|
const conn = req.connection;
|
|
const tempFilePath = path.join(os.tmpdir(), file.name);
|
|
|
|
try {
|
|
await file.mv(tempFilePath);
|
|
await runCommand(
|
|
'scp',
|
|
buildScpArgs(conn, tempFilePath, `${conn.username}@${conn.host}:${remotePath}`)
|
|
);
|
|
fs.unlinkSync(tempFilePath);
|
|
console.log(`Uploaded: ${remotePath}`);
|
|
res.json({ success: true, remotePath, message: 'File uploaded' });
|
|
} catch (err) {
|
|
console.error('Upload error:', err.message);
|
|
res.status(500).json({ error: 'Upload failed: ' + err.message });
|
|
}
|
|
});
|
|
|
|
app.post('/api/sftp/mkdir', verifyToken, async (req, res) => {
|
|
const { path: dirPath } = req.body;
|
|
if (!dirPath) return res.status(400).json({ error: 'Missing path parameter' });
|
|
|
|
try {
|
|
await runSftpBatch(req.connection, [`mkdir ${dirPath}`]);
|
|
console.log(`Created directory: ${dirPath}`);
|
|
res.json({ success: true, path: dirPath, message: 'Directory created' });
|
|
} catch (err) {
|
|
console.error('Mkdir error:', err.message);
|
|
res.status(500).json({ error: 'Failed to create directory: ' + err.message });
|
|
}
|
|
});
|
|
|
|
app.post('/api/sftp/delete', verifyToken, async (req, res) => {
|
|
const { path: filePath } = req.body;
|
|
if (!filePath) return res.status(400).json({ error: 'Missing path parameter' });
|
|
|
|
try {
|
|
await runSftpBatch(req.connection, [`rm ${filePath}`]);
|
|
console.log(`Deleted: ${filePath}`);
|
|
res.json({ success: true, path: filePath, message: 'File deleted' });
|
|
} catch (err) {
|
|
console.error('Delete error:', err.message);
|
|
res.status(500).json({ error: 'Failed to delete file: ' + err.message });
|
|
}
|
|
});
|
|
|
|
app.post('/api/sftp/disconnect', verifyToken, (req, res) => {
|
|
connections.delete(req.connectionId);
|
|
console.log(`Disconnected: ${req.connectionId}`);
|
|
res.json({ success: true, message: 'Disconnected from SFTP server' });
|
|
});
|
|
|
|
app.post('/api/google-photos/fetch', verifyToken, async (req, res) => {
|
|
const { googleAccessToken, pageSize = 50, pageToken } = req.body;
|
|
if (!googleAccessToken) {
|
|
return res.status(400).json({ error: 'Google access token is required' });
|
|
}
|
|
|
|
try {
|
|
const params = new URLSearchParams({ pageSize: String(pageSize) });
|
|
if (pageToken) params.append('pageToken', pageToken);
|
|
|
|
const response = await fetch(
|
|
`https://photoslibrary.googleapis.com/v1/mediaItems?${params.toString()}`,
|
|
{ headers: { Authorization: `Bearer ${googleAccessToken}` } }
|
|
);
|
|
|
|
if (!response.ok) {
|
|
const errText = await response.text();
|
|
return res.status(response.status).json({ error: 'Google API error', details: errText });
|
|
}
|
|
|
|
const data = await response.json();
|
|
const mediaItems = (data.mediaItems || []).map((item) => ({
|
|
id: item.id,
|
|
filename: item.filename,
|
|
mimeType: item.mimeType,
|
|
baseUrl: item.baseUrl,
|
|
productUrl: item.productUrl,
|
|
creationTime: item.mediaMetadata?.creationTime,
|
|
width: item.mediaMetadata?.width,
|
|
height: item.mediaMetadata?.height,
|
|
}));
|
|
|
|
console.log(`Fetched ${mediaItems.length} Google Photos items via NAS proxy`);
|
|
res.json({ success: true, mediaItems, nextPageToken: data.nextPageToken || null, count: mediaItems.length });
|
|
} catch (err) {
|
|
console.error('Google Photos fetch error:', err.message);
|
|
res.status(500).json({ error: 'Failed to fetch Google Photos: ' + err.message });
|
|
}
|
|
});
|
|
|
|
app.post('/api/google-photos/download-to-nas', verifyToken, async (req, res) => {
|
|
const { googleAccessToken, baseUrl, filename, remotePath } = req.body;
|
|
const conn = req.connection;
|
|
|
|
if (!googleAccessToken || !baseUrl || !remotePath) {
|
|
return res.status(400).json({ error: 'googleAccessToken, baseUrl, and remotePath are required' });
|
|
}
|
|
|
|
try {
|
|
const imageResponse = await fetch(`${baseUrl}=d`, {
|
|
headers: { Authorization: `Bearer ${googleAccessToken}` },
|
|
});
|
|
if (!imageResponse.ok) {
|
|
return res.status(imageResponse.status).json({ error: 'Failed to download from Google Photos' });
|
|
}
|
|
|
|
const buffer = await imageResponse.buffer();
|
|
const safeName = filename || `gphoto_${Date.now()}.jpg`;
|
|
const tempFilePath = path.join(os.tmpdir(), safeName);
|
|
fs.writeFileSync(tempFilePath, buffer);
|
|
|
|
const fullRemotePath = `${conn.username}@${conn.host}:${remotePath}/${safeName}`;
|
|
await runCommand('scp', buildScpArgs(conn, tempFilePath, fullRemotePath));
|
|
fs.unlinkSync(tempFilePath);
|
|
|
|
console.log(`Saved Google Photo to NAS: ${remotePath}/${safeName}`);
|
|
res.json({ success: true, message: `Photo saved to NAS at ${remotePath}/${safeName}` });
|
|
} catch (err) {
|
|
console.error('Download-to-NAS error:', err.message);
|
|
res.status(500).json({ error: 'Failed to save photo to NAS: ' + err.message });
|
|
}
|
|
});
|
|
|
|
app.post('/api/google-photos/sync-status', verifyToken, (req, res) => {
|
|
res.json({ success: true, status: 'idle', message: 'No active sync in progress', lastSync: null });
|
|
});
|
|
|
|
process.on('SIGINT', () => {
|
|
console.log('\nShutting down...');
|
|
connections.forEach((_, id) => connections.delete(id));
|
|
process.exit(0);
|
|
});
|
|
|
|
app.use((err, req, res, _next) => {
|
|
console.error('Server error:', err.message);
|
|
res.status(500).json({
|
|
error: 'Internal server error',
|
|
message: process.env.NODE_ENV === 'development' ? err.message : 'Unknown error',
|
|
});
|
|
});
|
|
|
|
app.use((req, res) => {
|
|
res.status(404).json({ error: 'Not found', path: req.path });
|
|
});
|
|
|
|
const PORT = process.env.PORT || 3001;
|
|
app.listen(PORT, () => {
|
|
console.log(`\n SFTP Backend Server`);
|
|
console.log(` Port: ${PORT}`);
|
|
console.log(` URL: http://localhost:${PORT}`);
|
|
console.log(` Photo Dir: ${DEFAULT_PHOTO_DIR}`);
|
|
console.log(` Status: Ready\n`);
|
|
});
|
|
|
|
module.exports = app;
|
|
|