FressRSS/app/Controllers/feedController.php

<?php

class FreshRSS_feed_Controller extends Minz_ActionController {
	public function firstAction() {
		if (!$this->view->loginOk) {
			// Token is useful in the case that anonymous refresh is forbidden
			// and CRON task cannot be used with php command so the user can
			// set a CRON task to refresh his feeds by using token inside url
			$token = $this->view->conf->token;
			$token_param = Minz_Request::param('token', '');
			$token_is_ok = ($token != '' && $token == $token_param);
			$action = Minz_Request::actionName();
			if (!(($token_is_ok || Minz_Configuration::allowAnonymousRefresh()) &&
				$action === 'actualize')
			) {
				Minz_Error::error(
					403,
					array('error' => array(_t('access_denied')))
				);
			}
		}
	}

	public function addAction() {
		$url = Minz_Request::param('url_rss', false);

		if ($url === false) {
			Minz_Request::forward(array(
				'c' => 'subscription',
				'a' => 'index'
			), true);
		}

		$feedDAO = FreshRSS_Factory::createFeedDao();
		$this->catDAO = new FreshRSS_CategoryDAO();
		$this->catDAO->checkDefault();

		if (Minz_Request::isPost()) {
			@set_time_limit(300);


			$cat = Minz_Request::param('category', false);
			if ($cat === 'nc') {
				$new_cat = Minz_Request::param('new_category');
				if (empty($new_cat['name'])) {
					$cat = false;
				} else {
					$cat = $this->catDAO->addCategory($new_cat);
				}
			}
			if ($cat === false) {
				$def_cat = $this->catDAO->getDefault();
				$cat = $def_cat->id();
			}

			$user = Minz_Request::param('http_user');
			$pass = Minz_Request::param('http_pass');
			$params = array();

			$transactionStarted = false;
			try {
				$feed = new FreshRSS_Feed($url);
				$feed->_category($cat);

				$httpAuth = '';
				if ($user != '' || $pass != '') {
					$httpAuth = $user . ':' . $pass;
				}
				$feed->_httpAuth($httpAuth);

				$feed->load(true);

				$values = array(
					'url' => $feed->url(),
					'category' => $feed->category(),
					'name' => $feed->name(),
					'website' => $feed->website(),
					'description' => $feed->description(),
					'lastUpdate' => time(),
					'httpAuth' => $feed->httpAuth(),
				);

				if ($feedDAO->searchByUrl($values['url'])) {
					// on est déjà abonné à ce flux
					$notif = array(
						'type' => 'bad',
						'content' => _t('already_subscribed', $feed->name())
					);
					Minz_Session::_param('notification', $notif);
				} else {
					$id = $feedDAO->addFeed($values);
					if (!$id) {
						// problème au niveau de la base de données
						$notif = array(
							'type' => 'bad',
							'content' => _t('feed_not_added', $feed->name())
						);
						Minz_Session::_param('notification', $notif);
					} else {
						$feed->_id($id);
						$feed->faviconPrepare();

						$is_read = $this->view->conf->mark_when['reception'] ? 1 : 0;

						$entryDAO = FreshRSS_Factory::createEntryDao();
						$entries = array_reverse($feed->entries());	//We want chronological order and SimplePie uses reverse order

						// on calcule la date des articles les plus anciens qu'on accepte
						$nb_month_old = $this->view->conf->old_entries;
						$date_min = time() - (3600 * 24 * 30 * $nb_month_old);

						//MySQL: http://docs.oracle.com/cd/E17952_01/refman-5.5-en/optimizing-innodb-transaction-management.html
						//SQLite: http://stackoverflow.com/questions/1711631/how-do-i-improve-the-performance-of-sqlite
						$preparedStatement = $entryDAO->addEntryPrepare();
						$transactionStarted = true;
						$feedDAO->beginTransaction();
						// on ajoute les articles en masse sans vérification
						foreach ($entries as $entry) {
							$values = $entry->toArray();
							$values['id_feed'] = $feed->id();
							$values['id'] = min(time(), $entry->date(true)) . uSecString();
							$values['is_read'] = $is_read;
							$entryDAO->addEntry($values, $preparedStatement);
						}
						$feedDAO->updateLastUpdate($feed->id());
						if ($transactionStarted) {
							$feedDAO->commit();
						}
						$transactionStarted = false;

						// ok, ajout terminé
						$notif = array(
							'type' => 'good',
							'content' => _t('feed_added', $feed->name())
						);
						Minz_Session::_param('notification', $notif);

						// permet de rediriger vers la page de conf du flux
						$params['id'] = $feed->id();
					}
				}
			} catch (FreshRSS_BadUrl_Exception $e) {
				Minz_Log::warning($e->getMessage());
				$notif = array(
					'type' => 'bad',
					'content' => _t('invalid_url', $url)
				);
				Minz_Session::_param('notification', $notif);
			} catch (FreshRSS_Feed_Exception $e) {
				Minz_Log::warning($e->getMessage());
				$notif = array(
					'type' => 'bad',
					'content' => _t('internal_problem_feed',
					                Minz_Url::display(array('a' => 'logs')))
				);
				Minz_Session::_param('notification', $notif);
			} catch (Minz_FileNotExistException $e) {
				// Répertoire de cache n'existe pas
				Minz_Log::error($e->getMessage());
				$notif = array(
					'type' => 'bad',
					'content' => _t('internal_problem_feed',
					                Minz_Url::display(array('a' => 'logs')))
				);
				Minz_Session::_param('notification', $notif);
			}
			if ($transactionStarted) {
				$feedDAO->rollBack();
			}

			Minz_Request::forward(array(
				'c' => 'subscription',
				'a' => 'index',
				'params' => $params
			), true);
		} else {

			// GET request so we must ask confirmation to user
			Minz_View::prependTitle(_t('add_rss_feed') . ' · ');
			$this->view->categories = $this->catDAO->listCategories(false);
			$this->view->feed = new FreshRSS_Feed($url);
			try {
				// We try to get some more information about the feed
				$this->view->feed->load(true);
				$this->view->load_ok = true;
			} catch (Exception $e) {
				$this->view->load_ok = false;
			}

			$feed = $feedDAO->searchByUrl($this->view->feed->url());
			if ($feed) {
				// Already subscribe so we redirect to the feed configuration page
				$notif = array(
					'type' => 'bad',
					'content' => _t('already_subscribed', $feed->name())
				);
				Minz_Session::_param('notification', $notif);

				Minz_Request::forward(array(
					'c' => 'subscription',
					'a' => 'index',
					'params' => array(
						'id' => $feed->id()
					)
				), true);
			}
		}
	}

	public function truncateAction() {
		if (Minz_Request::isPost()) {
			$id = Minz_Request::param('id');
			$feedDAO = FreshRSS_Factory::createFeedDao();
			$n = $feedDAO->truncate($id);
			$notif = array(
				'type' => $n === false ? 'bad' : 'good',
				'content' => _t('n_entries_deleted', $n)
			);
			Minz_Session::_param('notification', $notif);
			invalidateHttpCache();
			Minz_Request::forward(array(
				'c' => 'subscription',
				'a' => 'index',
				'params' => array('id' => $id)
			), true);
		}
	}

	public function actualizeAction() {
		@set_time_limit(300);

		$feedDAO = FreshRSS_Factory::createFeedDao();
		$entryDAO = FreshRSS_Factory::createEntryDao();

		Minz_Session::_param('actualize_feeds', false);
		$id = Minz_Request::param('id');
		$force = Minz_Request::param('force', false);

		// on créé la liste des flux à mettre à actualiser
		// si on veut mettre un flux à jour spécifiquement, on le met
		// dans la liste, mais seul (permet d'automatiser le traitement)
		$feeds = array();
		if ($id) {
			$feed = $feedDAO->searchById($id);
			if ($feed) {
				$feeds = array($feed);
			}
		} else {
			$feeds = $feedDAO->listFeedsOrderUpdate($this->view->conf->ttl_default);
		}

		// on calcule la date des articles les plus anciens qu'on accepte
		$nb_month_old = max($this->view->conf->old_entries, 1);
		$date_min = time() - (3600 * 24 * 30 * $nb_month_old);

		$i = 0;
		$flux_update = 0;
		$is_read = $this->view->conf->mark_when['reception'] ? 1 : 0;
		foreach ($feeds as $feed) {
			if (!$feed->lock()) {
				Minz_Log::notice('Feed already being actualized: ' . $feed->url());
				continue;
			}
			try {
				$url = $feed->url();
				$feedHistory = $feed->keepHistory();

				$feed->load(false);
				$entries = array_reverse($feed->entries());	//We want chronological order and SimplePie uses reverse order
				$hasTransaction = false;

				if (count($entries) > 0) {
					//For this feed, check last n entry GUIDs already in database
					$existingGuids = array_fill_keys(
						$entryDAO->listLastGuidsByFeed($feed->id(),
						                               count($entries) + 10), 1);
					$useDeclaredDate = empty($existingGuids);

					if ($feedHistory == -2) {	//default
						$feedHistory = $this->view->conf->keep_history_default;
					}

					$preparedStatement = $entryDAO->addEntryPrepare();
					$hasTransaction = true;
					$feedDAO->beginTransaction();

					// On ne vérifie pas strictement que l'article n'est pas déjà en BDD
					// La BDD refusera l'ajout car (id_feed, guid) doit être unique
					foreach ($entries as $entry) {
						$eDate = $entry->date(true);
						if ((!isset($existingGuids[$entry->guid()])) &&
							(($feedHistory != 0) || ($eDate  >= $date_min))) {
							$values = $entry->toArray();
							//Use declared date at first import, otherwise use discovery date
							$values['id'] = ($useDeclaredDate || $eDate < $date_min) ?
								min(time(), $eDate) . uSecString() :
								uTimeString();
							$values['is_read'] = $is_read;
							$entryDAO->addEntry($values, $preparedStatement);
						}
					}
				}

				if (($feedHistory >= 0) && (rand(0, 30) === 1)) {
					if (!$hasTransaction) {
						$feedDAO->beginTransaction();
					}
					$nb = $feedDAO->cleanOldEntries($feed->id(), $date_min, max($feedHistory, count($entries) + 10));
					if ($nb > 0) {
						Minz_Log::debug($nb . ' old entries cleaned in feed [' . $feed->url() . ']');
					}
				}

				// on indique que le flux vient d'être mis à jour en BDD
				$feedDAO->updateLastUpdate($feed->id(), 0, $hasTransaction);
				if ($hasTransaction) {
					$feedDAO->commit();
				}
				$flux_update++;
				if (($feed->url() !== $url)) {	//HTTP 301 Moved Permanently
					Minz_Log::notice('Feed ' . $url . ' moved permanently to ' . $feed->url());
					$feedDAO->updateFeed($feed->id(), array('url' => $feed->url()));
				}
			} catch (FreshRSS_Feed_Exception $e) {
				Minz_Log::notice($e->getMessage());
				$feedDAO->updateLastUpdate($feed->id(), 1);
			}

			$feed->faviconPrepare();
			$feed->unlock();
			unset($feed);

			// On arrête à 10 flux pour ne pas surcharger le serveur
			// sauf si le paramètre $force est à vrai
			$i++;
			if ($i >= 10 && !$force) {
				break;
			}
		}

		$url = array();
		if ($flux_update === 1) {
			// on a mis un seul flux à jour
			$feed = reset($feeds);
			$notif = array(
				'type' => 'good',
				'content' => _t('feed_actualized', $feed->name())
			);
		} elseif ($flux_update > 1) {
			// plusieurs flux on été mis à jour
			$notif = array(
				'type' => 'good',
				'content' => _t('n_feeds_actualized', $flux_update)
			);
		} else {
			// aucun flux n'a été mis à jour, oups
			$notif = array(
				'type' => 'good',
				'content' => _t('no_feed_to_refresh')
			);
		}

		if ($i === 1) {
			// Si on a voulu mettre à jour qu'un flux
			// on filtre l'affichage par ce flux
			$feed = reset($feeds);
			$url['params'] = array('get' => 'f_' . $feed->id());
		}

		if (Minz_Request::param('ajax', 0) === 0) {
			Minz_Session::_param('notification', $notif);
			Minz_Request::forward($url, true);
		} else {
			// Une requête Ajax met un seul flux à jour.
			// Comme en principe plusieurs requêtes ont lieu,
			// on indique que "plusieurs flux ont été mis à jour".
			// Cela permet d'avoir une notification plus proche du
			// ressenti utilisateur
			$notif = array(
				'type' => 'good',
				'content' => _t('feeds_actualized')
			);
			Minz_Session::_param('notification', $notif);
			// et on désactive le layout car ne sert à rien
			$this->view->_useLayout(false);
		}
	}

	public function moveAction() {
		if (Minz_Request::isPost()) {
			$feed_id = Minz_Request::param('f_id');
			$cat_id = Minz_Request::param('c_id');

			$feedDAO = FreshRSS_Factory::createFeedDao();
			$values = array(
				'category' => $cat_id,
			);

			$feed = $feedDAO->searchById($feed_id);

			if ($feed && ($feed->category() == $cat_id ||
			              $feedDAO->updateFeed($feed_id, $values))) {
				// TODO: return something useful
			} else {
				Minz_Error::error(
					404,
					array('error' => array(_t('error_occurred')))
				);
			}
		}
	}

	public function deleteAction() {
		if (Minz_Request::isPost()) {
			$id = Minz_Request::param('id');
			$feedDAO = FreshRSS_Factory::createFeedDao();

			if ($feedDAO->deleteFeed($id)) {
				// TODO: Delete old favicon

				// Remove related queries
				$this->view->conf->remove_query_by_get('f_' . $id);
				$this->view->conf->save();

				$notif = array(
					'type' => 'good',
					'content' => _t('feed_deleted')
				);
			} else {
				$notif = array(
					'type' => 'bad',
					'content' => _t('error_occured')
				);
			}

			Minz_Session::_param('notification', $notif);

			$redirect_url = Minz_Request::param('r', false, true);
			if ($redirect_url) {
				Minz_Request::forward($redirect_url);
			} else {
				Minz_Request::forward(array('c' => 'subscription', 'a' => 'index'), true);
			}
		}
	}
}