<?php
/**
* RSSGenerator class for creating RSS 2.0 XML feeds
* Generates RSS feeds for selected albums with photo metadata
* Includes caching and auto-update functionality
*/
class RSSGenerator
{
/**
* @var mixed
*/
private $dataManager;
/**
* @var mixed
*/
private $baseUrl;
/**
* @var mixed
*/
private $config;
/**
* @var mixed
*/
private $cacheDir;
/**
* @var mixed
*/
private $cacheFile;
/**
* @var mixed
*/
private $cacheLifetime;
/**
* Constructor
* @param DataManager $dataManager Data manager instance
* @param string $baseUrl Base URL for the gallery
*/
public function __construct(DataManager $dataManager, $baseUrl = null)
{
$this->dataManager = $dataManager;
$this->config = $dataManager->getAllConfig();
$this->baseUrl = $baseUrl ?: $this->config['rss_base_url'] ?? 'http://localhost/';
// Ensure base URL ends with slash
$this->baseUrl = rtrim($this->baseUrl, '/').'/';
// Initialize caching
$this->cacheDir = __DIR__.'/../data/cache';
$this->cacheFile = $this->cacheDir.'/rss_feed.xml';
$this->cacheLifetime = 300; // 5 minutes default cache lifetime
// Ensure cache directory exists
if (!is_dir($this->cacheDir)) {
mkdir($this->cacheDir, 0755, true);
}
}
/**
* Generate complete RSS feed XML with caching support
* @param bool $forceRegenerate Force regeneration ignoring cache
* @return string RSS XML content
*/
public function generateFeed($forceRegenerate = false)
{
try {
// Check if cached version exists and is still valid
if (!$forceRegenerate && $this->isCacheValid()) {
return file_get_contents($this->cacheFile);
}
$enabledAlbums = $this->getEnabledAlbums();
$rssItems = [];
// Collect photos from all RSS-enabled albums
foreach ($enabledAlbums as $album) {
$photos = $this->dataManager->getPhotos($album['id']);
foreach ($photos as $photo) {
$rssItems[] = $this->formatPhotoForRSS($photo, $album);
}
}
// Sort items by upload date (newest first)
usort($rssItems, function ($a, $b) {
return strtotime($b['pubDate']) - strtotime($a['pubDate']);
});
// Limit items based on configuration
$maxItems = $this->config['rss_max_items'] ?? 50;
$rssItems = array_slice($rssItems, 0, $maxItems);
// Generate RSS XML
$xml = $this->generateRSSHeader();
foreach ($rssItems as $item) {
$xml .= $this->generateRSSItem($item);
}
$xml .= $this->generateRSSFooter();
// Validate the generated XML
if (!$this->validateRSSXML($xml)) {
throw new Exception('Generated RSS XML is invalid');
}
// Cache the generated feed
$this->cacheRSSFeed($xml);
return $xml;
} catch (Exception $e) {
throw new Exception('Failed to generate RSS feed: '.$e->getMessage());
}
}
/**
* Get albums that are enabled for RSS
* @return array Array of RSS-enabled albums
*/
public function getEnabledAlbums()
{
try {
$allAlbums = $this->dataManager->getAlbums(true);
return array_filter($allAlbums, function ($album) {
return !empty($album['is_rss_enabled']) && $album['photo_count'] > 0;
});
} catch (Exception $e) {
throw new Exception('Failed to get enabled albums: '.$e->getMessage());
}
}
/**
* Format photo data for RSS item
* @param array $photo Photo data
* @param array $album Album data
* @return array RSS item data
*/
private function formatPhotoForRSS($photo, $album)
{
$photoUrl = $this->baseUrl."albums/{$album['id']}/{$photo['filename']}";
$albumUrl = $this->baseUrl."?album={$album['id']}";
// Create enhanced description with photo metadata and direct album link
$description = "<p>Photo from album: <strong><a href=\"{$albumUrl}\">{$album['title']}</a></strong></p>";
if (!empty($album['description'])) {
$description .= "<p><em>{$album['description']}</em></p>";
}
$description .= "<p><img src=\"{$photoUrl}\" alt=\"Photo from {$album['title']}\" style=\"max-width: 100%; height: auto; border-radius: 8px; box-shadow: 0 2px 8px rgba(0,0,0,0.1);\" /></p>";
// Add direct link to view full album
$description .= "<p><a href=\"{$albumUrl}\" style=\"display: inline-block; padding: 8px 16px; background: #3498db; color: white; text-decoration: none; border-radius: 4px; font-weight: 500;\">📸 View Full Album</a></p>";
// Add photo metadata
if (!empty($photo['width']) && !empty($photo['height'])) {
$description .= "<p><small>📐 Dimensions: {$photo['width']} × {$photo['height']} pixels</small></p>";
}
if (!empty($photo['file_size'])) {
$fileSize = $this->formatBytes($photo['file_size']);
$description .= "<p><small>💾 File size: {$fileSize}</small></p>";
}
if (!empty($photo['uploaded_at'])) {
$uploadDate = date('F j, Y g:i A', strtotime($photo['uploaded_at']));
$description .= "<p><small>📅 Uploaded: {$uploadDate}</small></p>";
}
// Create enhanced title with album name
$title = $photo['original_filename'] ?? $photo['filename'];
if (!empty($album['title'])) {
$title .= " | {$album['title']}";
}
return [
'title' => $this->escapeXml($title),
'link' => $this->escapeXml($albumUrl),
'description' => $this->escapeXml($description),
'pubDate' => $this->formatRSSDate($photo['uploaded_at']),
'guid' => $this->escapeXml($photoUrl),
'enclosure' => [
'url' => $this->escapeXml($photoUrl),
'length' => $photo['file_size'] ?? 0,
'type' => 'image/webp'
]
];
}
/**
* Generate RSS header
* @return string RSS header XML
*/
private function generateRSSHeader()
{
$title = $this->escapeXml($this->config['rss_title'] ?? 'Photo Gallery RSS Feed');
$description = $this->escapeXml($this->config['rss_description'] ?? 'Latest photos from selected albums');
$link = $this->escapeXml($this->baseUrl);
$buildDate = $this->formatRSSDate(date('c'));
return '<?xml version="1.0" encoding="UTF-8"?>'."\n".
'<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">'."\n".
'<channel>'."\n".
"<title>{$title}</title>\n".
"<link>{$link}</link>\n".
"<description>{$description}</description>\n".
"<language>en-us</language>\n".
"<lastBuildDate>{$buildDate}</lastBuildDate>\n".
"<generator>Photo Gallery Backend</generator>\n".
"<atom:link href=\"{$link}api.php?action=getRSSFeed\" rel=\"self\" type=\"application/rss+xml\" />\n";
}
/**
* Generate RSS footer
* @return string RSS footer XML
*/
private function generateRSSFooter()
{
return "</channel>\n</rss>\n";
}
/**
* Generate single RSS item
* @param array $item RSS item data
* @return string RSS item XML
*/
private function generateRSSItem($item)
{
$xml = "<item>\n";
$xml .= "<title>{$item['title']}</title>\n";
$xml .= "<link>{$item['link']}</link>\n";
$xml .= "<description><![CDATA[{$item['description']}]]></description>\n";
$xml .= "<pubDate>{$item['pubDate']}</pubDate>\n";
$xml .= "<guid isPermaLink=\"false\">{$item['guid']}</guid>\n";
if (!empty($item['enclosure'])) {
$xml .= "<enclosure url=\"{$item['enclosure']['url']}\" ".
"length=\"{$item['enclosure']['length']}\" ".
"type=\"{$item['enclosure']['type']}\" />\n";
}
$xml .= "</item>\n";
return $xml;
}
/**
* Format date for RSS (RFC 2822 format)
* @param string $date ISO date string
* @return string RFC 2822 formatted date
*/
private function formatRSSDate($date)
{
if (empty($date)) {
return date('r');
}
return date('r', strtotime($date));
}
/**
* Escape XML special characters
* @param string $text Text to escape
* @return string Escaped text
*/
private function escapeXml($text)
{
return htmlspecialchars($text, ENT_XML1 | ENT_COMPAT, 'UTF-8');
}
/**
* Format bytes to human readable format
* @param int $bytes Number of bytes
* @return string Formatted string
*/
private function formatBytes($bytes)
{
if ($bytes == 0) {
return '0 B';
}
$units = ['B', 'KB', 'MB', 'GB'];
$factor = floor(log($bytes, 1024));
return sprintf('%.1f %s', $bytes / pow(1024, $factor), $units[$factor]);
}
/**
* Check if cached RSS feed is still valid
* @return bool True if cache is valid
*/
private function isCacheValid()
{
if (!file_exists($this->cacheFile)) {
return false;
}
$cacheTime = filemtime($this->cacheFile);
$currentTime = time();
// Check if cache has expired
if (($currentTime - $cacheTime) > $this->cacheLifetime) {
return false;
}
// Check if any RSS-enabled albums have been modified since cache was created
$enabledAlbums = $this->getEnabledAlbums();
foreach ($enabledAlbums as $album) {
if (strtotime($album['updated_at']) > $cacheTime) {
return false;
}
}
return true;
}
/**
* Cache the RSS feed content
* @param string $xml RSS XML content
* @return bool Success status
*/
private function cacheRSSFeed($xml)
{
try {
return file_put_contents($this->cacheFile, $xml) !== false;
} catch (Exception $e) {
error_log('Failed to cache RSS feed: '.$e->getMessage());
return false;
}
}
/**
* Validate RSS XML format
* @param string $xml RSS XML content
* @return bool True if valid
*/
private function validateRSSXML($xml)
{
try {
// Enable user error handling
libxml_use_internal_errors(true);
libxml_clear_errors();
// Create DOMDocument and load XML
$dom = new DOMDocument();
$dom->loadXML($xml);
// Check for XML errors
$errors = libxml_get_errors();
if (!empty($errors)) {
error_log('RSS XML validation errors: '.print_r($errors, true));
return false;
}
// Validate RSS structure
$rssElements = $dom->getElementsByTagName('rss');
if ($rssElements->length !== 1) {
error_log('RSS XML validation error: Missing or multiple RSS elements');
return false;
}
$channelElements = $dom->getElementsByTagName('channel');
if ($channelElements->length !== 1) {
error_log('RSS XML validation error: Missing or multiple channel elements');
return false;
}
// Check required channel elements
$requiredElements = ['title', 'link', 'description'];
$channel = $channelElements->item(0);
foreach ($requiredElements as $element) {
$elements = $channel->getElementsByTagName($element);
if ($elements->length === 0) {
error_log("RSS XML validation error: Missing required element: {$element}");
return false;
}
}
return true;
} catch (Exception $e) {
error_log('RSS XML validation exception: '.$e->getMessage());
return false;
} finally {
// Restore error handling
libxml_use_internal_errors(false);
}
}
/**
* Invalidate RSS cache (force regeneration on next request)
* @return bool Success status
*/
public function invalidateCache()
{
if (file_exists($this->cacheFile)) {
return unlink($this->cacheFile);
}
return true;
}
/**
* Trigger RSS feed regeneration (auto-update mechanism)
* Called when photos are added or albums are modified
* @return bool Success status
*/
public function triggerAutoUpdate()
{
try {
// Invalidate cache first
$this->invalidateCache();
// Generate new feed (this will create new cache)
$this->generateFeed(true);
return true;
} catch (Exception $e) {
error_log('RSS auto-update failed: '.$e->getMessage());
return false;
}
}
/**
* Get RSS feed discovery meta tags for HTML head
* @return string HTML meta tags
*/
public function getRSSDiscoveryTags()
{
$rssUrl = $this->baseUrl.'api.php?action=getRSSFeed';
$title = $this->config['rss_title'] ?? 'Photo Gallery RSS Feed';
return '<link rel="alternate" type="application/rss+xml" title="'.
htmlspecialchars($title, ENT_QUOTES, 'UTF-8').
'" href="'.htmlspecialchars($rssUrl, ENT_QUOTES, 'UTF-8').'" />';
}
/**
* Get cache statistics
* @return array Cache information
*/
public function getCacheStats()
{
$stats = [
'cache_exists' => file_exists($this->cacheFile),
'cache_valid' => false,
'cache_size' => 0,
'cache_age' => 0,
'cache_lifetime' => $this->cacheLifetime
];
if ($stats['cache_exists']) {
$stats['cache_size'] = filesize($this->cacheFile);
$stats['cache_age'] = time() - filemtime($this->cacheFile);
$stats['cache_valid'] = $this->isCacheValid();
}
return $stats;
}
}