ProcessPodcastSubscriptionsEpisodes.module

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

namespace ProcessWire;

use Lukaswhite\PodcastFeedParser\Artwork;
use Lukaswhite\PodcastFeedParser\Episode;
use Lukaswhite\PodcastFeedParser\Podcast;

/**
 * @method void updateOrCreatePodcastEpisode(Episode $episode, Podcast $podcast, WireData $feed)
 * @method NullPage|Page getPodcastEpisodePageByIdOrCreateNew($episode_id, string $title = '')
 * @method float parseDuration($duration)
 */
class ProcessPodcastSubscriptionsEpisodes extends WireData implements Module, ConfigurableModule
{
	public static function getModuleInfo() {
		return array(
			'title' => 'Process Podcast Create Episode Pages',
			'version' => 104,
			'summary' => 'Example Module for creating podcast episodes pages with ProcessPodcastSubscriptions',
			'icon' => 'clock-o',
			'requires' => ['LazyCron', 'ProcessPodcastSubscriptions'],
			'installs' => 'ProcessPodcastSubscriptions',
			'singular' => true,
			'autoload' => true,
		);
	}

	public function init() {
		$this->addHookBefore('ProcessPodcastSubscriptions::processPodcast', $this, 'hookProcessPodcast');

		$this->episodeParent = $this->pages->get($this->episodeParentId);
		if(!$this->episodeParent->id) $this->episodeParent = $this->pages->get('/');
	}

	/**
	 * @param HookEvent $event
	 * @return void
	 * @throws WireException
	 */
	public function hookProcessPodcast(HookEvent $event) {

		/** @var WireData $feed */
		$feed = $event->arguments(0);

		/** @var Podcast $podcast */
		$podcast = $event->arguments(1);

		// process
		foreach($podcast->getEpisodes() as $episode) $this->updateOrCreatePodcastEpisode($episode, $podcast, $feed);

	}

	/**
	 * @param Episode $episode
	 * @param Podcast $podcast
	 * @param WireData $feed
	 * @return void
	 * @throws WireException
	 */
	public function ___updateOrCreatePodcastEpisode(Episode $episode, Podcast $podcast, WireData $feed) {

		$podcastId = $episode->getGuid();
		if(!$podcastId) return;

		$title = $episode->getTitle();

		/** @var Page $podcastEpisode */
		$podcastEpisode = $this->getPodcastEpisodePageByIdOrCreateNew($podcastId, $title);

		// Set fields
		$podcastEpisode->title = html_entity_decode($episode->getTitle());
		$podcastEpisode->episode_description = html_entity_decode($episode->getDescription());
		$podcastEpisode->episode_duration = $this->parseDuration($episode->getDuration());
		$podcastEpisode->episode_media = $episode->getMedia()->getUri();
		$podcastEpisode->episode_number = $episode->getEpisodeNumber();

		// Add feed
		// this is the linking property
		$podcastEpisode->podcast_feed = $feed->feed_url;

		// Add Artwork
		$artwork = $episode->getArtwork() ?? $podcast->getArtwork();
		if(($artwork instanceof Artwork) && !$podcastEpisode->episode_image->count()) {

			// get Field
			/** @var FieldtypeImage|FieldtypeFile $episodeImage */
			$episodeImage = $podcastEpisode->getField('episode_image');
			$allowedExtensions = explode(' ', $episodeImage->extensions);

			// filename
			// build filename from title or id
			$filename = $podcastEpisode->title;
			if(empty($filename)) $filename = $podcastId;
			$filename = $this->sanitizer->snakeCase(strtolower( $filename ));

			// download file and save in tmp folder
			$imageContent = $this->files->fileGetContents($artwork->getUri());
			$tempDir = $this->files->tempDir();
			$path = $tempDir->get();
			$pathToFile = $path . $filename;
			$tmpFile = $this->files->filePutContents($pathToFile, $imageContent);
			if($tmpFile) {

				// find extension by mime type and check if is allowed in this field
				$internalFileExtensionFromMimeType = strtolower(explode('/', mime_content_type($pathToFile))[1] ?? 'unknown');
				if(
					in_array($internalFileExtensionFromMimeType, $allowedExtensions) &&
					$this->files->rename($pathToFile, $pathToFile . '.' . $internalFileExtensionFromMimeType)
				) {
					$pathToFile = $pathToFile . '.' . $internalFileExtensionFromMimeType;
					$podcastEpisode->episode_image = null;
					$podcastEpisode->episode_image->add($pathToFile);
				}
			}

		}

		// Update published date
		if($podcastEpisode->published !== (int) $episode->getPublishedDate()->format('U')) {
			$mysqlDateTime = $episode->getPublishedDate()->format('Y-m-d H:i:s');
			$podcastEpisode->set('published', $mysqlDateTime);
			$this->database->exec("UPDATE pages SET published='{$mysqlDateTime}', created='{$mysqlDateTime}' WHERE id={$podcastEpisode->id}");
		}

		// Update
		$podcastEpisode->save();
	}

	/**
	 * Find or create and save new media Page
	 * @param $episode_id
	 * @param string $title
	 * @return NullPage|Page
	 * @throws WireException
	 */
	public function ___getPodcastEpisodePageByIdOrCreateNew($episode_id, string $title = '') {
		$podcast_episode = $this->pages->findOne('template=podcast-episode,episode_id=' . $episode_id);

		if(!$podcast_episode->id) {
			$podcast_episode = new Page($this->templates->get('podcast-episode'));
			$podcast_episode
				->set('episode_id', $episode_id)
				->set('title', $title)
				->set('parent', $this->episodeParent)
				;
			$podcast_episode->save(['noHooks' => true]);
		}
		$podcast_episode->of(false);
		return $podcast_episode;
	}

	/**
	 * Parse time to seconds
	 * @param $duration
	 * @return float
	 */
	public function ___parseDuration($duration): float {

		// HH:MM:SS, MM:SS, MMM:SS
		if (preg_match('/\:/', $duration)) {
			$parts = array_reverse(explode(':', $duration));
			$seconds = (float) ($parts[0] ?? .0);
			$minutes = (int) ($parts[1] ?? 0);
			$hours = (int) ($parts[2] ?? 0);
			return ($hours * 60 * 60) + ($minutes * 60) + $seconds;
		}

		// Seconds
		else {
			return floatval($duration);
		}
	}

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

		// Create fields
		$fields = $this->getFieldData();
		$field_names = '';

		foreach ($fields as $field_name => $field_data) {
			try {
				$f = new Field();
				$f->setImportData($field_data);
				$f->save();
				$field_names .= $field_name . " ";
			} catch(\Exception $e) {
				$this->warning($e->getMessage());
				continue;
			}

		}
		$this->message(sprintf($this->_('Created fields: %s'), $field_names));

		// Create Templates
		$templates = $this->getTemplateData();
		$template_names = '';

		foreach ($templates as $template_name => $template_data) {
			try {
				$fg = new Fieldgroup();
				$fg->name = $template_name;
				$template_names .= $template_name . " ";
				foreach ($template_data['fieldgroupFields'] as $fieldname) {
					$fg->add($fieldname);
				}
				$fg->save();
				$t = new Template();
				$t->setImportData($template_data) ;
				$t->save();
			} catch(\Exception $e) {
				$this->warning($e->getMessage());
				continue;
			}

		}
		$this->message(sprintf($this->_('Created template: %s'), $template_names));

		// copy template file in templates folder
		$this->files->copy(
			$this->config->paths->ProcessPodcastSubscriptionsEpisodes . 'templates/',
			$this->config->paths->templates
		);

		$this->message(sprintf($this->_('Created template files: %s'), 'podcast-episode.php'));

	}

	/**
	 * @return void
	 */
	public function uninstall() {
		$this->message(sprintf($this->_('Please delete the template "%1$s" and all field with the prefix "%2$s" by yourself.'), 'podcast-episode', 'episode_'));
	}

	/**
	 * Get field data
	 * @return mixed
	 */
	private function getFieldData() {
		$fields_json = file_get_contents(__DIR__ . "/data/fields.json");
		return json_decode($fields_json, true);
	}

	/**
	 * Get template data
	 * @return mixed
	 */
	private function getTemplateData() {
		$templates_json = file_get_contents(__DIR__ . "/data/templates.json");
		return json_decode($templates_json, true);
	}

}