2021-02-06 12:43:30 +01:00
|
|
|
|
<?php
|
2023-11-16 22:43:00 +01:00
|
|
|
|
declare(strict_types=1);
|
2021-02-06 12:43:30 +01:00
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Provide methods to import files.
|
|
|
|
|
*/
|
|
|
|
|
class FreshRSS_Import_Service {
|
|
|
|
|
|
2023-10-30 20:47:27 +01:00
|
|
|
|
private FreshRSS_CategoryDAO $catDAO;
|
2021-02-06 12:43:30 +01:00
|
|
|
|
|
2023-10-30 20:47:27 +01:00
|
|
|
|
private FreshRSS_FeedDAO $feedDAO;
|
|
|
|
|
|
|
|
|
|
/** true if success, false otherwise */
|
|
|
|
|
private bool $lastStatus;
|
2022-07-04 09:53:26 +02:00
|
|
|
|
|
2021-02-06 12:43:30 +01:00
|
|
|
|
/**
|
|
|
|
|
* Initialize the service for the given user.
|
|
|
|
|
*/
|
2023-04-17 08:30:21 +02:00
|
|
|
|
public function __construct(?string $username = null) {
|
2021-02-06 12:43:30 +01:00
|
|
|
|
$this->catDAO = FreshRSS_Factory::createCategoryDao($username);
|
|
|
|
|
$this->feedDAO = FreshRSS_Factory::createFeedDao($username);
|
|
|
|
|
}
|
|
|
|
|
|
2022-07-04 09:53:26 +02:00
|
|
|
|
/** @return bool true if success, false otherwise */
|
|
|
|
|
public function lastStatus(): bool {
|
|
|
|
|
return $this->lastStatus;
|
|
|
|
|
}
|
|
|
|
|
|
2021-02-06 12:43:30 +01:00
|
|
|
|
/**
|
|
|
|
|
* This method parses and imports an OPML file.
|
|
|
|
|
*
|
|
|
|
|
* @param string $opml_file the OPML file content.
|
2023-01-18 10:12:21 +01:00
|
|
|
|
* @param FreshRSS_Category|null $forced_category force the feeds to be associated to this category.
|
2023-04-17 08:30:21 +02:00
|
|
|
|
* @param bool $dry_run true to not create categories and feeds in database.
|
2021-02-06 12:43:30 +01:00
|
|
|
|
*/
|
2023-04-17 08:30:21 +02:00
|
|
|
|
public function importOpml(string $opml_file, ?FreshRSS_Category $forced_category = null, bool $dry_run = false): void {
|
2023-09-27 21:40:05 +02:00
|
|
|
|
if (function_exists('set_time_limit')) {
|
|
|
|
|
@set_time_limit(300);
|
|
|
|
|
}
|
2022-07-04 09:53:26 +02:00
|
|
|
|
$this->lastStatus = true;
|
2023-07-07 22:36:27 +02:00
|
|
|
|
$opml_array = [];
|
2021-02-06 12:43:30 +01:00
|
|
|
|
try {
|
2023-01-18 10:12:21 +01:00
|
|
|
|
$libopml = new \marienfressinaud\LibOpml\LibOpml(false);
|
|
|
|
|
$opml_array = $libopml->parseString($opml_file);
|
|
|
|
|
} catch (\marienfressinaud\LibOpml\Exception $e) {
|
|
|
|
|
self::log($e->getMessage());
|
2022-07-04 09:53:26 +02:00
|
|
|
|
$this->lastStatus = false;
|
2023-01-18 10:12:21 +01:00
|
|
|
|
return;
|
2021-02-06 12:43:30 +01:00
|
|
|
|
}
|
|
|
|
|
|
2023-01-18 10:12:21 +01:00
|
|
|
|
$this->catDAO->checkDefault();
|
|
|
|
|
$default_category = $this->catDAO->getDefault();
|
2023-12-14 22:11:04 +01:00
|
|
|
|
if ($default_category === null) {
|
2023-01-18 10:12:21 +01:00
|
|
|
|
self::log('Cannot get the default category');
|
|
|
|
|
$this->lastStatus = false;
|
|
|
|
|
return;
|
|
|
|
|
}
|
2021-02-06 12:43:30 +01:00
|
|
|
|
|
2023-01-18 10:12:21 +01:00
|
|
|
|
// Get the categories by names so we can use this array to retrieve
|
|
|
|
|
// existing categories later.
|
2023-04-23 11:58:15 +02:00
|
|
|
|
$categories = $this->catDAO->listCategories(false) ?: [];
|
2023-01-18 10:12:21 +01:00
|
|
|
|
$categories_by_names = [];
|
|
|
|
|
foreach ($categories as $category) {
|
|
|
|
|
$categories_by_names[$category->name()] = $category;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Get current numbers of categories and feeds, and the limits to
|
|
|
|
|
// verify the user can import its categories/feeds.
|
|
|
|
|
$nb_categories = count($categories);
|
2021-02-06 12:43:30 +01:00
|
|
|
|
$nb_feeds = count($this->feedDAO->listFeeds());
|
2023-12-18 17:59:16 +01:00
|
|
|
|
$limits = FreshRSS_Context::systemConf()->limits;
|
2021-02-06 12:43:30 +01:00
|
|
|
|
|
2023-01-18 10:12:21 +01:00
|
|
|
|
// Process the OPML outlines to get a list of categories and a list of
|
|
|
|
|
// feeds elements indexed by their categories names.
|
2023-07-07 22:36:27 +02:00
|
|
|
|
[$categories_elements, $categories_to_feeds] = $this->loadFromOutlines($opml_array['body'], '');
|
2021-02-06 12:43:30 +01:00
|
|
|
|
|
2023-01-18 10:12:21 +01:00
|
|
|
|
foreach ($categories_to_feeds as $category_name => $feeds_elements) {
|
|
|
|
|
$category_element = $categories_elements[$category_name] ?? null;
|
|
|
|
|
|
|
|
|
|
$category = null;
|
|
|
|
|
if ($forced_category) {
|
|
|
|
|
// If the category is forced, ignore the actual category name
|
|
|
|
|
$category = $forced_category;
|
|
|
|
|
} elseif (isset($categories_by_names[$category_name])) {
|
|
|
|
|
// If the category already exists, get it from $categories_by_names
|
|
|
|
|
$category = $categories_by_names[$category_name];
|
|
|
|
|
} elseif ($category_element) {
|
|
|
|
|
// Otherwise, create the category (if possible)
|
|
|
|
|
$limit_reached = $nb_categories >= $limits['max_categories'];
|
|
|
|
|
$can_create_category = FreshRSS_Context::$isCli || !$limit_reached;
|
|
|
|
|
|
|
|
|
|
if ($can_create_category) {
|
|
|
|
|
$category = $this->createCategory($category_element, $dry_run);
|
|
|
|
|
if ($category) {
|
|
|
|
|
$categories_by_names[$category->name()] = $category;
|
|
|
|
|
$nb_categories++;
|
|
|
|
|
}
|
2021-02-06 12:43:30 +01:00
|
|
|
|
} else {
|
2023-01-18 10:12:21 +01:00
|
|
|
|
Minz_Log::warning(
|
|
|
|
|
_t('feedback.sub.category.over_max', $limits['max_categories'])
|
|
|
|
|
);
|
2021-02-06 12:43:30 +01:00
|
|
|
|
}
|
2023-01-18 10:12:21 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!$category) {
|
|
|
|
|
// Category can be null if the feeds weren't in a category
|
|
|
|
|
// outline, or if we weren't able to create the category.
|
|
|
|
|
$category = $default_category;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Then, create the feeds one by one and attach them to the
|
|
|
|
|
// category we just got.
|
|
|
|
|
foreach ($feeds_elements as $feed_element) {
|
|
|
|
|
$limit_reached = $nb_feeds >= $limits['max_feeds'];
|
|
|
|
|
$can_create_feed = FreshRSS_Context::$isCli || !$limit_reached;
|
|
|
|
|
if (!$can_create_feed) {
|
|
|
|
|
Minz_Log::warning(
|
|
|
|
|
_t('feedback.sub.feed.over_max', $limits['max_feeds'])
|
|
|
|
|
);
|
2022-07-04 09:53:26 +02:00
|
|
|
|
$this->lastStatus = false;
|
2023-01-18 10:12:21 +01:00
|
|
|
|
break;
|
2021-02-06 12:43:30 +01:00
|
|
|
|
}
|
|
|
|
|
|
2023-01-18 10:12:21 +01:00
|
|
|
|
if ($this->createFeed($feed_element, $category, $dry_run)) {
|
|
|
|
|
// TODO what if the feed already exists in the database?
|
|
|
|
|
$nb_feeds++;
|
|
|
|
|
} else {
|
|
|
|
|
$this->lastStatus = false;
|
2021-02-06 12:43:30 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
2023-01-18 10:12:21 +01:00
|
|
|
|
* Create a feed from a feed element (i.e. OPML outline).
|
2021-02-06 12:43:30 +01:00
|
|
|
|
*
|
2023-04-17 08:30:21 +02:00
|
|
|
|
* @param array<string,string> $feed_elt An OPML element (must be a feed element).
|
2023-01-18 10:12:21 +01:00
|
|
|
|
* @param FreshRSS_Category $category The category to associate to the feed.
|
2023-04-17 08:30:21 +02:00
|
|
|
|
* @param bool $dry_run true to not create the feed in database.
|
2023-01-18 10:12:21 +01:00
|
|
|
|
* @return FreshRSS_Feed|null The created feed, or null if it failed.
|
2021-02-06 12:43:30 +01:00
|
|
|
|
*/
|
2023-04-17 08:30:21 +02:00
|
|
|
|
private function createFeed(array $feed_elt, FreshRSS_Category $category, bool $dry_run): ?FreshRSS_Feed {
|
2021-02-06 12:43:30 +01:00
|
|
|
|
$url = Minz_Helper::htmlspecialchars_utf8($feed_elt['xmlUrl']);
|
2023-01-18 10:12:21 +01:00
|
|
|
|
$name = $feed_elt['text'] ?? $feed_elt['title'] ?? '';
|
|
|
|
|
$name = Minz_Helper::htmlspecialchars_utf8($name);
|
2022-09-09 22:56:34 +02:00
|
|
|
|
$website = Minz_Helper::htmlspecialchars_utf8($feed_elt['htmlUrl'] ?? '');
|
|
|
|
|
$description = Minz_Helper::htmlspecialchars_utf8($feed_elt['description'] ?? '');
|
2021-02-06 12:43:30 +01:00
|
|
|
|
|
|
|
|
|
try {
|
|
|
|
|
// Create a Feed object and add it in DB
|
|
|
|
|
$feed = new FreshRSS_Feed($url);
|
2023-01-18 10:12:21 +01:00
|
|
|
|
$category->addFeed($feed);
|
2021-02-06 12:43:30 +01:00
|
|
|
|
$feed->_name($name);
|
|
|
|
|
$feed->_website($website);
|
|
|
|
|
$feed->_description($description);
|
|
|
|
|
|
2023-02-09 13:57:20 +01:00
|
|
|
|
switch (strtolower($feed_elt['type'] ?? '')) {
|
2023-01-18 10:12:21 +01:00
|
|
|
|
case strtolower(FreshRSS_Export_Service::TYPE_HTML_XPATH):
|
2022-05-12 22:15:10 +02:00
|
|
|
|
$feed->_kind(FreshRSS_Feed::KIND_HTML_XPATH);
|
|
|
|
|
break;
|
2023-02-09 13:57:20 +01:00
|
|
|
|
case strtolower(FreshRSS_Export_Service::TYPE_XML_XPATH):
|
|
|
|
|
$feed->_kind(FreshRSS_Feed::KIND_XML_XPATH);
|
|
|
|
|
break;
|
2024-04-25 08:28:42 +02:00
|
|
|
|
case strtolower(FreshRSS_Export_Service::TYPE_JSON_DOTNOTATION):
|
2024-01-10 08:23:45 +01:00
|
|
|
|
case strtolower(FreshRSS_Export_Service::TYPE_JSON_DOTPATH):
|
2024-04-25 08:28:42 +02:00
|
|
|
|
$feed->_kind(FreshRSS_Feed::KIND_JSON_DOTNOTATION);
|
2024-01-10 08:23:45 +01:00
|
|
|
|
break;
|
|
|
|
|
case strtolower(FreshRSS_Export_Service::TYPE_JSONFEED):
|
|
|
|
|
$feed->_kind(FreshRSS_Feed::KIND_JSONFEED);
|
|
|
|
|
break;
|
2022-05-12 22:15:10 +02:00
|
|
|
|
default:
|
|
|
|
|
$feed->_kind(FreshRSS_Feed::KIND_RSS);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2023-01-18 10:12:21 +01:00
|
|
|
|
if (isset($feed_elt['frss:cssFullContent'])) {
|
|
|
|
|
$feed->_pathEntries(Minz_Helper::htmlspecialchars_utf8($feed_elt['frss:cssFullContent']));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (isset($feed_elt['frss:cssFullContentFilter'])) {
|
2023-12-18 17:59:16 +01:00
|
|
|
|
$feed->_attribute('path_entries_filter', $feed_elt['frss:cssFullContentFilter']);
|
2023-01-18 10:12:21 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (isset($feed_elt['frss:filtersActionRead'])) {
|
|
|
|
|
$feed->_filtersAction(
|
|
|
|
|
'read',
|
2024-03-31 18:39:43 +02:00
|
|
|
|
preg_split('/\R/u', $feed_elt['frss:filtersActionRead']) ?: []
|
2023-01-18 10:12:21 +01:00
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
|
2022-05-12 22:15:10 +02:00
|
|
|
|
$xPathSettings = [];
|
2023-01-18 10:12:21 +01:00
|
|
|
|
if (isset($feed_elt['frss:xPathItem'])) {
|
|
|
|
|
$xPathSettings['item'] = $feed_elt['frss:xPathItem'];
|
2022-05-12 22:15:10 +02:00
|
|
|
|
}
|
2023-01-18 10:12:21 +01:00
|
|
|
|
if (isset($feed_elt['frss:xPathItemTitle'])) {
|
|
|
|
|
$xPathSettings['itemTitle'] = $feed_elt['frss:xPathItemTitle'];
|
|
|
|
|
}
|
|
|
|
|
if (isset($feed_elt['frss:xPathItemContent'])) {
|
|
|
|
|
$xPathSettings['itemContent'] = $feed_elt['frss:xPathItemContent'];
|
|
|
|
|
}
|
|
|
|
|
if (isset($feed_elt['frss:xPathItemUri'])) {
|
|
|
|
|
$xPathSettings['itemUri'] = $feed_elt['frss:xPathItemUri'];
|
|
|
|
|
}
|
|
|
|
|
if (isset($feed_elt['frss:xPathItemAuthor'])) {
|
|
|
|
|
$xPathSettings['itemAuthor'] = $feed_elt['frss:xPathItemAuthor'];
|
|
|
|
|
}
|
|
|
|
|
if (isset($feed_elt['frss:xPathItemTimestamp'])) {
|
|
|
|
|
$xPathSettings['itemTimestamp'] = $feed_elt['frss:xPathItemTimestamp'];
|
|
|
|
|
}
|
|
|
|
|
if (isset($feed_elt['frss:xPathItemTimeFormat'])) {
|
|
|
|
|
$xPathSettings['itemTimeFormat'] = $feed_elt['frss:xPathItemTimeFormat'];
|
|
|
|
|
}
|
|
|
|
|
if (isset($feed_elt['frss:xPathItemThumbnail'])) {
|
|
|
|
|
$xPathSettings['itemThumbnail'] = $feed_elt['frss:xPathItemThumbnail'];
|
|
|
|
|
}
|
|
|
|
|
if (isset($feed_elt['frss:xPathItemCategories'])) {
|
|
|
|
|
$xPathSettings['itemCategories'] = $feed_elt['frss:xPathItemCategories'];
|
|
|
|
|
}
|
|
|
|
|
if (isset($feed_elt['frss:xPathItemUid'])) {
|
|
|
|
|
$xPathSettings['itemUid'] = $feed_elt['frss:xPathItemUid'];
|
|
|
|
|
}
|
2022-05-12 22:15:10 +02:00
|
|
|
|
if (!empty($xPathSettings)) {
|
2023-12-18 17:59:16 +01:00
|
|
|
|
$feed->_attribute('xpath', $xPathSettings);
|
2022-05-12 22:15:10 +02:00
|
|
|
|
}
|
|
|
|
|
|
2024-01-10 08:23:45 +01:00
|
|
|
|
$jsonSettings = [];
|
|
|
|
|
if (isset($feed_elt['frss:jsonItem'])) {
|
|
|
|
|
$jsonSettings['item'] = $feed_elt['frss:jsonItem'];
|
|
|
|
|
}
|
|
|
|
|
if (isset($feed_elt['frss:jsonItemTitle'])) {
|
|
|
|
|
$jsonSettings['itemTitle'] = $feed_elt['frss:jsonItemTitle'];
|
|
|
|
|
}
|
|
|
|
|
if (isset($feed_elt['frss:jsonItemContent'])) {
|
|
|
|
|
$jsonSettings['itemContent'] = $feed_elt['frss:jsonItemContent'];
|
|
|
|
|
}
|
|
|
|
|
if (isset($feed_elt['frss:jsonItemUri'])) {
|
|
|
|
|
$jsonSettings['itemUri'] = $feed_elt['frss:jsonItemUri'];
|
|
|
|
|
}
|
|
|
|
|
if (isset($feed_elt['frss:jsonItemAuthor'])) {
|
|
|
|
|
$jsonSettings['itemAuthor'] = $feed_elt['frss:jsonItemAuthor'];
|
|
|
|
|
}
|
|
|
|
|
if (isset($feed_elt['frss:jsonItemTimestamp'])) {
|
|
|
|
|
$jsonSettings['itemTimestamp'] = $feed_elt['frss:jsonItemTimestamp'];
|
|
|
|
|
}
|
|
|
|
|
if (isset($feed_elt['frss:jsonItemTimeFormat'])) {
|
|
|
|
|
$jsonSettings['itemTimeFormat'] = $feed_elt['frss:jsonItemTimeFormat'];
|
|
|
|
|
}
|
|
|
|
|
if (isset($feed_elt['frss:jsonItemThumbnail'])) {
|
|
|
|
|
$jsonSettings['itemThumbnail'] = $feed_elt['frss:jsonItemThumbnail'];
|
|
|
|
|
}
|
|
|
|
|
if (isset($feed_elt['frss:jsonItemCategories'])) {
|
|
|
|
|
$jsonSettings['itemCategories'] = $feed_elt['frss:jsonItemCategories'];
|
|
|
|
|
}
|
|
|
|
|
if (isset($feed_elt['frss:jsonItemUid'])) {
|
|
|
|
|
$jsonSettings['itemUid'] = $feed_elt['frss:jsonItemUid'];
|
|
|
|
|
}
|
|
|
|
|
if (!empty($jsonSettings)) {
|
2024-04-25 08:28:42 +02:00
|
|
|
|
$feed->_attribute('json_dotnotation', $jsonSettings);
|
2024-01-10 08:23:45 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
$curl_params = [];
|
|
|
|
|
if (isset($feed_elt['frss:CURLOPT_COOKIE'])) {
|
|
|
|
|
$curl_params[CURLOPT_COOKIE] = $feed_elt['frss:CURLOPT_COOKIE'];
|
|
|
|
|
}
|
|
|
|
|
if (isset($feed_elt['frss:CURLOPT_COOKIEFILE'])) {
|
|
|
|
|
$curl_params[CURLOPT_COOKIEFILE] = $feed_elt['frss:CURLOPT_COOKIEFILE'];
|
|
|
|
|
}
|
|
|
|
|
if (isset($feed_elt['frss:CURLOPT_FOLLOWLOCATION'])) {
|
|
|
|
|
$curl_params[CURLOPT_FOLLOWLOCATION] = (bool)$feed_elt['frss:CURLOPT_FOLLOWLOCATION'];
|
|
|
|
|
}
|
|
|
|
|
if (isset($feed_elt['frss:CURLOPT_HTTPHEADER'])) {
|
2024-03-31 18:39:43 +02:00
|
|
|
|
$curl_params[CURLOPT_HTTPHEADER] = preg_split('/\R/u', $feed_elt['frss:CURLOPT_HTTPHEADER']) ?: [];
|
2024-01-10 08:23:45 +01:00
|
|
|
|
}
|
|
|
|
|
if (isset($feed_elt['frss:CURLOPT_MAXREDIRS'])) {
|
|
|
|
|
$curl_params[CURLOPT_MAXREDIRS] = (int)$feed_elt['frss:CURLOPT_MAXREDIRS'];
|
|
|
|
|
}
|
|
|
|
|
if (isset($feed_elt['frss:CURLOPT_POST'])) {
|
|
|
|
|
$curl_params[CURLOPT_POST] = (bool)$feed_elt['frss:CURLOPT_POST'];
|
|
|
|
|
}
|
|
|
|
|
if (isset($feed_elt['frss:CURLOPT_POSTFIELDS'])) {
|
|
|
|
|
$curl_params[CURLOPT_POSTFIELDS] = $feed_elt['frss:CURLOPT_POSTFIELDS'];
|
|
|
|
|
}
|
|
|
|
|
if (isset($feed_elt['frss:CURLOPT_PROXY'])) {
|
|
|
|
|
$curl_params[CURLOPT_PROXY] = $feed_elt['frss:CURLOPT_PROXY'];
|
|
|
|
|
}
|
|
|
|
|
if (isset($feed_elt['frss:CURLOPT_PROXYTYPE'])) {
|
|
|
|
|
$curl_params[CURLOPT_PROXYTYPE] = $feed_elt['frss:CURLOPT_PROXYTYPE'];
|
|
|
|
|
}
|
|
|
|
|
if (isset($feed_elt['frss:CURLOPT_USERAGENT'])) {
|
|
|
|
|
$curl_params[CURLOPT_USERAGENT] = $feed_elt['frss:CURLOPT_USERAGENT'];
|
|
|
|
|
}
|
|
|
|
|
if (!empty($curl_params)) {
|
|
|
|
|
$feed->_attribute('curl_params', $curl_params);
|
|
|
|
|
}
|
|
|
|
|
|
2021-02-06 12:43:30 +01:00
|
|
|
|
// Call the extension hook
|
2022-07-04 09:53:26 +02:00
|
|
|
|
/** @var FreshRSS_Feed|null */
|
2021-02-06 12:43:30 +01:00
|
|
|
|
$feed = Minz_ExtensionManager::callHook('feed_before_insert', $feed);
|
2023-01-18 10:12:21 +01:00
|
|
|
|
|
|
|
|
|
if ($dry_run) {
|
2022-07-04 09:53:26 +02:00
|
|
|
|
return $feed;
|
|
|
|
|
}
|
2023-01-18 10:12:21 +01:00
|
|
|
|
|
2021-02-06 12:43:30 +01:00
|
|
|
|
if ($feed != null) {
|
2022-07-04 09:53:26 +02:00
|
|
|
|
// addFeedObject checks if feed is already in DB
|
2021-02-06 12:43:30 +01:00
|
|
|
|
$id = $this->feedDAO->addFeedObject($feed);
|
2022-07-04 09:53:26 +02:00
|
|
|
|
if ($id == false) {
|
|
|
|
|
$this->lastStatus = false;
|
|
|
|
|
} else {
|
|
|
|
|
$feed->_id($id);
|
|
|
|
|
return $feed;
|
|
|
|
|
}
|
2021-02-06 12:43:30 +01:00
|
|
|
|
}
|
|
|
|
|
} catch (FreshRSS_Feed_Exception $e) {
|
2023-01-18 10:12:21 +01:00
|
|
|
|
self::log($e->getMessage());
|
2022-07-04 09:53:26 +02:00
|
|
|
|
$this->lastStatus = false;
|
2021-02-06 12:43:30 +01:00
|
|
|
|
}
|
|
|
|
|
|
2023-01-18 10:12:21 +01:00
|
|
|
|
$clean_url = SimplePie_Misc::url_remove_credentials($url);
|
|
|
|
|
self::log("Cannot create {$clean_url} feed in category {$category->name()}");
|
2022-07-04 09:53:26 +02:00
|
|
|
|
return null;
|
2021-02-06 12:43:30 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
2023-01-18 10:12:21 +01:00
|
|
|
|
* Create and return a category.
|
|
|
|
|
*
|
2023-04-17 08:30:21 +02:00
|
|
|
|
* @param array<string,string> $category_element An OPML element (must be a category element).
|
|
|
|
|
* @param bool $dry_run true to not create the category in database.
|
2023-01-18 10:12:21 +01:00
|
|
|
|
* @return FreshRSS_Category|null The created category, or null if it failed.
|
2021-02-06 12:43:30 +01:00
|
|
|
|
*/
|
2023-04-17 08:30:21 +02:00
|
|
|
|
private function createCategory(array $category_element, bool $dry_run): ?FreshRSS_Category {
|
2023-01-18 10:12:21 +01:00
|
|
|
|
$name = $category_element['text'] ?? $category_element['title'] ?? '';
|
|
|
|
|
$name = Minz_Helper::htmlspecialchars_utf8($name);
|
|
|
|
|
$category = new FreshRSS_Category($name);
|
|
|
|
|
|
|
|
|
|
if (isset($category_element['frss:opmlUrl'])) {
|
|
|
|
|
$opml_url = checkUrl($category_element['frss:opmlUrl']);
|
|
|
|
|
if ($opml_url != '') {
|
|
|
|
|
$category->_kind(FreshRSS_Category::KIND_DYNAMIC_OPML);
|
2023-12-18 17:59:16 +01:00
|
|
|
|
$category->_attribute('opml_url', $opml_url);
|
2022-07-04 09:53:26 +02:00
|
|
|
|
}
|
2023-01-18 10:12:21 +01:00
|
|
|
|
}
|
2022-07-04 09:53:26 +02:00
|
|
|
|
|
2023-01-18 10:12:21 +01:00
|
|
|
|
if ($dry_run) {
|
|
|
|
|
return $category;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
$id = $this->catDAO->addCategoryObject($category);
|
|
|
|
|
if ($id !== false) {
|
|
|
|
|
$category->_id($id);
|
|
|
|
|
return $category;
|
|
|
|
|
} else {
|
|
|
|
|
self::log("Cannot create category {$category->name()}");
|
|
|
|
|
$this->lastStatus = false;
|
|
|
|
|
return null;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Return the list of category and feed outlines by categories names.
|
|
|
|
|
*
|
|
|
|
|
* This method is applied to a list of outlines. It merges the different
|
|
|
|
|
* list of feeds from several outlines into one array.
|
|
|
|
|
*
|
2023-04-17 08:30:21 +02:00
|
|
|
|
* @param array<mixed> $outlines
|
2023-01-18 10:12:21 +01:00
|
|
|
|
* The outlines from which to extract the outlines.
|
|
|
|
|
* @param string $parent_category_name
|
|
|
|
|
* The name of the parent category of the current outlines.
|
2023-04-17 08:30:21 +02:00
|
|
|
|
* @return array{0:array<mixed>,1:array<mixed>}
|
2023-01-18 10:12:21 +01:00
|
|
|
|
*/
|
2023-04-17 08:30:21 +02:00
|
|
|
|
private function loadFromOutlines(array $outlines, string $parent_category_name): array {
|
2023-01-18 10:12:21 +01:00
|
|
|
|
$categories_elements = [];
|
|
|
|
|
$categories_to_feeds = [];
|
|
|
|
|
|
|
|
|
|
foreach ($outlines as $outline) {
|
|
|
|
|
// Get the categories and feeds from the child outline (it may
|
|
|
|
|
// return several categories and feeds if the outline is a category).
|
2023-07-07 22:36:27 +02:00
|
|
|
|
[$outline_categories, $outline_categories_to_feeds] = $this->loadFromOutline($outline, $parent_category_name);
|
2023-01-18 10:12:21 +01:00
|
|
|
|
|
|
|
|
|
// Then, we merge the initial arrays with the arrays returned by
|
|
|
|
|
// the outline.
|
|
|
|
|
$categories_elements = array_merge($categories_elements, $outline_categories);
|
|
|
|
|
|
|
|
|
|
foreach ($outline_categories_to_feeds as $category_name => $feeds) {
|
|
|
|
|
if (!isset($categories_to_feeds[$category_name])) {
|
|
|
|
|
$categories_to_feeds[$category_name] = [];
|
2022-07-04 09:53:26 +02:00
|
|
|
|
}
|
2023-01-18 10:12:21 +01:00
|
|
|
|
|
|
|
|
|
$categories_to_feeds[$category_name] = array_merge(
|
|
|
|
|
$categories_to_feeds[$category_name],
|
|
|
|
|
$feeds
|
|
|
|
|
);
|
2022-07-04 09:53:26 +02:00
|
|
|
|
}
|
2023-01-18 10:12:21 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return [$categories_elements, $categories_to_feeds];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Return the list of category and feed outlines by categories names.
|
|
|
|
|
*
|
|
|
|
|
* This method is applied to a specific outline. If the outline represents
|
|
|
|
|
* a category (i.e. @outlines key exists), it will reapply loadFromOutlines()
|
|
|
|
|
* to its children. If the outline represents a feed (i.e. xmlUrl key
|
|
|
|
|
* exists), it will add the outline to an array accessible by its category
|
|
|
|
|
* name.
|
|
|
|
|
*
|
2023-04-17 08:30:21 +02:00
|
|
|
|
* @param array<mixed> $outline
|
2023-01-18 10:12:21 +01:00
|
|
|
|
* The outline from which to extract the categories and feeds outlines.
|
|
|
|
|
* @param string $parent_category_name
|
|
|
|
|
* The name of the parent category of the current outline.
|
|
|
|
|
*
|
2023-04-17 08:30:21 +02:00
|
|
|
|
* @return array{0:array<string,mixed>,1:array<string,mixed>}
|
2023-01-18 10:12:21 +01:00
|
|
|
|
*/
|
2023-04-17 08:30:21 +02:00
|
|
|
|
private function loadFromOutline($outline, $parent_category_name): array {
|
2023-01-18 10:12:21 +01:00
|
|
|
|
$categories_elements = [];
|
|
|
|
|
$categories_to_feeds = [];
|
|
|
|
|
|
|
|
|
|
if ($parent_category_name === '' && isset($outline['category'])) {
|
|
|
|
|
// The outline has no parent category, but its OPML category
|
|
|
|
|
// attribute is set, so we use it as the category name.
|
|
|
|
|
// lib_opml parses this attribute as an array of strings, so we
|
|
|
|
|
// rebuild a string here.
|
|
|
|
|
$parent_category_name = implode(', ', $outline['category']);
|
|
|
|
|
$categories_elements[$parent_category_name] = [
|
|
|
|
|
'text' => $parent_category_name,
|
|
|
|
|
];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (isset($outline['@outlines'])) {
|
2023-05-07 21:35:08 +02:00
|
|
|
|
// The outline has children, it’s probably a category
|
2023-01-18 10:12:21 +01:00
|
|
|
|
if (!empty($outline['text'])) {
|
|
|
|
|
$category_name = $outline['text'];
|
|
|
|
|
} elseif (!empty($outline['title'])) {
|
|
|
|
|
$category_name = $outline['title'];
|
2021-02-06 12:43:30 +01:00
|
|
|
|
} else {
|
2023-01-18 10:12:21 +01:00
|
|
|
|
$category_name = $parent_category_name;
|
2021-02-06 12:43:30 +01:00
|
|
|
|
}
|
2023-01-18 10:12:21 +01:00
|
|
|
|
|
2023-07-07 22:36:27 +02:00
|
|
|
|
[$categories_elements, $categories_to_feeds] = $this->loadFromOutlines($outline['@outlines'], $category_name);
|
2023-01-18 10:12:21 +01:00
|
|
|
|
|
|
|
|
|
unset($outline['@outlines']);
|
|
|
|
|
$categories_elements[$category_name] = $outline;
|
2021-02-06 12:43:30 +01:00
|
|
|
|
}
|
|
|
|
|
|
2023-05-07 21:35:08 +02:00
|
|
|
|
// The xmlUrl means it’s a feed URL: add the outline to the array if it exists.
|
2023-01-18 10:12:21 +01:00
|
|
|
|
if (isset($outline['xmlUrl'])) {
|
|
|
|
|
if (!isset($categories_to_feeds[$parent_category_name])) {
|
|
|
|
|
$categories_to_feeds[$parent_category_name] = [];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
$categories_to_feeds[$parent_category_name][] = $outline;
|
2021-02-06 12:43:30 +01:00
|
|
|
|
}
|
|
|
|
|
|
2023-01-18 10:12:21 +01:00
|
|
|
|
return [$categories_elements, $categories_to_feeds];
|
|
|
|
|
}
|
|
|
|
|
|
2023-04-17 08:30:21 +02:00
|
|
|
|
private static function log(string $message): void {
|
2023-01-18 10:12:21 +01:00
|
|
|
|
if (FreshRSS_Context::$isCli) {
|
|
|
|
|
fwrite(STDERR, "FreshRSS error during OPML import: {$message}\n");
|
|
|
|
|
} else {
|
|
|
|
|
Minz_Log::warning("Error during OPML import: {$message}");
|
|
|
|
|
}
|
2021-02-06 12:43:30 +01:00
|
|
|
|
}
|
|
|
|
|
}
|