523 lines
20 KiB
PHP
523 lines
20 KiB
PHP
<?php
|
|
|
|
class InvalidPodcastException extends Exception {}
|
|
|
|
class PodcastNotFoundException extends Exception {}
|
|
|
|
class Application_Service_PodcastService
|
|
{
|
|
// These fields should never be modified with POST/PUT data
|
|
private static $privateFields = [
|
|
'id',
|
|
'url',
|
|
'type',
|
|
'owner',
|
|
];
|
|
|
|
/**
|
|
* Returns parsed rss feed, or false if the given URL cannot be downloaded.
|
|
*
|
|
* @param string $feedUrl String containing the podcast feed URL
|
|
*
|
|
* @return mixed
|
|
*/
|
|
public static function getPodcastFeed($feedUrl)
|
|
{
|
|
try {
|
|
$feed = new SimplePie();
|
|
$feed->set_feed_url($feedUrl);
|
|
$feed->enable_cache(false);
|
|
$feed->init();
|
|
|
|
return $feed;
|
|
} catch (Exception $e) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/** Creates a Podcast object from the given podcast URL.
|
|
* This is used by our Podcast REST API.
|
|
*
|
|
* @param string $feedUrl Podcast RSS Feed Url
|
|
*
|
|
* @return array Podcast Array with a full list of episodes
|
|
*
|
|
* @throws Exception
|
|
* @throws InvalidPodcastException
|
|
*/
|
|
public static function createFromFeedUrl($feedUrl)
|
|
{
|
|
// TODO: why is this so slow?
|
|
$rss = self::getPodcastFeed($feedUrl);
|
|
if (!$rss) {
|
|
throw new InvalidPodcastException();
|
|
}
|
|
$rssErr = $rss->error();
|
|
if (!empty($rssErr)) {
|
|
throw new InvalidPodcastException($rssErr);
|
|
}
|
|
|
|
// Ensure we are only creating Podcast with the given URL, and excluding
|
|
// any extra data fields that may have been POSTED
|
|
$podcastArray = [];
|
|
$podcastArray['url'] = $feedUrl;
|
|
|
|
$podcastArray['title'] = htmlspecialchars($rss->get_title());
|
|
$podcastArray['description'] = htmlspecialchars($rss->get_description());
|
|
$podcastArray['link'] = htmlspecialchars($rss->get_link());
|
|
$podcastArray['language'] = htmlspecialchars($rss->get_language());
|
|
$podcastArray['copyright'] = htmlspecialchars($rss->get_copyright());
|
|
|
|
$author = $rss->get_author();
|
|
$name = empty($author) ? '' : $author->get_name();
|
|
$podcastArray['creator'] = htmlspecialchars($name);
|
|
|
|
$categories = [];
|
|
if (is_array($rss->get_categories())) {
|
|
foreach ($rss->get_categories() as $category) {
|
|
array_push($categories, $category->get_scheme() . ':' . $category->get_term());
|
|
}
|
|
}
|
|
$podcastArray['category'] = htmlspecialchars(implode('', $categories));
|
|
|
|
// TODO: put in constants
|
|
$itunesChannel = 'http://www.itunes.com/dtds/podcast-1.0.dtd';
|
|
|
|
$itunesSubtitle = $rss->get_channel_tags($itunesChannel, 'subtitle');
|
|
$podcastArray['itunes_subtitle'] = isset($itunesSubtitle[0]['data']) ? $itunesSubtitle[0]['data'] : '';
|
|
|
|
$itunesCategory = $rss->get_channel_tags($itunesChannel, 'category');
|
|
$categoryArray = [];
|
|
if (is_array($itunesCategory)) {
|
|
foreach ($itunesCategory as $c => $data) {
|
|
foreach ($data['attribs'] as $attrib) {
|
|
array_push($categoryArray, $attrib['text']);
|
|
}
|
|
}
|
|
}
|
|
$podcastArray['itunes_category'] = implode(',', $categoryArray);
|
|
|
|
$itunesAuthor = $rss->get_channel_tags($itunesChannel, 'author');
|
|
$podcastArray['itunes_author'] = isset($itunesAuthor[0]['data']) ? $itunesAuthor[0]['data'] : '';
|
|
|
|
$itunesSummary = $rss->get_channel_tags($itunesChannel, 'summary');
|
|
$podcastArray['itunes_summary'] = isset($itunesSummary[0]['data']) ? $itunesSummary[0]['data'] : '';
|
|
|
|
$itunesKeywords = $rss->get_channel_tags($itunesChannel, 'keywords');
|
|
$podcastArray['itunes_keywords'] = isset($itunesKeywords[0]['data']) ? $itunesKeywords[0]['data'] : '';
|
|
|
|
$itunesExplicit = $rss->get_channel_tags($itunesChannel, 'explicit');
|
|
$podcastArray['itunes_explicit'] = isset($itunesExplicit[0]['data']) ? $itunesExplicit[0]['data'] : '';
|
|
|
|
self::validatePodcastMetadata($podcastArray);
|
|
|
|
try {
|
|
// Base class
|
|
$podcast = new Podcast();
|
|
$podcast->fromArray($podcastArray, BasePeer::TYPE_FIELDNAME);
|
|
$podcast->setDbOwner(self::getOwnerId());
|
|
$podcast->save();
|
|
|
|
$importedPodcast = new ImportedPodcast();
|
|
$importedPodcast->fromArray($podcastArray, BasePeer::TYPE_FIELDNAME);
|
|
$importedPodcast->setPodcast($podcast);
|
|
$importedPodcast->setDbAutoIngest(true);
|
|
$importedPodcast->save();
|
|
|
|
// if the autosmartblock and album override are enabled then create a smartblock and playlist matching this podcast via the album name
|
|
if (Application_Model_Preference::GetPodcastAutoSmartblock() && Application_Model_Preference::GetPodcastAlbumOverride()) {
|
|
self::createPodcastSmartblockAndPlaylist($podcast);
|
|
}
|
|
|
|
return $podcast->toArray(BasePeer::TYPE_FIELDNAME);
|
|
} catch (Exception $e) {
|
|
$podcast->delete();
|
|
|
|
throw $e;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param $title passed in directly from web UI input
|
|
* This will automatically create a smartblock and playlist for this podcast
|
|
* @param mixed $podcast
|
|
*/
|
|
public static function createPodcastSmartblockAndPlaylist($podcast, $title = null)
|
|
{
|
|
if (is_array($podcast)) {
|
|
$newpodcast = new Podcast();
|
|
$newpodcast->fromArray($podcast, BasePeer::TYPE_FIELDNAME);
|
|
$podcast = $newpodcast;
|
|
}
|
|
if ($title == null) {
|
|
$title = $podcast->getDbTitle();
|
|
}
|
|
// Base class
|
|
$newBl = new Application_Model_Block();
|
|
$newBl->setCreator(Application_Model_User::getCurrentUser()->getId());
|
|
$newBl->setName($title);
|
|
$newBl->setDescription(_('Auto-generated smartblock for podcast'));
|
|
$newBl->saveType('dynamic');
|
|
// limit the smartblock to 1 item
|
|
$row = new CcBlockcriteria();
|
|
$row->setDbCriteria('limit');
|
|
$row->setDbModifier('items');
|
|
$row->setDbValue(1);
|
|
$row->setDbBlockId($newBl->getId());
|
|
$row->save();
|
|
|
|
// sort so that it is the newest item
|
|
$row = new CcBlockcriteria();
|
|
$row->setDbCriteria('sort');
|
|
$row->setDbModifier('N/A');
|
|
$row->setDbValue('newest');
|
|
$row->setDbBlockId($newBl->getId());
|
|
$row->save();
|
|
|
|
// match the track by ensuring the album title matches the podcast
|
|
$row = new CcBlockcriteria();
|
|
$row->setDbCriteria('album_title');
|
|
$row->setDbModifier('is');
|
|
$row->setDbValue($title);
|
|
$row->setDbBlockId($newBl->getId());
|
|
$row->save();
|
|
|
|
$newPl = new Application_Model_Playlist();
|
|
$newPl->setName($title);
|
|
$newPl->setCreator(Application_Model_User::getCurrentUser()->getId());
|
|
$row = new CcPlaylistcontents();
|
|
$row->setDbBlockId($newBl->getId());
|
|
$row->setDbPlaylistId($newPl->getId());
|
|
$row->setDbType(2);
|
|
$row->save();
|
|
}
|
|
|
|
public static function createStationPodcast()
|
|
{
|
|
$podcast = new Podcast();
|
|
$podcast->setDbUrl(Config::getPublicUrl() . 'feeds/station-rss');
|
|
|
|
$title = Application_Model_Preference::GetStationName();
|
|
$title = empty($title) ? "My Station's Podcast" : $title;
|
|
$podcast->setDbTitle($title);
|
|
|
|
$podcast->setDbDescription(Application_Model_Preference::GetStationDescription());
|
|
$podcast->setDbLink(Config::getPublicUrl());
|
|
$podcast->setDbLanguage(explode('_', Application_Model_Preference::GetLocale())[0]);
|
|
$podcast->setDbCreator(Application_Model_Preference::GetStationName());
|
|
$podcast->setDbOwner(self::getOwnerId());
|
|
$podcast->save();
|
|
|
|
$stationPodcast = new StationPodcast();
|
|
$stationPodcast->setPodcast($podcast);
|
|
$stationPodcast->save();
|
|
|
|
Application_Model_Preference::setStationPodcastId($podcast->getDbId());
|
|
// Set the download key when we create the station podcast
|
|
// The value is randomly generated in the setter
|
|
Application_Model_Preference::setStationPodcastDownloadKey();
|
|
|
|
return $podcast->getDbId();
|
|
}
|
|
|
|
// TODO move this somewhere where it makes sense
|
|
private static function getOwnerId()
|
|
{
|
|
try {
|
|
if (Zend_Auth::getInstance()->hasIdentity()) {
|
|
$service_user = new Application_Service_UserService();
|
|
|
|
return $service_user->getCurrentUser()->getDbId();
|
|
}
|
|
$defaultOwner = CcSubjsQuery::create()
|
|
->filterByDbType('A')
|
|
->orderByDbId()
|
|
->findOne();
|
|
if (!$defaultOwner) {
|
|
// what to do if there is no admin user?
|
|
// should we handle this case?
|
|
return null;
|
|
}
|
|
|
|
return $defaultOwner->getDbId();
|
|
} catch (Exception $e) {
|
|
Logging::info($e->getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Trims the podcast metadata to fit the table's column max size.
|
|
*
|
|
* @param PodcastArray &$podcastArray
|
|
*/
|
|
private static function validatePodcastMetadata(&$podcastArray)
|
|
{
|
|
$podcastTable = PodcastPeer::getTableMap();
|
|
|
|
foreach ($podcastArray as $key => &$value) {
|
|
try {
|
|
// Make sure column exists in table
|
|
$columnMaxSize = $podcastTable->getColumn($key)->getSize();
|
|
} catch (PropelException $e) {
|
|
continue;
|
|
}
|
|
|
|
if (strlen($value) > $columnMaxSize) {
|
|
$value = substr($value, 0, $podcastTable->getColumn($key)->getSize());
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Fetches a Podcast's rss feed and returns all its episodes with
|
|
* the Podcast object.
|
|
*
|
|
* @param mixed $podcastId
|
|
*
|
|
* @return array - Podcast Array with a full list of episodes
|
|
*
|
|
* @throws PodcastNotFoundException
|
|
* @throws InvalidPodcastException
|
|
*/
|
|
public static function getPodcastById($podcastId)
|
|
{
|
|
$podcast = PodcastQuery::create()->findPk($podcastId);
|
|
if (!$podcast) {
|
|
throw new PodcastNotFoundException();
|
|
}
|
|
|
|
$podcast = $podcast->toArray(BasePeer::TYPE_FIELDNAME);
|
|
$podcast['itunes_explicit'] = ($podcast['itunes_explicit'] == 'yes') ? true : false;
|
|
|
|
return $podcast;
|
|
}
|
|
|
|
/**
|
|
* Deletes a Podcast and its podcast episodes.
|
|
*
|
|
* @param mixed $podcastId
|
|
*
|
|
* @throws Exception
|
|
* @throws PodcastNotFoundException
|
|
*/
|
|
public static function deletePodcastById($podcastId)
|
|
{
|
|
$podcast = PodcastQuery::create()->findPk($podcastId);
|
|
if ($podcast) {
|
|
$podcast->delete();
|
|
|
|
// FIXME: I don't think we should be able to delete the station podcast...
|
|
if ($podcastId == Application_Model_Preference::getStationPodcastId()) {
|
|
Application_Model_Preference::setStationPodcastId(null);
|
|
}
|
|
} else {
|
|
throw new PodcastNotFoundException();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Build a response with podcast data and embedded HTML to load on the frontend.
|
|
*
|
|
* @param int $podcastId ID of the podcast to build a response for
|
|
* @param Zend_View_Interface $view Zend view object to render the response HTML
|
|
*
|
|
* @return array the response array containing the podcast data and editor HTML
|
|
*
|
|
* @throws PodcastNotFoundException
|
|
*/
|
|
public static function buildPodcastEditorResponse($podcastId, $view)
|
|
{
|
|
// Check the StationPodcast table rather than checking
|
|
// the station podcast ID key in preferences for extensibility
|
|
$podcast = StationPodcastQuery::create()->findOneByDbPodcastId($podcastId);
|
|
$path = $podcast ? 'podcast/station.phtml' : 'podcast/podcast.phtml';
|
|
$podcast = Application_Service_PodcastService::getPodcastById($podcastId);
|
|
|
|
return [
|
|
'podcast' => json_encode($podcast),
|
|
'html' => $view->render($path),
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Updates a Podcast object with the given metadata.
|
|
*
|
|
* @param mixed $podcastId
|
|
* @param mixed $data
|
|
*
|
|
* @return array
|
|
*
|
|
* @throws Exception
|
|
* @throws PodcastNotFoundException
|
|
*/
|
|
public static function updatePodcastFromArray($podcastId, $data)
|
|
{
|
|
$podcast = PodcastQuery::create()->findPk($podcastId);
|
|
if (!$podcast) {
|
|
throw new PodcastNotFoundException();
|
|
}
|
|
|
|
self::removePrivateFields($data['podcast']);
|
|
self::validatePodcastMetadata($data['podcast']);
|
|
if (array_key_exists('auto_ingest', $data['podcast'])) {
|
|
self::_updateAutoIngestTimestamp($podcast, $data);
|
|
}
|
|
|
|
$data['podcast']['itunes_explicit'] = $data['podcast']['itunes_explicit'] ? 'yes' : 'clean';
|
|
$podcast->fromArray($data['podcast'], BasePeer::TYPE_FIELDNAME);
|
|
$podcast->save();
|
|
|
|
return $podcast->toArray(BasePeer::TYPE_FIELDNAME);
|
|
}
|
|
|
|
/**
|
|
* Update the automatic ingestion timestamp for the given Podcast.
|
|
*
|
|
* @param Podcast $podcast Podcast object to update
|
|
* @param array $data Podcast update data array
|
|
*/
|
|
private static function _updateAutoIngestTimestamp($podcast, $data)
|
|
{
|
|
// Get podcast data with lazy loaded columns since we can't directly call getDbAutoIngest()
|
|
$currData = $podcast->toArray(BasePeer::TYPE_FIELDNAME, true);
|
|
// Add an auto-ingest timestamp when turning auto-ingest on
|
|
if ($data['podcast']['auto_ingest'] == 1 && $currData['auto_ingest'] != 1) {
|
|
$data['podcast']['auto_ingest_timestamp'] = gmdate('r');
|
|
}
|
|
}
|
|
|
|
private static function removePrivateFields(&$data)
|
|
{
|
|
foreach (self::$privateFields as $key) {
|
|
unset($data[$key]);
|
|
}
|
|
}
|
|
|
|
private static function addEscapedChild($node, $name, $value = null, $namespace = null)
|
|
{
|
|
if (empty($value)) {
|
|
return null;
|
|
}
|
|
$child = $node->addChild($name, null, $namespace);
|
|
$child[0] = $value;
|
|
|
|
return $child;
|
|
}
|
|
|
|
public static function createStationRssFeed()
|
|
{
|
|
$stationPodcastId = Application_Model_Preference::getStationPodcastId();
|
|
|
|
try {
|
|
$podcast = PodcastQuery::create()->findPk($stationPodcastId);
|
|
if (!$podcast) {
|
|
throw new PodcastNotFoundException();
|
|
}
|
|
|
|
$xml = new SimpleXMLElement('<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"/>');
|
|
|
|
$channel = $xml->addChild('channel');
|
|
self::addEscapedChild($channel, 'title', $podcast->getDbTitle());
|
|
self::addEscapedChild($channel, 'link', $podcast->getDbLink());
|
|
self::addEscapedChild($channel, 'description', $podcast->getDbDescription());
|
|
self::addEscapedChild($channel, 'language', $podcast->getDbLanguage());
|
|
self::addEscapedChild($channel, 'copyright', $podcast->getDbCopyright());
|
|
|
|
$xml->addAttribute('xmlns:xmlns:atom', 'http://www.w3.org/2005/Atom');
|
|
|
|
$atomLink = $channel->addChild('xmlns:atom:link');
|
|
$atomLink->addAttribute('href', Config::getPublicUrl() . 'feeds/station-rss');
|
|
$atomLink->addAttribute('rel', 'self');
|
|
$atomLink->addAttribute('type', 'application/rss+xml');
|
|
|
|
$imageUrl = Config::getPublicUrl() . 'api/station-logo';
|
|
$image = $channel->addChild('image');
|
|
$image->addChild('title', htmlspecialchars($podcast->getDbTitle()));
|
|
self::addEscapedChild($image, 'url', $imageUrl);
|
|
self::addEscapedChild($image, 'link', Config::getPublicUrl());
|
|
|
|
$xml->addAttribute('xmlns:xmlns:itunes', ITUNES_XML_NAMESPACE_URL);
|
|
self::addEscapedChild($channel, 'xmlns:itunes:author', $podcast->getDbItunesAuthor());
|
|
self::addEscapedChild($channel, 'xmlns:itunes:keywords', $podcast->getDbItunesKeywords());
|
|
self::addEscapedChild($channel, 'xmlns:itunes:summary', $podcast->getDbItunesSummary());
|
|
self::addEscapedChild($channel, 'xmlns:itunes:subtitle', $podcast->getDbItunesSubtitle());
|
|
self::addEscapedChild($channel, 'xmlns:itunes:explicit', $podcast->getDbItunesExplicit());
|
|
$owner = $channel->addChild('xmlns:itunes:owner');
|
|
self::addEscapedChild($owner, 'xmlns:itunes:name', Application_Model_Preference::GetStationName());
|
|
self::addEscapedChild($owner, 'xmlns:itunes:email', Application_Model_Preference::GetEmail());
|
|
|
|
$itunesImage = $channel->addChild('xmlns:itunes:image');
|
|
$itunesImage->addAttribute('href', $imageUrl);
|
|
|
|
// Need to split categories into separate tags
|
|
$itunesCategories = explode(',', $podcast->getDbItunesCategory());
|
|
foreach ($itunesCategories as $c) {
|
|
if (!empty($c)) {
|
|
$category = $channel->addChild('xmlns:itunes:category');
|
|
$category->addAttribute('text', $c);
|
|
}
|
|
}
|
|
|
|
$episodes = PodcastEpisodesQuery::create()->filterByDbPodcastId($stationPodcastId)->find();
|
|
foreach ($episodes as $episode) {
|
|
$item = $channel->addChild('item');
|
|
$publishedFile = CcFilesQuery::create()->findPk($episode->getDbFileId());
|
|
|
|
// title
|
|
self::addEscapedChild($item, 'title', $publishedFile->getDbTrackTitle());
|
|
|
|
// link - do we need this?
|
|
|
|
// pubDate
|
|
self::addEscapedChild($item, 'pubDate', gmdate(DATE_RFC2822, strtotime($episode->getDbPublicationDate())));
|
|
|
|
// category
|
|
foreach ($itunesCategories as $c) {
|
|
if (!empty($c)) {
|
|
self::addEscapedChild($item, 'category', $c);
|
|
}
|
|
}
|
|
|
|
// guid
|
|
$guid = self::addEscapedChild($item, 'guid', $episode->getDbEpisodeGuid());
|
|
$guid->addAttribute('isPermaLink', 'false');
|
|
|
|
// description
|
|
self::addEscapedChild($item, 'description', $publishedFile->getDbDescription());
|
|
|
|
// encolsure - url, length, type attribs
|
|
$enclosure = $item->addChild('enclosure');
|
|
$enclosure->addAttribute('url', $episode->getDbDownloadUrl());
|
|
$enclosure->addAttribute('length', $publishedFile->getDbFilesize());
|
|
$enclosure->addAttribute('type', $publishedFile->getDbMime());
|
|
|
|
// itunes:subtitle
|
|
// From https://www.apple.com/ca/itunes/podcasts/specs.html#subtitle :
|
|
// 'The contents of the <itunes:subtitle> tag are displayed in the Description column in iTunes.'
|
|
// self::addEscapedChild($item, "xmlns:itunes:subtitle", $publishedFile->getDbTrackTitle());
|
|
self::addEscapedChild($item, 'xmlns:itunes:subtitle', $publishedFile->getDbDescription());
|
|
|
|
// itunes:summary
|
|
self::addEscapedChild($item, 'xmlns:itunes:summary', $publishedFile->getDbDescription());
|
|
|
|
// itunes:author
|
|
self::addEscapedChild($item, 'xmlns:itunes:author', $publishedFile->getDbArtistName());
|
|
|
|
// itunes:explicit - skip this?
|
|
|
|
// itunes:duration
|
|
self::addEscapedChild($item, 'xmlns:itunes:duration', explode('.', $publishedFile->getDbLength())[0]);
|
|
}
|
|
|
|
// Format it nicely with newlines...
|
|
$dom = new DOMDocument();
|
|
$dom->loadXML($xml->asXML());
|
|
$dom->formatOutput = true;
|
|
|
|
return $dom->saveXML();
|
|
} catch (FeedException $e) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|