masterdraco/transmission-rss-manager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
masterdraco 2025-02-26 08:48:34 +01:00
commit 756c6fdd6f
5 changed files with 2557 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
README.md Normal file
View File

119
full-server-implementation.txt Normal file
View File

@ -0,0 +1,119 @@
// server.js - Main application server file
const express = require('express');
const bodyParser = require('body-parser');
const path = require('path');
const fs = require('fs').promises;
const cors = require('cors');
const Transmission = require('transmission');
// Import custom modules
const PostProcessor = require('./postProcessor');
const RssFeedManager = require('./rssFeedManager');
// Initialize Express app
const app = express();
const PORT = process.env.PORT || 3000;
// Load configuration
let config = {
transmissionConfig: {
host: 'localhost',
port: 9091,
username: '',
password: '',
path: '/transmission/rpc'
},
remoteConfig: {
isRemote: false,
directoryMapping: {}
},
destinationPaths: {
movies: '/mnt/media/movies',
tvShows: '/mnt/media/tvshows',
music: '/mnt/media/music',
books: '/mnt/media/books',
software: '/mnt/media/software'
},
seedingRequirements: {
minRatio: 1.0,
minTimeMinutes: 60,
checkIntervalSeconds: 300
},
processingOptions: {
extractArchives: true,
deleteArchives: true,
createCategoryFolders: true,
ignoreSample: true,
ignoreExtras: true,
renameFiles: true,
autoReplaceUpgrades: true,
removeDuplicates: true,
keepOnlyBestVersion: true
},
rssFeeds: [],
rssUpdateIntervalMinutes: 60,
autoProcessing: false
};
// Service instances
let transmissionClient = null;
let postProcessor = null;
let rssFeedManager = null;
// Save config function
async function saveConfig() {
try {
await fs.writeFile(
path.join(__dirname, 'config.json'),
JSON.stringify(config, null, 2),
'utf8'
);
console.log('Configuration saved');
return true;
} catch (err) {
console.error('Error saving config:', err.message);
return false;
}
}
// Load config function
async function loadConfig() {
try {
const data = await fs.readFile(path.join(__dirname, 'config.json'), 'utf8');
const loadedConfig = JSON.parse(data);
config = { ...config, ...loadedConfig };
console.log('Configuration loaded');
return true;
} catch (err) {
console.error('Error loading config, using defaults:', err.message);
// Save default config
await saveConfig();
return false;
}
}
// Initialize Transmission client
function initTransmission() {
transmissionClient = new Transmission({
host: config.transmissionConfig.host,
port: config.transmissionConfig.port,
username: config.transmissionConfig.username,
password: config.transmissionConfig.password,
url: config.transmissionConfig.path
});
console.log(`Transmission client initialized for ${config.transmissionConfig.host}:${config.transmissionConfig.port}`);
return transmissionClient;
}
// Initialize post processor
function initPostProcessor() {
if (postProcessor) {
postProcessor.stop();
}
postProcessor = new PostProcessor({
transmissionConfig: config.transmissionConfig,
remoteConfig: config.remoteConfig,
destinationPaths: config.destinationPaths,
see

870
install-script.sh Executable file
View File

@ -0,0 +1,870 @@
#!/bin/bash
# Transmission RSS Manager Installation Script for Ubuntu
# This script installs all necessary dependencies and sets up the program
# Text formatting
BOLD='\033[1m'
GREEN='\033[0;32m'
YELLOW='\033[0;33m'
RED='\033[0;31m'
NC='\033[0m' # No Color
# Print header
echo -e "${BOLD}==================================================${NC}"
echo -e "${BOLD} Transmission RSS Manager Installer ${NC}"
echo -e "${BOLD}==================================================${NC}"
echo
# Check if script is run with sudo
if [ "$EUID" -ne 0 ]; then
echo -e "${RED}Please run as root (use sudo)${NC}"
exit 1
fi
# Get current directory
SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"
# Configuration variables
INSTALL_DIR="/opt/transmission-rss-manager"
SERVICE_NAME="transmission-rss-manager"
USER=$(logname || echo $SUDO_USER)
PORT=3000
# Transmission configuration variables
TRANSMISSION_REMOTE=false
TRANSMISSION_HOST="localhost"
TRANSMISSION_PORT=9091
TRANSMISSION_USER=""
TRANSMISSION_PASS=""
TRANSMISSION_RPC_PATH="/transmission/rpc"
TRANSMISSION_DOWNLOAD_DIR="/var/lib/transmission-daemon/downloads"
TRANSMISSION_DIR_MAPPING="{}"
# Ask user for configuration
echo -e "${BOLD}Installation Configuration:${NC}"
echo -e "Please provide the following configuration parameters:"
echo
read -p "Installation directory [$INSTALL_DIR]: " input_install_dir
INSTALL_DIR=${input_install_dir:-$INSTALL_DIR}
read -p "Web interface port [$PORT]: " input_port
PORT=${input_port:-$PORT}
read -p "Run as user [$USER]: " input_user
USER=${input_user:-$USER}
echo
echo -e "${BOLD}Transmission Configuration:${NC}"
echo -e "Configure connection to your Transmission client:"
echo
read -p "Is Transmission running on a remote server? (y/n) [n]: " input_remote
if [[ $input_remote =~ ^[Yy]$ ]]; then
TRANSMISSION_REMOTE=true
read -p "Remote Transmission host [localhost]: " input_trans_host
TRANSMISSION_HOST=${input_trans_host:-$TRANSMISSION_HOST}
read -p "Remote Transmission port [9091]: " input_trans_port
TRANSMISSION_PORT=${input_trans_port:-$TRANSMISSION_PORT}
read -p "Remote Transmission username []: " input_trans_user
TRANSMISSION_USER=${input_trans_user:-$TRANSMISSION_USER}
read -p "Remote Transmission password []: " input_trans_pass
TRANSMISSION_PASS=${input_trans_pass:-$TRANSMISSION_PASS}
read -p "Remote Transmission RPC path [/transmission/rpc]: " input_trans_path
TRANSMISSION_RPC_PATH=${input_trans_path:-$TRANSMISSION_RPC_PATH}
# Configure directory mapping for remote setup
echo
echo -e "${YELLOW}Directory Mapping Configuration${NC}"
echo -e "When using a remote Transmission server, you need to map paths between servers."
echo -e "For each directory on the remote server, specify the corresponding local directory."
echo
# Get remote download directory
read -p "Remote Transmission download directory: " REMOTE_DOWNLOAD_DIR
REMOTE_DOWNLOAD_DIR=${REMOTE_DOWNLOAD_DIR:-"/var/lib/transmission-daemon/downloads"}
# Get local directory that corresponds to remote download directory
read -p "Local directory that corresponds to the remote download directory: " LOCAL_DOWNLOAD_DIR
LOCAL_DOWNLOAD_DIR=${LOCAL_DOWNLOAD_DIR:-"/mnt/transmission-downloads"}
# Create mapping JSON
TRANSMISSION_DIR_MAPPING=$(cat <<EOF
{
"$REMOTE_DOWNLOAD_DIR": "$LOCAL_DOWNLOAD_DIR"
}
EOF
)
# Create the local directory
mkdir -p "$LOCAL_DOWNLOAD_DIR"
chown -R $USER:$USER "$LOCAL_DOWNLOAD_DIR"
# Ask if want to add more mappings
while true; do
read -p "Add another directory mapping? (y/n) [n]: " add_another
if [[ ! $add_another =~ ^[Yy]$ ]]; then
break
fi
read -p "Remote directory path: " remote_dir
read -p "Corresponding local directory path: " local_dir
if [ -n "$remote_dir" ] && [ -n "$local_dir" ]; then
# Update mapping JSON (remove the last "}" and add the new mapping)
TRANSMISSION_DIR_MAPPING="${TRANSMISSION_DIR_MAPPING%\}}, \"$remote_dir\": \"$local_dir\" }"
# Create the local directory
mkdir -p "$local_dir"
chown -R $USER:$USER "$local_dir"
echo -e "${GREEN}Mapping added: $remote_dir → $local_dir${NC}"
fi
done
# Set Transmission download dir for configuration
TRANSMISSION_DOWNLOAD_DIR=$REMOTE_DOWNLOAD_DIR
else
read -p "Transmission download directory [/var/lib/transmission-daemon/downloads]: " input_trans_dir
TRANSMISSION_DOWNLOAD_DIR=${input_trans_dir:-$TRANSMISSION_DOWNLOAD_DIR}
fi
echo
echo -e "${BOLD}Media Destination Configuration:${NC}"
read -p "Media destination base directory [/mnt/media]: " MEDIA_DIR
MEDIA_DIR=${MEDIA_DIR:-"/mnt/media"}
echo
echo -e "${YELLOW}Installing dependencies...${NC}"
# Update package index
apt-get update
# Install Node.js and npm if not already installed
if ! command -v node &> /dev/null; then
echo "Installing Node.js and npm..."
apt-get install -y ca-certificates curl gnupg
mkdir -p /etc/apt/keyrings
curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg
echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_18.x nodistro main" > /etc/apt/sources.list.d/nodesource.list
apt-get update
apt-get install -y nodejs
fi
# Install additional dependencies
echo "Installing additional dependencies..."
apt-get install -y unrar unzip p7zip-full nginx
# Create installation directory
echo -e "${YELLOW}Creating installation directory...${NC}"
mkdir -p $INSTALL_DIR
mkdir -p $INSTALL_DIR/logs
# Copy application files if they exist
echo -e "${YELLOW}Copying application files...${NC}"
cp $SCRIPT_DIR/*.js $INSTALL_DIR/ 2>/dev/null || :
cp $SCRIPT_DIR/*.css $INSTALL_DIR/ 2>/dev/null || :
cp $SCRIPT_DIR/*.html $INSTALL_DIR/ 2>/dev/null || :
cp $SCRIPT_DIR/*.md $INSTALL_DIR/ 2>/dev/null || :
# Create package.json
echo -e "${YELLOW}Creating package.json...${NC}"
cat > $INSTALL_DIR/package.json << EOF
{
"name": "transmission-rss-manager",
"version": "1.0.0",
"description": "Transmission RSS Manager with post-processing capabilities",
"main": "server.js",
"scripts": {
"start": "node server.js"
},
"dependencies": {
"express": "^4.18.2",
"body-parser": "^1.20.2",
"transmission": "^0.4.10",
"adm-zip": "^0.5.10",
"node-fetch": "^2.6.9",
"xml2js": "^0.5.0",
"cors": "^2.8.5"
}
}
EOF
# Create server.js
echo -e "${YELLOW}Creating server.js...${NC}"
cat > $INSTALL_DIR/server.js << EOF
const express = require("express");
const bodyParser = require("body-parser");
const path = require("path");
const fs = require("fs").promises;
const cors = require("cors");
const Transmission = require("transmission");
// Initialize Express app
const app = express();
const PORT = process.env.PORT || $PORT;
// Load configuration
let config = {
transmissionConfig: {
host: "$TRANSMISSION_HOST",
port: $TRANSMISSION_PORT,
username: "$TRANSMISSION_USER",
password: "$TRANSMISSION_PASS",
path: "$TRANSMISSION_RPC_PATH"
},
remoteConfig: {
isRemote: $TRANSMISSION_REMOTE,
directoryMapping: $TRANSMISSION_DIR_MAPPING
},
destinationPaths: {
movies: "$MEDIA_DIR/movies",
tvShows: "$MEDIA_DIR/tvshows",
music: "$MEDIA_DIR/music",
books: "$MEDIA_DIR/books",
software: "$MEDIA_DIR/software"
},
seedingRequirements: {
minRatio: 1.0,
minTimeMinutes: 60,
checkIntervalSeconds: 300
},
processingOptions: {
extractArchives: true,
deleteArchives: true,
createCategoryFolders: true,
ignoreSample: true,
ignoreExtras: true,
renameFiles: true,
autoReplaceUpgrades: true,
removeDuplicates: true,
keepOnlyBestVersion: true
},
downloadDir: "$TRANSMISSION_DOWNLOAD_DIR"
};
// Save config function
async function saveConfig() {
try {
await fs.writeFile(
path.join(__dirname, 'config.json'),
JSON.stringify(config, null, 2),
'utf8'
);
console.log('Configuration saved');
} catch (err) {
console.error('Error saving config:', err.message);
}
}
// Initialize config on startup
async function loadConfig() {
try {
const data = await fs.readFile(path.join(__dirname, 'config.json'), 'utf8');
const loadedConfig = JSON.parse(data);
config = { ...config, ...loadedConfig };
console.log('Configuration loaded');
} catch (err) {
console.error('Error loading config, using defaults:', err.message);
// Save default config
await saveConfig();
}
}
// Initialize Transmission client
let transmissionClient = null;
function initTransmission() {
transmissionClient = new Transmission({
host: config.transmissionConfig.host,
port: config.transmissionConfig.port,
username: config.transmissionConfig.username,
password: config.transmissionConfig.password,
url: config.transmissionConfig.path
});
}
// Enable CORS
app.use(cors());
// Parse JSON bodies
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
// API routes - defined BEFORE static files
app.get("/api/status", (req, res) => {
res.setHeader("Content-Type", "application/json");
res.send(JSON.stringify({
status: "running",
version: "1.0.0",
transmissionConnected: !!transmissionClient
}));
});
app.post("/api/transmission/test", (req, res) => {
const { host, port, username, password } = req.body;
// Create a test client with provided credentials
const testClient = new Transmission({
host: host || config.transmissionConfig.host,
port: port || config.transmissionConfig.port,
username: username || config.transmissionConfig.username,
password: password || config.transmissionConfig.password,
url: config.transmissionConfig.path
});
// Test connection
testClient.sessionStats((err, result) => {
if (err) {
return res.json({
success: false,
message: \`Connection failed: \${err.message}\`
});
}
// If successful, update config
config.transmissionConfig = {
host: host || config.transmissionConfig.host,
port: port || config.transmissionConfig.port,
username: username || config.transmissionConfig.username,
password: password || config.transmissionConfig.password,
path: config.transmissionConfig.path
};
// Save updated config
saveConfig();
// Reinitialize client
initTransmission();
res.json({
success: true,
message: "Connected to Transmission successfully!",
data: {
version: result.version || "Unknown",
rpcVersion: result.rpcVersion || "Unknown"
}
});
});
});
// Get configuration
app.get("/api/config", (req, res) => {
// Don't send password in response
const safeConfig = { ...config };
if (safeConfig.transmissionConfig) {
safeConfig.transmissionConfig = { ...safeConfig.transmissionConfig, password: '••••••••' };
}
res.json(safeConfig);
});
// Update configuration
app.post("/api/config", async (req, res) => {
try {
// Merge new config with existing config
config = {
...config,
...req.body,
// Preserve password if not provided
transmissionConfig: {
...config.transmissionConfig,
...req.body.transmissionConfig,
password: req.body.transmissionConfig?.password || config.transmissionConfig.password
}
};
await saveConfig();
initTransmission();
res.json({ success: true, message: 'Configuration updated' });
} catch (err) {
res.status(500).json({ success: false, message: err.message });
}
});
// Serve static files
app.use(express.static(path.join(__dirname, "public")));
// Catch-all route AFTER static files
app.get("*", (req, res) => {
res.sendFile(path.join(__dirname, "public", "index.html"));
});
// Initialize the application
async function init() {
await loadConfig();
initTransmission();
// Start the server
app.listen(PORT, () => {
console.log(\`Transmission RSS Manager running on port \${PORT}\`);
});
}
// Start the application
init().catch(err => {
console.error('Failed to initialize application:', err);
});
EOF
# Create public directory and index.html
mkdir -p $INSTALL_DIR/public
echo -e "${YELLOW}Creating index.html...${NC}"
cat > $INSTALL_DIR/public/index.html << EOF
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Transmission RSS Manager</title>
<style>
body {
font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Arial, sans-serif;
line-height: 1.6;
color: #333;
background-color: #f5f5f5;
padding: 20px;
}
.app-container {
max-width: 1000px;
margin: 0 auto;
}
h1, h2 {
color: #2c3e50;
}
.panel {
background: white;
border-radius: 8px;
padding: 20px;
margin-bottom: 20px;
box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
}
.form-group {
margin-bottom: 15px;
}
label {
display: block;
margin-bottom: 5px;
font-weight: 500;
}
input[type="text"],
input[type="number"],
input[type="password"] {
width: 100%;
padding: 8px 12px;
border: 1px solid #ddd;
border-radius: 4px;
font-size: 14px;
}
button {
padding: 8px 16px;
border: none;
border-radius: 4px;
cursor: pointer;
font-weight: 500;
background-color: #3498db;
color: white;
}
button:hover {
background-color: #2980b9;
}
.status-message {
padding: 10px 15px;
border-radius: 4px;
background-color: #f8f9fa;
border-left: 4px solid #3498db;
margin-bottom: 20px;
}
.success {
background-color: #d4edda;
border-left: 4px solid #28a745;
}
.error {
background-color: #f8d7da;
border-left: 4px solid #dc3545;
}
.tabs {
display: flex;
border-bottom: 1px solid #ddd;
margin-bottom: 20px;
}
.tab {
padding: 10px 15px;
cursor: pointer;
border-bottom: 2px solid transparent;
}
.tab.active {
border-bottom: 2px solid #3498db;
font-weight: 500;
}
.tab-content {
display: none;
}
.tab-content.active {
display: block;
}
</style>
</head>
<body>
<div class="app-container">
<h1>Transmission RSS Manager</h1>
<div class="tabs">
<div class="tab active" data-tab="connection">Connection</div>
<div class="tab" data-tab="config">Configuration</div>
<div class="tab" data-tab="status">Status</div>
</div>
<div id="status-bar" class="status-message">
Checking connection...
</div>
<div class="tab-content active" id="connection-tab">
<div class="panel">
<h2>Connection Settings</h2>
<div class="form-group">
<label for="host">Host:</label>
<input type="text" id="host" value="localhost">
</div>
<div class="form-group">
<label for="port">Port:</label>
<input type="number" id="port" value="9091">
</div>
<div class="form-group">
<label for="username">Username:</label>
<input type="text" id="username">
</div>
<div class="form-group">
<label for="password">Password:</label>
<input type="password" id="password">
</div>
<button type="button" id="connect-btn">Connect to Transmission</button>
</div>
</div>
<div class="tab-content" id="config-tab">
<div class="panel">
<h2>System Configuration</h2>
<p>Configuration options will be available after connecting to Transmission.</p>
</div>
</div>
<div class="tab-content" id="status-tab">
<div class="panel">
<h2>System Status</h2>
<div id="system-info">
<p>Loading system information...</p>
</div>
</div>
</div>
</div>
<script>
document.addEventListener("DOMContentLoaded", function() {
const statusBar = document.getElementById("status-bar");
const tabs = document.querySelectorAll(".tab");
const tabContents = document.querySelectorAll(".tab-content");
// Tab switching
tabs.forEach(tab => {
tab.addEventListener("click", function() {
// Remove active class from all tabs
tabs.forEach(t => t.classList.remove("active"));
tabContents.forEach(tc => tc.classList.remove("active"));
// Add active class to clicked tab
this.classList.add("active");
document.getElementById(this.dataset.tab + "-tab").classList.add("active");
});
});
// Check API connection
fetch("/api/status")
.then(response => {
if (!response.ok) {
throw new Error("API response was not ok: " + response.status);
}
return response.json();
})
.then(data => {
statusBar.textContent = "API Status: Connected";
statusBar.classList.add("success");
// Update system info
const systemInfo = document.getElementById("system-info");
systemInfo.innerHTML = \`
<p><strong>Version:</strong> \${data.version || "1.0.0"}</p>
<p><strong>Transmission Connected:</strong> \${data.transmissionConnected ? "Yes" : "No"}</p>
<p><strong>Status:</strong> \${data.status || "Unknown"}</p>
\`;
// Check if already connected to Transmission
if (data.transmissionConnected) {
// Load configuration
loadConfig();
}
})
.catch(error => {
statusBar.textContent = "API Connection Error: " + error.message;
statusBar.classList.add("error");
console.error("Error details:", error);
});
// Connect button functionality
document.getElementById("connect-btn").addEventListener("click", function() {
const host = document.getElementById("host").value;
const port = document.getElementById("port").value;
const username = document.getElementById("username").value;
const password = document.getElementById("password").value;
statusBar.textContent = "Connecting to Transmission...";
statusBar.classList.remove("success", "error");
fetch("/api/transmission/test", {
method: "POST",
headers: {
"Content-Type": "application/json"
},
body: JSON.stringify({
host, port, username, password
})
})
.then(response => {
if (!response.ok) {
throw new Error("API response was not ok: " + response.status);
}
return response.json();
})
.then(data => {
if (data.success) {
statusBar.textContent = "Connected to Transmission successfully!";
statusBar.classList.add("success");
// Load configuration after successful connection
loadConfig();
} else {
statusBar.textContent = "Connection failed: " + data.message;
statusBar.classList.add("error");
}
})
.catch(error => {
statusBar.textContent = "Connection error: " + error.message;
statusBar.classList.add("error");
console.error("Error details:", error);
});
});
// Load configuration from server
function loadConfig() {
fetch("/api/config")
.then(response => response.json())
.then(config => {
// Update configuration tab
const configTab = document.getElementById("config-tab");
configTab.innerHTML = \`
<div class="panel">
<h2>System Configuration</h2>
<h3>Transmission</h3>
<p><strong>Host:</strong> \${config.transmissionConfig.host}</p>
<p><strong>Port:</strong> \${config.transmissionConfig.port}</p>
<h3>Destination Paths</h3>
<p><strong>Movies:</strong> \${config.destinationPaths.movies}</p>
<p><strong>TV Shows:</strong> \${config.destinationPaths.tvShows}</p>
<p><strong>Music:</strong> \${config.destinationPaths.music}</p>
<h3>Seeding Requirements</h3>
<p><strong>Minimum Ratio:</strong> \${config.seedingRequirements.minRatio}</p>
<p><strong>Minimum Time (minutes):</strong> \${config.seedingRequirements.minTimeMinutes}</p>
<button id="edit-config-btn" class="primary-button">Edit Configuration</button>
</div>
\`;
})
.catch(error => {
console.error("Error loading configuration:", error);
});
}
});
</script>
</body>
</html>
EOF
# Create directories for media
echo -e "${YELLOW}Creating media directories...${NC}"
mkdir -p $MEDIA_DIR/movies
mkdir -p $MEDIA_DIR/tvshows
mkdir -p $MEDIA_DIR/music
mkdir -p $MEDIA_DIR/books
mkdir -p $MEDIA_DIR/software
# Set correct permissions
echo -e "${YELLOW}Setting permissions...${NC}"
chown -R $USER:$USER $INSTALL_DIR
chown -R $USER:$USER $MEDIA_DIR
chmod -R 755 $INSTALL_DIR
chmod -R 755 $MEDIA_DIR
# Create config file
echo -e "${YELLOW}Creating configuration file...${NC}"
cat > $INSTALL_DIR/config.json << EOF
{
"transmissionConfig": {
"host": "$TRANSMISSION_HOST",
"port": $TRANSMISSION_PORT,
"username": "$TRANSMISSION_USER",
"password": "$TRANSMISSION_PASS",
"path": "$TRANSMISSION_RPC_PATH"
},
"remoteConfig": {
"isRemote": $TRANSMISSION_REMOTE,
"directoryMapping": $TRANSMISSION_DIR_MAPPING
},
"destinationPaths": {
"movies": "$MEDIA_DIR/movies",
"tvShows": "$MEDIA_DIR/tvshows",
"music": "$MEDIA_DIR/music",
"books": "$MEDIA_DIR/books",
"software": "$MEDIA_DIR/software"
},
"seedingRequirements": {
"minRatio": 1.0,
"minTimeMinutes": 60,
"checkIntervalSeconds": 300
},
"processingOptions": {
"extractArchives": true,
"deleteArchives": true,
"createCategoryFolders": true,
"ignoreSample": true,
"ignoreExtras": true,
"renameFiles": true,
"autoReplaceUpgrades": true,
"removeDuplicates": true,
"keepOnlyBestVersion": true
},
"downloadDir": "$TRANSMISSION_DOWNLOAD_DIR"
}
EOF
# Install Node.js dependencies
echo -e "${YELLOW}Installing Node.js dependencies...${NC}"
cd $INSTALL_DIR
npm install
# Create systemd service
echo -e "${YELLOW}Creating systemd service...${NC}"
cat > /etc/systemd/system/$SERVICE_NAME.service << EOF
[Unit]
Description=Transmission RSS Manager
After=network.target
Wants=transmission-daemon.service
[Service]
ExecStart=/usr/bin/node $INSTALL_DIR/server.js
WorkingDirectory=$INSTALL_DIR
Restart=always
User=$USER
Environment=NODE_ENV=production PORT=$PORT
[Install]
WantedBy=multi-user.target
EOF
# Create Nginx configuration
echo -e "${YELLOW}Creating Nginx configuration...${NC}"
cat > /etc/nginx/sites-available/$SERVICE_NAME << EOF
server {
listen 80;
listen [::]:80;
# Change this to your domain if you have one
server_name _;
# Main location for static files
location / {
proxy_pass http://localhost:$PORT;
proxy_http_version 1.1;
proxy_set_header Upgrade \$http_upgrade;
proxy_set_header Connection 'upgrade';
proxy_set_header Host \$host;
proxy_cache_bypass \$http_upgrade;
}
# Specific location for API calls
location /api/ {
proxy_pass http://localhost:$PORT/api/;
proxy_http_version 1.1;
proxy_set_header Host \$host;
proxy_set_header X-Real-IP \$remote_addr;
proxy_set_header X-Forwarded-For \$proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto \$scheme;
}
}
EOF
# Enable Nginx site
ln -sf /etc/nginx/sites-available/$SERVICE_NAME /etc/nginx/sites-enabled/
# Test Nginx configuration
nginx -t
# Reload Nginx
systemctl reload nginx
# Enable and start the service
echo -e "${YELLOW}Starting service...${NC}"
systemctl daemon-reload
systemctl enable $SERVICE_NAME
systemctl start $SERVICE_NAME
# Print completion message
echo
echo -e "${GREEN}${BOLD}Installation Complete!${NC}"
echo
echo -e "${BOLD}The Transmission RSS Manager has been installed to:${NC} $INSTALL_DIR"
echo -e "${BOLD}Web interface is available at:${NC} http://localhost (or your server IP)"
echo -e "${BOLD}Service status:${NC} $(systemctl is-active $SERVICE_NAME)"
echo
echo -e "${BOLD}To view logs:${NC} journalctl -u $SERVICE_NAME -f"
echo -e "${BOLD}To restart service:${NC} sudo systemctl restart $SERVICE_NAME"
echo
if [ "$TRANSMISSION_REMOTE" = true ]; then
echo -e "${YELLOW}Remote Transmission Configuration:${NC}"
echo -e "Host: $TRANSMISSION_HOST:$TRANSMISSION_PORT"
echo -e "Directory Mapping: Remote paths will be mapped to local paths for processing"
echo
fi
# Final check
if systemctl is-active --quiet $SERVICE_NAME; then
echo -e "${GREEN}Service is running successfully!${NC}"
else
echo -e "${RED}Service failed to start. Check logs with: journalctl -u $SERVICE_NAME -f${NC}"
fi
echo -e "${BOLD}==================================================${NC}"

982
post-processor-implementation.txt Normal file
View File

@ -0,0 +1,982 @@
// postProcessor.js - Handles post-download processing
const fs = require('fs').promises;
const path = require('path');
const childProcess = require('child_process');
const util = require('util');
const exec = util.promisify(childProcess.exec);
const Transmission = require('transmission');
const AdmZip = require('adm-zip');
class PostProcessor {
constructor(config = {}) {
this.config = {
// Transmission connection details
transmissionConfig: config.transmissionConfig || {},
// Remote configuration
remoteConfig: {
isRemote: false,
directoryMapping: {},
...config.remoteConfig
},
// Destination paths
destinationPaths: {
movies: '/mnt/media/movies',
tvShows: '/mnt/media/tvshows',
music: '/mnt/media/music',
books: '/mnt/media/books',
software: '/mnt/media/software',
...config.destinationPaths
},
// Seeding requirements
seedingRequirements: {
minRatio: 1.0, // Minimum ratio to achieve
minTimeMinutes: 60, // Minimum seeding time in minutes
checkIntervalSeconds: 300, // Check interval in seconds
...config.seedingRequirements
},
// Processing options
processingOptions: {
extractArchives: true, // Extract rar, zip, etc.
deleteArchives: true, // Delete archives after extraction
createCategoryFolders: true, // Create category subfolders
ignoreSample: true, // Ignore sample files
ignoreExtras: true, // Ignore extra/bonus content
renameFiles: true, // Rename files to clean names
autoReplaceUpgrades: true, // Automatically replace with better quality
removeDuplicates: true, // Remove duplicate content
keepOnlyBestVersion: true, // Keep only the best version when duplicates exist
...config.processingOptions
},
// File patterns
filePatterns: {
videoExtensions: ['.mkv', '.mp4', '.avi', '.mov', '.wmv', '.m4v', '.mpg', '.mpeg'],
audioExtensions: ['.mp3', '.flac', '.m4a', '.wav', '.ogg', '.aac'],
archiveExtensions: ['.rar', '.zip', '.7z', '.tar', '.gz'],
ignorePatterns: ['sample', 'trailer', 'extra', 'bonus', 'behind.the.scenes', 'featurette'],
...config.filePatterns
}
};
this.transmissionClient = new Transmission(this.config.transmissionConfig);
this.processQueue = [];
this.isProcessing = false;
this.processingIntervalId = null;
// Initialize the database
this.managedContentDatabase = this.loadManagedContentDatabase();
}
// Start processing monitor
start() {
if (this.processingIntervalId) {
this.stop();
}
this.processingIntervalId = setInterval(() => {
this.checkCompletedTorrents();
}, this.config.seedingRequirements.checkIntervalSeconds * 1000);
console.log('Post-processor started');
this.checkCompletedTorrents(); // Do an initial check
return this;
}
// Stop processing monitor
stop() {
if (this.processingIntervalId) {
clearInterval(this.processingIntervalId);
this.processingIntervalId = null;
}
console.log('Post-processor stopped');
return this;
}
// Check for completed torrents that meet seeding requirements
async checkCompletedTorrents() {
if (this.isProcessing) {
return; // Don't start a new check if already processing
}
try {
this.isProcessing = true;
// Get detailed info about all torrents
const response = await this.getTorrents([
'id', 'name', 'status', 'downloadDir', 'percentDone', 'uploadRatio',
'addedDate', 'doneDate', 'downloadedEver', 'files', 'labels',
'secondsSeeding', 'isFinished'
]);
if (!response || !response.arguments || !response.arguments.torrents) {
throw new Error('Invalid response from Transmission');
}
const torrents = response.arguments.torrents;
// Find completed torrents that are seeding
for (const torrent of torrents) {
// Skip if not finished downloading or already processed
if (!torrent.isFinished || this.processQueue.some(item => item.id === torrent.id)) {
continue;
}
// Calculate seeding time in minutes
const seedingTimeMinutes = torrent.secondsSeeding / 60;
// Check if seeding requirements are met
const ratioMet = torrent.uploadRatio >= this.config.seedingRequirements.minRatio;
const timeMet = seedingTimeMinutes >= this.config.seedingRequirements.minTimeMinutes;
// If either requirement is met, queue for processing
if (ratioMet || timeMet) {
this.processQueue.push({
id: torrent.id,
name: torrent.name,
downloadDir: torrent.downloadDir,
files: torrent.files,
category: this.detectCategory(torrent),
ratioMet,
timeMet,
seedingTimeMinutes
});
console.log(`Queued torrent for processing: ${torrent.name}`);
}
}
// Process the queue
if (this.processQueue.length > 0) {
await this.processNextInQueue();
}
} catch (error) {
console.error('Error checking completed torrents:', error);
} finally {
this.isProcessing = false;
}
}
// Process next item in queue
async processNextInQueue() {
if (this.processQueue.length === 0) {
return;
}
const item = this.processQueue.shift();
try {
console.log(`Processing: ${item.name}`);
// 1. Determine target directory
const targetDir = this.getTargetDirectory(item);
// 2. Process files (copy/extract)
await this.processFiles(item, targetDir);
// 3. Update status to indicate processing is complete
console.log(`Processing complete for: ${item.name}`);
// 4. Optionally remove torrent from Transmission (commented out for safety)
// await this.removeTorrent(item.id, false);
} catch (error) {
console.error(`Error processing ${item.name}:`, error);
// Put back in queue to retry later
this.processQueue.push(item);
}
// Process next item
if (this.processQueue.length > 0) {
await this.processNextInQueue();
}
}
// Get torrents from Transmission
async getTorrents(fields) {
return new Promise((resolve, reject) => {
this.transmissionClient.get(fields, (err, result) => {
if (err) {
reject(err);
} else {
resolve(result);
}
});
});
}
// Remove torrent from Transmission
async removeTorrent(id, deleteLocalData = false) {
return new Promise((resolve, reject) => {
this.transmissionClient.remove(id, deleteLocalData, (err, result) => {
if (err) {
reject(err);
} else {
resolve(result);
}
});
});
}
// Determine the category of a torrent
detectCategory(torrent) {
// First check if torrent has labels
if (torrent.labels && torrent.labels.length > 0) {
const label = torrent.labels[0].toLowerCase();
if (label.includes('movie')) return 'movies';
if (label.includes('tv') || label.includes('show')) return 'tvShows';
if (label.includes('music') || label.includes('audio')) return 'music';
if (label.includes('book') || label.includes('ebook')) return 'books';
if (label.includes('software') || label.includes('app')) return 'software';
}
// Then check the name for common patterns
const name = torrent.name.toLowerCase();
// Check for TV show patterns (e.g., S01E01, Season 1, etc.)
if (/s\d{1,2}e\d{1,2}/i.test(name) || /season\s\d{1,2}/i.test(name)) {
return 'tvShows';
}
// Check file extensions to help determine type
const fileExtensions = torrent.files.map(file => {
const ext = file.name.substring(file.name.lastIndexOf('.')).toLowerCase();
return ext;
});
const hasVideoFiles = fileExtensions.some(ext =>
this.config.filePatterns.videoExtensions.includes(ext)
);
const hasAudioFiles = fileExtensions.some(ext =>
this.config.filePatterns.audioExtensions.includes(ext)
);
if (hasVideoFiles) {
// Assume movies if has video but not detected as TV show
return 'movies';
}
if (hasAudioFiles) {
return 'music';
}
// Default fallback based on common terms
if (name.includes('movie') || name.includes('film')) return 'movies';
if (name.includes('album') || name.includes('discography')) return 'music';
if (name.includes('book') || name.includes('epub') || name.includes('pdf')) return 'books';
if (name.includes('software') || name.includes('program') || name.includes('app')) return 'software';
// Ultimate fallback
return 'movies';
}
// Get target directory path based on category
getTargetDirectory(item) {
const baseDir = this.config.destinationPaths[item.category] || this.config.destinationPaths.movies;
if (!this.config.processingOptions.createCategoryFolders) {
return baseDir;
}
// For movies, we might want to organize by name
if (item.category === 'movies') {
// Extract name and year if possible
const mediaInfo = this.extractMediaInfo(item.name);
if (mediaInfo.title) {
return `${baseDir}/${mediaInfo.title}${mediaInfo.year ? ` (${mediaInfo.year})` : ''}`;
}
}
// For TV shows, organize by show name
if (item.category === 'tvShows') {
// Try to extract show name from common patterns
const match = item.name.match(/^(.+?)(?:\s*S\d{1,2}|\s*Season\s*\d{1,2}|\s*\(\d{4}\))/i);
if (match) {
const showName = match[1].replace(/\./g, ' ').trim();
return `${baseDir}/${showName}`;
}
}
// Fallback to using the item name directly
return `${baseDir}/${item.name}`;
}
// Map a remote path to a local path
mapRemotePathToLocal(remotePath) {
if (!this.config.remoteConfig.isRemote) {
return remotePath; // Not a remote setup, return as is
}
const mapping = this.config.remoteConfig.directoryMapping;
// Check for exact match
if (mapping[remotePath]) {
return mapping[remotePath];
}
// Check for parent directory match
for (const [remote, local] of Object.entries(mapping)) {
if (remotePath.startsWith(remote)) {
const relativePath = remotePath.slice(remote.length);
return local + relativePath;
}
}
// No mapping found, return original path but log warning
console.warn(`No directory mapping found for remote path: ${remotePath}`);
return remotePath;
}
// Map a local path to a remote path
mapLocalPathToRemote(localPath) {
if (!this.config.remoteConfig.isRemote) {
return localPath; // Not a remote setup, return as is
}
const mapping = this.config.remoteConfig.directoryMapping;
const reversedMapping = {};
// Create reversed mapping (local -> remote)
for (const [remote, local] of Object.entries(mapping)) {
reversedMapping[local] = remote;
}
// Check for exact match
if (reversedMapping[localPath]) {
return reversedMapping[localPath];
}
// Check for parent directory match
for (const [local, remote] of Object.entries(reversedMapping)) {
if (localPath.startsWith(local)) {
const relativePath = localPath.slice(local.length);
return remote + relativePath;
}
}
// No mapping found, return original path but log warning
console.warn(`No directory mapping found for local path: ${localPath}`);
return localPath;
}
// Process files (copy or extract)
async processFiles(item, targetDir) {
// Check for existing versions of the same content
const existingVersion = await this.findExistingVersion(item);
if (existingVersion) {
console.log(`Found existing version: ${existingVersion.path}`);
// Check if new version is better quality
const isUpgrade = await this.isQualityUpgrade(item, existingVersion);
if (isUpgrade) {
console.log(`New version is a quality upgrade. Replacing...`);
// If auto-replace is enabled, remove the old version
if (this.config.processingOptions.autoReplaceUpgrades) {
await this.removeExistingVersion(existingVersion);
}
} else if (this.config.processingOptions.keepOnlyBestVersion) {
// If not an upgrade and we only want to keep the best version, stop processing
console.log(`New version is not a quality upgrade. Skipping...`);
return false;
}
}
// If checking for duplicates, verify this isn't a duplicate
if (this.config.processingOptions.removeDuplicates) {
const duplicates = await this.findDuplicates(item);
if (duplicates.length > 0) {
console.log(`Found ${duplicates.length} duplicate(s).`);
// Keep only the best version if enabled
if (this.config.processingOptions.keepOnlyBestVersion) {
// Determine the best version among all (including the new one)
const allVersions = [...duplicates, { item, quality: this.getQualityRank(item) }];
const bestVersion = this.findBestQualityVersion(allVersions);
// If the new version is the best, remove all others and continue
if (bestVersion.item === item) {
console.log(`New version is the best quality. Removing duplicates.`);
for (const duplicate of duplicates) {
await this.removeExistingVersion(duplicate);
}
} else {
// If the new version is not the best, skip processing
console.log(`A better version already exists. Skipping...`);
return false;
}
}
}
}
try {
// Create target directory
await fs.mkdir(targetDir, { recursive: true });
// For each file in the torrent
for (const file of item.files) {
// Handle remote path mapping if applicable
let sourcePath;
if (this.config.remoteConfig.isRemote) {
// Map the remote download dir to local path
const localDownloadDir = this.mapRemotePathToLocal(item.downloadDir);
sourcePath = path.join(localDownloadDir, file.name);
} else {
sourcePath = path.join(item.downloadDir, file.name);
}
const fileExt = path.extname(file.name).toLowerCase();
// Skip sample files if configured
if (this.config.processingOptions.ignoreSample &&
this.config.filePatterns.ignorePatterns.some(pattern =>
file.name.toLowerCase().includes(pattern))) {
console.log(`Skipping file (matches ignore pattern): ${file.name}`);
continue;
}
// Handle archives if extraction is enabled
if (this.config.processingOptions.extractArchives &&
this.config.filePatterns.archiveExtensions.includes(fileExt)) {
console.log(`Extracting archive: ${sourcePath} to ${targetDir}`);
// Extract the archive
if (fileExt === '.zip') {
await this.extractZipArchive(sourcePath, targetDir);
} else if (fileExt === '.rar') {
await this.extractRarArchive(sourcePath, targetDir);
} else {
console.log(`Unsupported archive type: ${fileExt}`);
// Just copy the file as is
let destFileName = file.name;
if (this.config.processingOptions.renameFiles) {
destFileName = this.cleanFileName(file.name);
}
const destPath = path.join(targetDir, destFileName);
await fs.copyFile(sourcePath, destPath);
}
// Delete archive after extraction if configured
if (this.config.processingOptions.deleteArchives) {
console.log(`Deleting archive after extraction: ${sourcePath}`);
try {
await fs.unlink(sourcePath);
} catch (err) {
console.error(`Error deleting archive: ${err.message}`);
}
}
}
// Copy non-archive files
else {
let destFileName = file.name;
// Rename files if configured
if (this.config.processingOptions.renameFiles) {
destFileName = this.cleanFileName(file.name);
}
// Create subdirectories if needed
const subDir = path.dirname(file.name);
if (subDir !== '.') {
const targetSubDir = path.join(targetDir, subDir);
await fs.mkdir(targetSubDir, { recursive: true });
}
const destPath = path.join(targetDir, destFileName);
console.log(`Copying file: ${sourcePath} to ${destPath}`);
// Copy the file
await fs.copyFile(sourcePath, destPath);
}
}
// After successful processing, update the managed content database
await this.updateManagedContent(item, targetDir);
return true;
} catch (error) {
console.error(`Error processing files: ${error.message}`);
throw error;
}
}
// Extract ZIP archive
async extractZipArchive(archivePath, destination) {
try {
const zip = new AdmZip(archivePath);
zip.extractAllTo(destination, true);
return true;
} catch (error) {
console.error(`Failed to extract ZIP archive: ${error.message}`);
throw error;
}
}
// Extract RAR archive
async extractRarArchive(archivePath, destination) {
try {
// Check if unrar is available
await exec('unrar --version');
// Use unrar to extract the archive
const command = `unrar x -o+ "${archivePath}" "${destination}"`;
await exec(command);
return true;
} catch (error) {
console.error(`Failed to extract RAR archive: ${error.message}`);
throw error;
}
}
// Load managed content database
loadManagedContentDatabase() {
try {
if (typeof window !== 'undefined' && window.localStorage) {
// Browser environment
const savedData = localStorage.getItem('managed-content-database');
return savedData ? JSON.parse(savedData) : [];
} else {
// Node.js environment
try {
const fs = require('fs');
const path = require('path');
const dbPath = path.join(__dirname, 'managed-content-database.json');
if (fs.existsSync(dbPath)) {
const data = fs.readFileSync(dbPath, 'utf8');
return JSON.parse(data);
}
} catch (err) {
console.error('Error reading database file:', err);
}
return [];
}
} catch (error) {
console.error('Error loading managed content database:', error);
return [];
}
}
// Save managed content database
saveManagedContentDatabase(database) {
try {
if (typeof window !== 'undefined' && window.localStorage) {
// Browser environment
localStorage.setItem('managed-content-database', JSON.stringify(database));
} else {
// Node.js environment
const fs = require('fs');
const path = require('path');
const dbPath = path.join(__dirname, 'managed-content-database.json');
fs.writeFileSync(dbPath, JSON.stringify(database, null, 2), 'utf8');
}
} catch (error) {
console.error('Error saving managed content database:', error);
}
}
// Update managed content database with new item
async updateManagedContent(item, targetDir) {
const database = this.loadManagedContentDatabase();
// Extract media info
const mediaInfo = this.extractMediaInfo(item.name);
// Calculate quality rank
const qualityRank = this.getQualityRank(item);
// Check if entry already exists
const existingIndex = database.findIndex(entry =>
entry.title.toLowerCase() === mediaInfo.title.toLowerCase() &&
(!mediaInfo.year || !entry.year || entry.year === mediaInfo.year)
);
// Create new entry
const newEntry = {
id: Date.now().toString(),
title: mediaInfo.title,
year: mediaInfo.year,
category: item.category,
quality: this.detectQuality(item.name),
qualityRank,
path: targetDir,
originalName: item.name,
dateAdded: new Date().toISOString(),
torrentId: item.id
};
// If entry exists, update or add to history
if (existingIndex !== -1) {
// If new version has better quality
if (qualityRank > database[existingIndex].qualityRank) {
// Save the old version to history
if (!database[existingIndex].history) {
database[existingIndex].history = [];
}
database[existingIndex].history.push({
quality: database[existingIndex].quality,
qualityRank: database[existingIndex].qualityRank,
path: database[existingIndex].path,
originalName: database[existingIndex].originalName,
dateAdded: database[existingIndex].dateAdded
});
// Update with new version
database[existingIndex].quality = newEntry.quality;
database[existingIndex].qualityRank = newEntry.qualityRank;
database[existingIndex].path = newEntry.path;
database[existingIndex].originalName = newEntry.originalName;
database[existingIndex].dateUpdated = new Date().toISOString();
database[existingIndex].torrentId = newEntry.torrentId;
}
} else {
// Add new entry
database.push(newEntry);
}
// Save updated database
this.saveManagedContentDatabase(database);
}
// Find existing version of the same content
async findExistingVersion(item) {
const database = this.loadManagedContentDatabase();
const mediaInfo = this.extractMediaInfo(item.name);
// Find matching content
const match = database.find(entry =>
entry.title.toLowerCase() === mediaInfo.title.toLowerCase() &&
(!mediaInfo.year || !entry.year || entry.year === mediaInfo.year)
);
return match;
}
// Find duplicates of the same content
async findDuplicates(item) {
const database = this.loadManagedContentDatabase();
const mediaInfo = this.extractMediaInfo(item.name);
// Find all matching content
const matches = database.filter(entry =>
entry.title.toLowerCase() === mediaInfo.title.toLowerCase() &&
(!mediaInfo.year || !entry.year || entry.year === mediaInfo.year)
);
return matches;
}
// Remove an existing version
async removeExistingVersion(version) {
console.log(`Removing existing version: ${version.path}`);
try {
// Check if directory exists
const stats = await fs.stat(version.path);
if (stats.isDirectory()) {
// Remove directory and all contents
await this.removeDirectory(version.path);
} else {
// Just remove the file
await fs.unlink(version.path);
}
// Remove from managed content database
const database = this.loadManagedContentDatabase();
const updatedDatabase = database.filter(entry => entry.id !== version.id);
this.saveManagedContentDatabase(updatedDatabase);
return true;
} catch (error) {
console.error(`Error removing existing version: ${error.message}`);
return false;
}
}
// Remove a directory recursively
async removeDirectory(dirPath) {
try {
const items = await fs.readdir(dirPath);
for (const item of items) {
const itemPath = path.join(dirPath, item);
const stats = await fs.stat(itemPath);
if (stats.isDirectory()) {
await this.removeDirectory(itemPath);
} else {
await fs.unlink(itemPath);
}
}
await fs.rmdir(dirPath);
} catch (error) {
console.error(`Error removing directory: ${error.message}`);
throw error;
}
}
// Check if a new version is a quality upgrade
async isQualityUpgrade(newItem, existingVersion) {
const newQuality = this.getQualityRank(newItem);
const existingQuality = existingVersion.qualityRank || 0;
return newQuality > existingQuality;
}
// Find the best quality version among multiple versions
findBestQualityVersion(versions) {
return versions.reduce((best, current) => {
return (current.qualityRank > best.qualityRank) ? current : best;
}, versions[0]);
}
// Calculate quality rank for an item
getQualityRank(item) {
const quality = this.detectQuality(item.name);
if (!quality) return 0;
const qualityStr = quality.toLowerCase();
if (qualityStr.includes('2160p') || qualityStr.includes('4k') || qualityStr.includes('uhd')) {
return 5;
}
if (qualityStr.includes('1080p') || qualityStr.includes('fullhd') ||
(qualityStr.includes('bluray') && !qualityStr.includes('720p'))) {
return 4;
}
if (qualityStr.includes('720p') || qualityStr.includes('hd')) {
return 3;
}
if (qualityStr.includes('dvdrip') || qualityStr.includes('sdbd')) {
return 2;
}
if (qualityStr.includes('webrip') || qualityStr.includes('webdl') || qualityStr.includes('web-dl')) {
return 1;
}
// Low quality or unknown
return 0;
}
// Detect quality from item name
detectQuality(name) {
const lowerName = name.toLowerCase();
// Quality patterns
const qualityPatterns = [
{ regex: /\b(2160p|uhd|4k)\b/i, quality: '2160p/4K' },
{ regex: /\b(1080p|fullhd|fhd)\b/i, quality: '1080p' },
{ regex: /\b(720p|hd)\b/i, quality: '720p' },
{ regex: /\b(bluray|bdremux|bdrip)\b/i, quality: 'BluRay' },
{ regex: /\b(webdl|web-dl|webrip)\b/i, quality: 'WebDL' },
{ regex: /\b(dvdrip|dvd-rip)\b/i, quality: 'DVDRip' },
{ regex: /\b(hdtv)\b/i, quality: 'HDTV' },
{ regex: /\b(hdtc|hd-tc)\b/i, quality: 'HDTC' },
{ regex: /\b(hdts|hd-ts|hdcam)\b/i, quality: 'HDTS' },
{ regex: /\b(cam|camrip)\b/i, quality: 'CAM' }
];
for (const pattern of qualityPatterns) {
if (pattern.regex.test(lowerName)) {
return pattern.quality;
}
}
return 'Unknown';
}
// Extract media info from name
extractMediaInfo(name) {
// Year pattern (e.g., "2023" or "(2023)" or "[2023]")
const yearPattern = /[\[\(\s.]+(19|20)\d{2}[\]\)\s.]+/;
const yearMatch = name.match(yearPattern);
const year = yearMatch ? yearMatch[0].replace(/[\[\]\(\)\s.]+/g, '') : null;
// Clean up title to get movie name
let cleanTitle = yearMatch ? name.split(yearPattern)[0].trim() : name;
// Remove quality indicators, scene tags, etc.
const cleanupPatterns = [
/\b(720p|1080p|2160p|4K|UHD|HDTV|WEB-DL|WEBRip|BRRip|BluRay|DVDRip)\b/gi,
/\b(HEVC|AVC|x264|x265|H\.?264|H\.?265|XVID|DIVX)\b/gi,
/\b(AAC|MP3|AC3|DTS|FLAC|OPUS)\b/gi,
/\b(AMZN|DSNP|HULU|HMAX|NF|PCOK)\b/gi,
/\b(EXTENDED|Directors\.?Cut|UNRATED|REMASTERED|PROPER|REMUX)\b/gi,
/\b(IMAX)\b/gi,
/[-\.][A-Za-z0-9]+$/
];
cleanupPatterns.forEach(pattern => {
cleanTitle = cleanTitle.replace(pattern, '');
});
// Final cleanup
cleanTitle = cleanTitle
.replace(/[._-]/g, ' ')
.replace(/\s{2,}/g, ' ')
.trim();
return {
title: cleanTitle,
year: year
};
}
// Clean up file name for nicer presentation
cleanFileName(fileName) {
// Remove common scene tags
let cleaned = fileName;
// Remove stuff in brackets
cleaned = cleaned.replace(/\[[^\]]+\]/g, '');
// Remove scene group names after dash
cleaned = cleaned.replace(/-[A-Za-z0-9]+$/, '');
// Replace dots with spaces
cleaned = cleaned.replace(/\./g, ' ');
// Remove multiple spaces
cleaned = cleaned.replace(/\s{2,}/g, ' ').trim();
// Keep the file extension
const lastDotIndex = fileName.lastIndexOf('.');
if (lastDotIndex !== -1) {
const extension = fileName.substring(lastDotIndex);
cleaned = cleaned + extension;
}
return cleaned;
}
// Update configuration
updateConfig(newConfig) {
this.config = {
...this.config,
...newConfig,
transmissionConfig: {
...this.config.transmissionConfig,
...newConfig.transmissionConfig
},
remoteConfig: {
...this.config.remoteConfig,
...newConfig.remoteConfig
},
destinationPaths: {
...this.config.destinationPaths,
...newConfig.destinationPaths
},
seedingRequirements: {
...this.config.seedingRequirements,
...newConfig.seedingRequirements
},
processingOptions: {
...this.config.processingOptions,
...newConfig.processingOptions
},
filePatterns: {
...this.config.filePatterns,
...newConfig.filePatterns
}
};
// Reinitialize the Transmission client
this.transmissionClient = new Transmission(this.config.transmissionConfig);
return this;
}
// Get library statistics
getLibraryStats() {
const database = this.loadManagedContentDatabase();
const stats = {
totalItems: database.length,
byCategory: {},
byQuality: {
'Unknown': 0,
'CAM/TS': 0,
'SD': 0,
'720p': 0,
'1080p': 0,
'4K/UHD': 0
},
totalUpgrades: 0
};
// Process each item
database.forEach(item => {
// Count by category
stats.byCategory[item.category] = (stats.byCategory[item.category] || 0) + 1;
// Count by quality rank
if (item.qualityRank >= 5) {
stats.byQuality['4K/UHD']++;
} else if (item.qualityRank >= 4) {
stats.byQuality['1080p']++;
} else if (item.qualityRank >= 3) {
stats.byQuality['720p']++;
} else if (item.qualityRank >= 1) {
stats.byQuality['SD']++;
} else if (item.qualityRank === 0 && item.quality && item.quality.toLowerCase().includes('cam')) {
stats.byQuality['CAM/TS']++;
} else {
stats.byQuality['Unknown']++;
}
// Count upgrades
if (item.history && item.history.length > 0) {
stats.totalUpgrades += item.history.length;
}
});
return stats;
}
// Get entire media library
getLibrary() {
return this.loadManagedContentDatabase();
}
// Search for media items
searchLibrary(query) {
if (!query) return this.getLibrary();
const database = this.loadManagedContentDatabase();
const lowerQuery = query.toLowerCase();
return database.filter(item =>
item.title.toLowerCase().includes(lowerQuery) ||
(item.year && item.year.includes(lowerQuery)) ||
(item.category && item.category.toLowerCase().includes(lowerQuery)) ||
(item.quality && item.quality.toLowerCase().includes(lowerQuery))
);
}
}
// Export for Node.js or browser
if (typeof module !== 'undefined' && module.exports) {
module.exports = PostProcessor;
} else if (typeof window !== 'undefined') {
window.PostProcessor = PostProcessor;
}

586
rss-implementation.js Normal file
View File

@ -0,0 +1,586 @@
// rssFeedManager.js - Manages RSS feeds and parsing
const xml2js = require('xml2js');
const fetch = require('node-fetch');
const fs = require('fs').promises;
const path = require('path');
class RssFeedManager {
constructor(config = {}) {
this.config = {
feeds: [],
updateIntervalMinutes: 60,
maxItemsPerFeed: 100,
autoDownload: false,
downloadFilters: {},
...config
};
this.parser = new xml2js.Parser({
explicitArray: false,
normalize: true,
normalizeTags: true
});
this.feedItems = [];
this.updateIntervalId = null;
}
// Start RSS feed monitoring
start() {
if (this.updateIntervalId) {
this.stop();
}
this.updateIntervalId = setInterval(() => {
this.updateAllFeeds();
}, this.config.updateIntervalMinutes * 60 * 1000);
console.log('RSS feed manager started');
this.updateAllFeeds(); // Do an initial update
return this;
}
// Stop RSS feed monitoring
stop() {
if (this.updateIntervalId) {
clearInterval(this.updateIntervalId);
this.updateIntervalId = null;
}
console.log('RSS feed manager stopped');
return this;
}
// Update all feeds
async updateAllFeeds() {
console.log('Updating all RSS feeds');
const results = {
total: this.config.feeds.length,
success: 0,
failed: 0,
newItems: 0
};
for (const feed of this.config.feeds) {
try {
const newItems = await this.updateFeed(feed);
results.success++;
results.newItems += newItems;
} catch (error) {
console.error(`Error updating feed ${feed.name || feed.url}:`, error);
results.failed++;
}
}
console.log(`Feed update complete: ${results.success}/${results.total} feeds updated, ${results.newItems} new items`);
// Save updated feed items to database
await this.saveItems();
return results;
}
// Update a single feed
async updateFeed(feed) {
console.log(`Updating feed: ${feed.name || feed.url}`);
try {
const response = await fetch(feed.url);
if (!response.ok) {
throw new Error(`Failed to fetch RSS feed: ${response.statusText}`);
}
const xml = await response.text();
const result = await this.parseXml(xml);
// Extract and format feed items
const items = this.extractItems(result, feed);
// Count new items (not already in our database)
let newItemCount = 0;
// Process each item
for (const item of items) {
// Generate a unique ID for the item
const itemId = this.generateItemId(item);
// Check if item already exists
const existingItem = this.feedItems.find(i => i.id === itemId);
if (!existingItem) {
// Add feed info to item
item.feedId = feed.id;
item.feedName = feed.name;
item.id = itemId;
item.firstSeen = new Date().toISOString();
item.downloaded = false;
// Add to items array
this.feedItems.push(item);
newItemCount++;
// Auto-download if enabled and item matches filter
if (feed.autoDownload && this.matchesFilter(item, feed.filters)) {
this.downloadItem(item);
}
}
}
console.log(`Feed updated: ${feed.name || feed.url}, ${newItemCount} new items`);
return newItemCount;
} catch (error) {
console.error(`Error updating feed: ${error.message}`);
throw error;
}
}
// Parse XML data
async parseXml(xml) {
return new Promise((resolve, reject) => {
this.parser.parseString(xml, (err, result) => {
if (err) {
reject(err);
} else {
resolve(result);
}
});
});
}
// Extract items from parsed feed
extractItems(parsedFeed, feedConfig) {
const items = [];
// Handle different feed formats
let feedItems = [];
if (parsedFeed.rss && parsedFeed.rss.channel) {
// Standard RSS
feedItems = parsedFeed.rss.channel.item || [];
if (!Array.isArray(feedItems)) {
feedItems = [feedItems];
}
} else if (parsedFeed.feed && parsedFeed.feed.entry) {
// Atom format
feedItems = parsedFeed.feed.entry || [];
if (!Array.isArray(feedItems)) {
feedItems = [feedItems];
}
}
// Process each item
for (const item of feedItems) {
const processedItem = this.processItem(item, feedConfig);
if (processedItem) {
items.push(processedItem);
}
}
return items;
}
// Process a single feed item
processItem(item, feedConfig) {
// Extract basic fields
const processed = {
title: item.title || '',
description: item.description || item.summary || '',
pubDate: item.pubdate || item.published || item.date || new Date().toISOString(),
size: 0,
seeders: 0,
leechers: 0,
quality: 'Unknown',
category: 'Unknown'
};
// Set download link
if (item.link) {
if (typeof item.link === 'string') {
processed.link = item.link;
} else if (item.link.$ && item.link.$.href) {
processed.link = item.link.$.href;
} else if (Array.isArray(item.link) && item.link.length > 0) {
const magnetLink = item.link.find(link =>
(typeof link === 'string' && link.startsWith('magnet:')) ||
(link.$ && link.$.href && link.$.href.startsWith('magnet:'))
);
if (magnetLink) {
processed.link = typeof magnetLink === 'string' ? magnetLink : magnetLink.$.href;
} else {
processed.link = typeof item.link[0] === 'string' ? item.link[0] : (item.link[0].$ ? item.link[0].$.href : '');
}
}
} else if (item.enclosure && item.enclosure.url) {
processed.link = item.enclosure.url;
}
// Skip item if no link found
if (!processed.link) {
return null;
}
// Try to extract size information
if (item.size) {
processed.size = parseInt(item.size, 10) || 0;
} else if (item.enclosure && item.enclosure.length) {
processed.size = parseInt(item.enclosure.length, 10) || 0;
} else if (item['torrent:contentlength']) {
processed.size = parseInt(item['torrent:contentlength'], 10) || 0;
}
// Convert size to MB if it's in bytes
if (processed.size > 1000000) {
processed.size = Math.round(processed.size / 1000000);
}
// Try to extract seeders/leechers
if (item.seeders || item['torrent:seeds']) {
processed.seeders = parseInt(item.seeders || item['torrent:seeds'], 10) || 0;
}
if (item.leechers || item['torrent:peers']) {
processed.leechers = parseInt(item.leechers || item['torrent:peers'], 10) || 0;
}
// Try to determine category
if (item.category) {
if (Array.isArray(item.category)) {
processed.category = item.category[0] || 'Unknown';
} else {
processed.category = item.category;
}
} else if (feedConfig.defaultCategory) {
processed.category = feedConfig.defaultCategory;
}
// Detect quality from title
processed.quality = this.detectQuality(processed.title);
return processed;
}
// Detect quality from title
detectQuality(title) {
const lowerTitle = title.toLowerCase();
// Quality patterns
const qualityPatterns = [
{ regex: /\b(2160p|uhd|4k)\b/i, quality: '2160p/4K' },
{ regex: /\b(1080p|fullhd|fhd)\b/i, quality: '1080p' },
{ regex: /\b(720p|hd)\b/i, quality: '720p' },
{ regex: /\b(bluray|bdremux|bdrip)\b/i, quality: 'BluRay' },
{ regex: /\b(webdl|web-dl|webrip)\b/i, quality: 'WebDL' },
{ regex: /\b(dvdrip|dvd-rip)\b/i, quality: 'DVDRip' },
{ regex: /\b(hdtv)\b/i, quality: 'HDTV' },
{ regex: /\b(hdtc|hd-tc)\b/i, quality: 'HDTC' },
{ regex: /\b(hdts|hd-ts|hdcam)\b/i, quality: 'HDTS' },
{ regex: /\b(cam|camrip)\b/i, quality: 'CAM' }
];
for (const pattern of qualityPatterns) {
if (pattern.regex.test(lowerTitle)) {
return pattern.quality;
}
}
return 'Unknown';
}
// Generate a unique ID for an item
generateItemId(item) {
// Use hash of title + link as ID
const hash = require('crypto').createHash('md5');
hash.update(item.title + item.link);
return hash.digest('hex');
}
// Check if an item matches a filter
matchesFilter(item, filters) {
if (!filters) return true;
// Name contains filter
if (filters.nameContains && !item.title.toLowerCase().includes(filters.nameContains.toLowerCase())) {
return false;
}
// Size filters
if (filters.minSize && item.size < filters.minSize) {
return false;
}
if (filters.maxSize && filters.maxSize > 0 && item.size > filters.maxSize) {
return false;
}
// Category filter
if (filters.includeCategory && !item.category.toLowerCase().includes(filters.includeCategory.toLowerCase())) {
return false;
}
// Exclude terms
if (filters.excludeTerms) {
const terms = filters.excludeTerms.toLowerCase().split(',').map(t => t.trim());
if (terms.some(term => item.title.toLowerCase().includes(term))) {
return false;
}
}
// Unwanted formats
if (filters.unwantedFormats) {
const formats = filters.unwantedFormats.toLowerCase().split(',').map(f => f.trim());
if (formats.some(format => item.title.toLowerCase().includes(format) ||
(item.quality && item.quality.toLowerCase() === format.toLowerCase()))) {
return false;
}
}
// Minimum quality
if (filters.minimumQuality) {
const qualityRanks = {
'unknown': 0,
'cam': 0,
'ts': 0,
'hdts': 0,
'tc': 0,
'hdtc': 0,
'dvdscr': 1,
'webrip': 1,
'webdl': 1,
'dvdrip': 2,
'hdtv': 2,
'720p': 3,
'hd': 3,
'1080p': 4,
'fullhd': 4,
'bluray': 4,
'2160p': 5,
'4k': 5,
'uhd': 5
};
const minQualityRank = qualityRanks[filters.minimumQuality.toLowerCase()] || 0;
const itemQualityRank = this.getQualityRank(item.quality);
if (itemQualityRank < minQualityRank) {
return false;
}
}
// Minimum seeders
if (filters.minimumSeeders && item.seeders < filters.minimumSeeders) {
return false;
}
// Passed all filters
return true;
}
// Calculate quality rank for an item
getQualityRank(quality) {
if (!quality) return 0;
const qualityStr = quality.toLowerCase();
if (qualityStr.includes('2160p') || qualityStr.includes('4k') || qualityStr.includes('uhd')) {
return 5;
}
if (qualityStr.includes('1080p') || qualityStr.includes('fullhd') ||
(qualityStr.includes('bluray') && !qualityStr.includes('720p'))) {
return 4;
}
if (qualityStr.includes('720p') || qualityStr.includes('hd')) {
return 3;
}
if (qualityStr.includes('dvdrip') || qualityStr.includes('sdbd')) {
return 2;
}
if (qualityStr.includes('webrip') || qualityStr.includes('webdl') || qualityStr.includes('web-dl')) {
return 1;
}
// Low quality or unknown
return 0;
}
// Download an item (add to Transmission)
async downloadItem(item, transmissionClient) {
if (!transmissionClient) {
console.error('No Transmission client provided for download');
return { success: false, message: 'No Transmission client provided' };
}
try {
// Add the torrent to Transmission
const result = await new Promise((resolve, reject) => {
transmissionClient.addUrl(item.link, (err, result) => {
if (err) {
reject(err);
} else {
resolve(result);
}
});
});
// Mark the item as downloaded
const existingItem = this.feedItems.find(i => i.id === item.id);
if (existingItem) {
existingItem.downloaded = true;
existingItem.downloadDate = new Date().toISOString();
existingItem.transmissionId = result.id || result.hashString || null;
}
// Save updated items
await this.saveItems();
return { success: true, result };
} catch (error) {
console.error(`Error downloading item: ${error.message}`);
return { success: false, message: error.message };
}
}
// Save items to persistent storage
async saveItems() {
try {
// In Node.js environment
const dbPath = path.join(__dirname, 'rss-items.json');
await fs.writeFile(dbPath, JSON.stringify(this.feedItems, null, 2), 'utf8');
return true;
} catch (error) {
console.error('Error saving RSS items:', error);
return false;
}
}
// Load items from persistent storage
async loadItems() {
try {
// In Node.js environment
const dbPath = path.join(__dirname, 'rss-items.json');
try {
const data = await fs.readFile(dbPath, 'utf8');
this.feedItems = JSON.parse(data);
} catch (err) {
if (err.code !== 'ENOENT') {
throw err;
}
// File doesn't exist, use empty array
this.feedItems = [];
}
return true;
} catch (error) {
console.error('Error loading RSS items:', error);
return false;
}
}
// Get all feed items
getAllItems() {
return [...this.feedItems];
}
// Get undownloaded feed items
getUndownloadedItems() {
return this.feedItems.filter(item => !item.downloaded);
}
// Filter items based on criteria
filterItems(filters) {
return this.feedItems.filter(item => this.matchesFilter(item, filters));
}
// Add a new feed
addFeed(feed) {
// Generate an ID if not provided
if (!feed.id) {
feed.id = `feed-${Date.now()}`;
}
// Add the feed to config
this.config.feeds.push(feed);
// Update the feed immediately
this.updateFeed(feed);
return feed;
}
// Remove a feed
removeFeed(feedId) {
const index = this.config.feeds.findIndex(f => f.id === feedId);
if (index !== -1) {
this.config.feeds.splice(index, 1);
return true;
}
return false;
}
// Update feed configuration
updateFeedConfig(feedId, updates) {
const feed = this.config.feeds.find(f => f.id === feedId);
if (feed) {
Object.assign(feed, updates);
return true;
}
return false;
}
// Get all feeds
getAllFeeds() {
return [...this.config.feeds];
}
// Save configuration
async saveConfig() {
try {
// In Node.js environment
const configPath = path.join(__dirname, 'rss-config.json');
await fs.writeFile(configPath, JSON.stringify(this.config, null, 2), 'utf8');
return true;
} catch (error) {
console.error('Error saving RSS config:', error);
return false;
}
}
// Load configuration
async loadConfig() {
try {
// In Node.js environment
const configPath = path.join(__dirname, 'rss-config.json');
try {
const data = await fs.readFile(configPath, 'utf8');
const loadedConfig = JSON.parse(data);
this.config = { ...this.config, ...loadedConfig };
} catch (err) {
if (err.code !== 'ENOENT') {
throw err;
}
// Config file doesn't exist, use defaults
}
return true;
} catch (error) {
console.error('Error loading RSS config:', error);
return false;
}
}
}
// Export for Node.js or browser
if (typeof module !== 'undefined' && module.exports) {
module.exports = RssFeedManager;
} else if (typeof window !== 'undefined') {
window.RssFeedManager = RssFeedManager;
}