ProcessPodcastSubscriptions.module

<?php
/**
* COPYRIGHT NOTICE
* Copyright (c) 2023 Neue Rituale GbR
* @author NR <code@neuerituale.com>
*/

namespace ProcessWire;

use Lukaswhite\PodcastFeedParser\Exceptions\FileNotFoundException;
use Lukaswhite\PodcastFeedParser\Exceptions\InvalidXmlException;
use Lukaswhite\PodcastFeedParser\Parser;
use Lukaswhite\PodcastFeedParser\Podcast;

/**
 * @method void processPodcast(WireData $feed, Podcast $podcast)
 * @method array filterDbFeedInput(string $feedUrl, Podcast $podcast)
 * @method array filterDbFeedUpdate(int $id, Podcast $podcast)
 * @method Parser getFeedParserInstance($args = null)
 */
class ProcessPodcastSubscriptions extends Process implements Module, ConfigurableModule {

	const dbTableName = 'podcast_subscriptions';
	const logFileName = 'podcast-subscriptions';
	const SCHEMA_VERSION = 2;
	private ?WireArray $feedsCache = null;

	public static function getModuleInfo(): array {
		return [
			'title' => 'Process Podcast Subscriptions',
			'version' => 104,
			'summary' => 'Subscribe Podcast RSS feed and save as new page',
			'icon' => 'clock-o',
			'requires' => ['LazyCron'],
			'permission' => 'podcast-subscriptions',
			'singular' => true,
			'autoload' => true,
			'page' => [
				'name' => 'podcast-subscriptions',
				'parent' => 'admin',
				'title' => __('Podcasts'),
			],
		];
	}

	/**
	 * Init
	 * @return void
	 * @throws WireException
	 */
	public function init() {

		// set initial schema version
		if(!$this->schemaVersion) $this->schemaVersion = 1;

		// update the database schema (if not the latest one yet)
		if($this->schemaVersion < self::SCHEMA_VERSION) $this->updateDatabaseSchema();

		// build subscription links array
		$subscriptionLinks = [];
		if(!empty($this->subscriptionLinksConfig)) {
			$links = explode("\n", $this->subscriptionLinksConfig);
			foreach($links as $link) {
				list($name, $label) = array_map('trim', explode('=', $link, 2));
				$subscriptionLinks[$name] = $label;
			}
		}
		$this->subscriptionLinks = $subscriptionLinks;

		// find hookname and init lazy cron hook
		$hookName = $this->timeFuncs[$this->cronSchedule] ?? false;
		if($hookName && $this->modules->isInstalled('LazyCron')) $this->addHook('LazyCron::' . $hookName, $this, 'updateAllFeeds');
	}

	/**
	 * Ready
	 * @return void
	 */
	public function ready() {

		// add css in Backend
		if($this->page->template->name === 'admin')	$this->config->styles->add($this->config->urls->ProcessPodcastSubscriptions . "ProcessPodcastSubscriptions.css");

		// hook field options for field podcast
		if($this->modules->isInstalled('FieldtypeDynamicOptions') && $this->fields->has('podcast')) {
			$this->wire->addHookAfter('FieldtypeDynamicOptions::getSelectableOptions', $this, 'hookPodcastFieldOptions');
		}
	}

	/** VIEWS */

	/**
	 * Show table
	 * @return array|null
	 * @throws WirePermissionException|WireException
	 */
	public function ___execute() : ?array {

		// Add new feed
		if($this->session->CSRF->hasValidToken()) {

			// submit feed
			if($this->input->post('submit')) {
				$feedUrl = $this->input->post('feed_url', 'url');
				try {
					$this->addFeed($feedUrl);
				} catch(\Exception $exception) {
					$this->error($exception->getMessage());
				}
			}

			// update feed info
			elseif($this->input->post('feedmeta')) {

				$feedId = $this->input->post('feedId', 'int');
				$meta = $this->processMetaInput();
				$feed = $this->getFeeds('id='.$feedId)->first();

				if($feed instanceof Feed) $this->updateFeedMeta($feed, $meta);

			}

		}

		return [
			'feeds' => $this->getFeeds(),
			'subscriptionLinks' => $this->subscriptionLinks,
			'meta' => $this->meta
		];

	}

	/**
	 * Manual update
	 * @return void
	 * @throws WireException
	 * @throws FileNotFoundException
	 * @throws InvalidXmlException
	 */
	public function ___executeUpdate() {
		$id = $this->sanitizer->int($this->input->urlSegment2);
		$feed = $this->updateFeed($id);
		$this->message(sprintf($this->_('Podcast "%s" updated'), $feed->title));
		$this->session->redirect($this->page->url);
	}

	/**
	 * Delete Feed
	 * @return void
	 * @throws WireException
	 */
	public function ___executeDelete() {
		$id = $this->sanitizer->int($this->input->urlSegment2);
		if($this->deleteFeed($id)) $this->message($this->_('Podcast deleted'));
		$this->session->redirect($this->page->url);
	}

	/** CONTROL */

	/**
	 * @param string $feedUrl
	 * @return Podcast
	 * @throws WireException
	 * @throws FileNotFoundException
	 * @throws InvalidXmlException
	 */
	public function addFeed(string $feedUrl = '') : Podcast {

		// check url
		if(empty($feedUrl)) throw new \Exception($this->_('Empty feed url'));

		// duplication check
		$checkStatement = $this->database->prepare('SELECT * FROM ' . self::dbTableName . ' WHERE feed_url=:feedUrl');
		$checkStatement->execute(['feedUrl' => $feedUrl]);
		if($checkStatement->fetchColumn(0)) throw new \Exception($this->_('Feed already exists'));

		// check feed
		$podcast = $this->fetchAndParseFeed($feedUrl);
		if(!$podcast) throw new \Exception($this->_('Invalid feed, no type found.'));

		// add to db
		$addStatement = $this->database->prepare('INSERT INTO ' . self::dbTableName . ' (title,description,artwork_url,feed_url,media_count) VALUE (:title,:description,:artwork_url,:feed_url,:media_count)');
		$dbFeedInput = $this->filterDbFeedInput($feedUrl, $podcast);
		$addStatement->execute($dbFeedInput);
		$this->message(sprintf($this->_('Podcast "%s" added'), $dbFeedInput['title']));

		// processPodcast
		$feed = $this->getFeeds('feed_url=' . $feedUrl)->first();
		if($feed) $this->processPodcast($feed, $podcast);

		return $podcast;

	}

	/**
	 * @param int $id
	 * @param bool $flushFeedCache
	 * @return bool|mixed|Wire
	 * @throws WireException
	 * @throws FileNotFoundException
	 * @throws InvalidXmlException
	 */
	public function updateFeed(int $id, bool $flushFeedCache = true) {

		// find feed
		$feed = $this->getFeeds('id=' . $id)->first();
		if(!$feed) throw new \Exception($this->_('Invalid feed id'));
		$podcast = $this->fetchAndParseFeed($feed->feed_url);

		// Update feed in db and the wireData for return
		$updateStatement = $this->database->prepare('UPDATE '.self::dbTableName.' SET title=:title, description=:description, artwork_url=:artwork_url, media_count=:media_count, modified=:modified WHERE id=:id;');
		$dbFeedUpdate = $this->filterDbFeedUpdate($id, $podcast);

		$updateStatement->execute($dbFeedUpdate);
		$feed->setArray($dbFeedUpdate);

		// flush feedcache
		if($flushFeedCache) $this->feedsCache = null;

		// process podcast
		$this->processPodcast($feed, $podcast);

		return $feed;
	}

	/**
	 * Update all feeds
	 * @return $this
	 * @throws WireException
	 * @throws FileNotFoundException
	 * @throws InvalidXmlException
	 */
	public function updateAllFeeds() : ProcessPodcastSubscriptions {

		$feeds = $this->getFeeds('', true);
        foreach($feeds as $feed) {
            try { $this->updateFeed($feed->id, false); }
            catch ( \Exception $exception ) { $this->log('Error:' . $exception->getMessage(), ['name' => self::logFileName]); }
        }

		$this->feedsCache = null;
		return $this;
	}

	/**
	 * @param string $selector
	 * @param bool $fresh
	 * @return WireArray
	 */
	public function getFeeds(string $selector = '', bool $fresh = false) : ?WireArray {

		$result = $this->feedsCache;

		if($fresh || !($result instanceof WireArray)) {
			$result = new WireArray();

			// Get from database
			$statement = $this->database->prepare('SELECT * FROM ' . self::dbTableName);
			$statement->execute();
			$items = $statement->fetchAll(\PDO::FETCH_CLASS, Feed::class);

			if(!is_array($items)) {
				$this->feedsCache = null;
				return $result;
			}

			$result = WireArray::newInstance($items);
			$this->feedsCache = $result;
		}

		return empty($selector) ? $result : $result->find($selector);
	}

	/**
	 * Delete feed by id
	 * @param int $id
	 * @return bool
	 * @throws WireException|\Exception
	 */
	public function deleteFeed(int $id) : bool {
		$feed = $this->getFeeds('id=' . $id)->first();
		if(!$feed) throw new \Exception($this->_('Invalid feed id'));

		$statement = $this->database->prepare('DELETE FROM '.self::dbTableName.' WHERE id=:id');
		$statement->bindValue('id', $feed->id, \PDO::PARAM_INT);
		return $statement->execute();
	}

	/**
	 * @param Feed $feed
	 * @param array $meta
	 * @return Feed
	 */
	public function updateFeedMeta(Feed $feed, array $meta = []): Feed {
		$json = count($meta)
			? json_encode($meta, JSON_UNESCAPED_UNICODE|JSON_UNESCAPED_SLASHES)
			: 'null'
		;

		$updateStatement = $this->database->prepare('UPDATE '.self::dbTableName.' SET meta=:meta WHERE id=:id;');
		$updateStatement->execute([
			'id' => $feed->id,
			'meta' => $json
		]);

		// decode in Feed::class because of same behavior of data
		return $feed->set('meta', $json);
	}

	/**
	 * @param $feedUrl
	 * @return Podcast|null
	 * @throws InvalidXmlException
	 */
	public function fetchAndParseFeed($feedUrl) : ?Podcast {

		$fileContent = $this->files->fileGetContents($feedUrl);
		if(!$fileContent) throw new \Exception(sprintf($this->_("Invalid feed url: %s"), $feedUrl ?: ''));

		libxml_use_internal_errors(true);
		$parser = $this->getFeedParserInstance();
		$parser->setContent($fileContent);
		$podcast = $parser->run();

		return $podcast->getTitle() ? $podcast : null;
	}

	/**
	 * @param WireData $feed
	 * @param Podcast $podcast
	 * @return void
	 */
	public function ___processPodcast(WireData $feed, Podcast $podcast) {
		$this->log('Process podcast done', ['name' => self::logFileName]);
	}

	/** HELPER */

	/**
	 * Filter database input
	 * for hooks
	 *
	 * @param string $feedUrl
	 * @param Podcast $podcast
	 * @return array
	 * @throws WireException
	 */
	public function ___filterDbFeedInput(string $feedUrl, Podcast $podcast) : array {
		return [
			'title' => $this->sanitizer->text(htmlspecialchars_decode($podcast->getTitle())),
			'description' => $this->sanitizer->text(htmlspecialchars_decode($podcast->getDescription()), ['maxLength' => 65535]),
			'artwork_url' => $this->sanitizer->url($podcast->getArtwork()->getUri()),
			'feed_url' => $feedUrl,
			'media_count' => $this->sanitizer->int($podcast->getEpisodes()->count())
		];
	}

	/**
	 * Filter database update
	 * for hooks
	 *
	 * @param int $id
	 * @param Podcast $podcast
	 * @return array
	 * @throws WireException
	 */
	public function ___filterDbFeedUpdate(int $id, Podcast $podcast) : array {
		return [
			'title' => $this->sanitizer->text(htmlspecialchars_decode($podcast->getTitle())),
			'description' => $this->sanitizer->text(htmlspecialchars_decode($podcast->getDescription()), ['maxLength' => 65535]),
			'artwork_url' => $this->sanitizer->url($podcast->getArtwork()->getUri()),
			'media_count' => $this->sanitizer->int($podcast->getEpisodes()->count()),
			'modified' => date('Y-m-d H:i:s'),
			'id' =>$id
		];
	}

	/**
	 * Collect data from input or somewhere else to save as additional metadata to the feed
	 * @return array
	 * @throws WireException
	 */
	public function processMetaInput(): array {

		$meta = [];

		// Subscription links
		$meta['subscriptionLinks'] = [];
		foreach($this->subscriptionLinks as $subscriptionLink => $label) {
			if($url = $this->input->post($subscriptionLink, 'url')) $meta['subscriptionLinks'][$subscriptionLink] = $url;
		}

		// other stuff
		// ...

		return $meta;
	}

	/**
	 * Install
	 * Add field
	 */
	public function install() {

		// Create Database
		wire()->database->exec("
			CREATE TABLE ".self::dbTableName." (
				`id` int(11) NOT NULL,
				`title` tinytext NOT NULL,
				`description` text NOT NULL,
				`artwork_url` text NOT NULL,
				`feed_url` varchar(2000) NOT NULL,
				`media_count` int(11) NOT NULL DEFAULT '0',
				`modified` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
				`created` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP
			);
			ALTER TABLE ".self::dbTableName." ADD PRIMARY KEY (`id`);
			ALTER TABLE ".self::dbTableName." MODIFY `id` int(11) NOT NULL AUTO_INCREMENT;
		");

		// Create process page
		$pageInfo = self::getModuleInfo()['page'];
		$page = new Page($this->templates->get('admin'));
		$page->name = $pageInfo['name'];
		$page->title = $pageInfo['title'];
		$page->parent = $this->pages->get($this->config->adminRootPageID);
		$page->process = $this->className;
		$page->save();
	}

	/**
	 * @return void
	 */
	public function uninstall() {
		try {
			wire()->database->exec('DROP TABLE ' . self::dbTableName);
		} catch(\Exception $exception) {
			$this->error($exception->getMessage());
		}
	}

	/**
	 * Update database schema
	 * @see https://github.com/teppokoivula/ProcessChangelog/
	 * from Teppo Koivula
	 *
	 * This method applies incremental updates until latest schema version is
	 * reached, while also keeping schemaVersion config setting up to date.
	 *
	 * @throws WireException if database schema version isn't recognized
	 */
	public function updateDatabaseSchema() {
		while ($this->schemaVersion < self::SCHEMA_VERSION) {

			// increment; defaults to 1, but in some cases we may be able to skip over a specific schema update
			$increment = 1;

			// first we need to figure out which update we're going to trigger, and whether it's one that can be
			switch ($this->schemaVersion) {
				case 1:
					$sql = [
						"ALTER TABLE `" . self::dbTableName . "` ADD `meta` JSON NOT NULL AFTER `media_count`;",
					];
					break;
				default:
					throw new WireException("Unrecognized database schema version: {$this->schemaVersion}");
			}

			// we're ready to execute this update
			foreach ($sql as $sqlQuery) {
				$schemaUpdated = $this->executeDatabaseSchemaUpdate($sqlQuery);
				if (!$schemaUpdated) {
					break;
				}
			}

			// if update fails: log, show notice (if current user is superuser) and continue
			if (!$schemaUpdated) {
				$message = sprintf(
					$this->_("Running database schema update %d failed"),
					$this->schemaVersion
				);
				$this->log->save(self::logFileName, $message);
				if ($this->user->isSuperuser()) $this->message($message);
				return;
			}

			// all's well that ends well
			$this->schemaVersion += $increment;
			$configData = $this->modules->getModuleConfigData($this);
			$configData['schemaVersion'] = $this->schemaVersion;
			$this->modules->saveModuleConfigData($this, $configData);
			if ($this->user->isSuperuser()) {
				$this->message(sprintf(
					$this->_('ProcessChangelog database schema update applied (#%d).'),
					$this->schemaVersion - 1
				));
			}
		}
	}

	/**
	 * Execute database schema update
	 *
	 * @param string $sql
	 * @return bool
	 */
	protected function executeDatabaseSchemaUpdate(string $sql): bool {
		try {
			$updatedRows = $this->database->exec($sql);
			return $updatedRows !== false;
		} catch (\PDOException $e) {
			if (isset($e->errorInfo[1]) && in_array($e->errorInfo[1], [1060, 1061, 1091])) {
				// 1060 (column already exists), 1061 (duplicate key name), and 1091 (can't drop index) are errors that
				// can be safely ignored here; the most likely issue would be that this update has already been applied
				return true;
			}
			// another type of error; log, show notice (if current user is superuser) and return false
			$message = sprintf(
				'Error updating schema: %s (%s)',
				$e->getMessage(),
				$e->getCode()
			);
			$this->log->save(self::logFileName, $message);
			if ($this->user->isSuperuser()) {
				$this->error($message);
			}
			return false;
		}
	}

	/**
	 * Add all Podcast to dynamic podcast field
	 * @param HookEvent $event
	 * @return void
	 */
	public function hookPodcastFieldOptions(HookEvent $event) {

			// The page being edited
			$page = $event->arguments(0);

			// The Dynamic Options field
			$field = $event->arguments(1);

			if($field->name !== 'podcast') return;

			// Feeds
			$feeds = $this->getFeeds();

			// Add options
			$result = [];
			foreach($feeds as $feed) $result[$feed->id] = $feed->title;
			$event->return = $result;

	}

	/**
	 * Get Parser Instance
	 * @param $args
	 * @return Parser
	 * @throws \Exception
	 */
	public function ___getFeedParserInstance($args = null): Parser {
		$this->loadFeedParserLib();
		return new Parser($args);
	}

	/**
	 * Load PodcastFeedParser Library
	 * @return void
	 * @throws \Exception
	 */
	public function loadFeedParserLib() {
		if(!class_exists("\Lukaswhite\PodcastFeedParser\Parser")) {
			if(!file_exists(__DIR__ . '/vendor/autoload.php')) throw new \Exception("Please install the PodcastFeedParser library via `composer install` in the ProcessPodcastSubscriptions module directory.");
			require_once(/*NoCompile*/__DIR__ . '/vendor/autoload.php');
		}
	}

}

class Feed extends WireData {
	public function set($key, $value) {
		if($key === 'id' || $key === 'media_count') $value = (int) $value;
		elseif($key === 'meta' && is_string($value)) $value = json_decode($value);
		return parent::set($key, $value);
	}
}