Merge remote-tracking branch 'FreshRSS/master'

15 files changed, 3285 insertions, 1285 deletions

diff --git a/app/Controllers/authController.php b/app/Controllers/authController.php
new file mode 100644
index 000000000..1398e4e49
--- /dev/null
+++ b/app/Controllers/authController.php
@@ -0,0 +1,212 @@
+<?php
+
+/**
+ * This controller handles action about authentication.
+ */
+class FreshRSS_auth_Controller extends Minz_ActionController {
+	/**
+	 * This action handles authentication management page.
+	 *
+	 * Parameters are:
+	 *   - token (default: current token)
+	 *   - anon_access (default: false)
+	 *   - anon_refresh (default: false)
+	 *   - auth_type (default: none)
+	 *   - unsafe_autologin (default: false)
+	 *   - api_enabled (default: false)
+	 *
+	 * @todo move unsafe_autologin in an extension.
+	 */
+	public function indexAction() {
+		if (!FreshRSS_Auth::hasAccess('admin')) {
+			Minz_Error::error(403);
+		}
+
+		Minz_View::prependTitle(_t('admin.auth.title') . ' · ');
+
+		if (Minz_Request::isPost()) {
+			$ok = true;
+
+			$current_token = FreshRSS_Context::$user_conf->token;
+			$token = Minz_Request::param('token', $current_token);
+			FreshRSS_Context::$user_conf->token = $token;
+			$ok &= FreshRSS_Context::$user_conf->save();
+
+			$anon = Minz_Request::param('anon_access', false);
+			$anon = ((bool)$anon) && ($anon !== 'no');
+			$anon_refresh = Minz_Request::param('anon_refresh', false);
+			$anon_refresh = ((bool)$anon_refresh) && ($anon_refresh !== 'no');
+			$auth_type = Minz_Request::param('auth_type', 'none');
+			$unsafe_autologin = Minz_Request::param('unsafe_autologin', false);
+			$api_enabled = Minz_Request::param('api_enabled', false);
+			if ($anon != FreshRSS_Context::$system_conf->allow_anonymous ||
+				$auth_type != FreshRSS_Context::$system_conf->auth_type ||
+				$anon_refresh != FreshRSS_Context::$system_conf->allow_anonymous_refresh ||
+				$unsafe_autologin != FreshRSS_Context::$system_conf->unsafe_autologin_enabled ||
+				$api_enabled != FreshRSS_Context::$system_conf->api_enabled) {
+
+				// TODO: test values from form
+				FreshRSS_Context::$system_conf->auth_type = $auth_type;
+				FreshRSS_Context::$system_conf->allow_anonymous = $anon;
+				FreshRSS_Context::$system_conf->allow_anonymous_refresh = $anon_refresh;
+				FreshRSS_Context::$system_conf->unsafe_autologin_enabled = $unsafe_autologin;
+				FreshRSS_Context::$system_conf->api_enabled = $api_enabled;
+
+				$ok &= FreshRSS_Context::$system_conf->save();
+			}
+
+			invalidateHttpCache();
+
+			if ($ok) {
+				Minz_Request::good(_t('feedback.conf.updated'),
+				                   array('c' => 'auth', 'a' => 'index'));
+			} else {
+				Minz_Request::bad(_t('feedback.conf.error'),
+				                  array('c' => 'auth', 'a' => 'index'));
+			}
+		}
+	}
+
+	/**
+	 * This action handles the login page.
+	 *
+	 * It forwards to the correct login page (form) or main page if
+	 * the user is already connected.
+	 */
+	public function loginAction() {
+		if (FreshRSS_Auth::hasAccess()) {
+			Minz_Request::forward(array('c' => 'index', 'a' => 'index'), true);
+		}
+
+		$auth_type = FreshRSS_Context::$system_conf->auth_type;
+		switch ($auth_type) {
+		case 'form':
+			Minz_Request::forward(array('c' => 'auth', 'a' => 'formLogin'));
+			break;
+		case 'http_auth':
+		case 'none':
+			// It should not happened!
+			Minz_Error::error(404);
+		default:
+			// TODO load plugin instead
+			Minz_Error::error(404);
+		}
+	}
+
+	/**
+	 * This action handles form login page.
+	 *
+	 * If this action is reached through a POST request, username and password
+	 * are compared to login the current user.
+	 *
+	 * Parameters are:
+	 *   - nonce (default: false)
+	 *   - username (default: '')
+	 *   - challenge (default: '')
+	 *   - keep_logged_in (default: false)
+	 *
+	 * @todo move unsafe autologin in an extension.
+	 */
+	public function formLoginAction() {
+		invalidateHttpCache();
+
+		$file_mtime = @filemtime(PUBLIC_PATH . '/scripts/bcrypt.min.js');
+		Minz_View::appendScript(Minz_Url::display('/scripts/bcrypt.min.js?' . $file_mtime));
+
+		$conf = Minz_Configuration::get('system');
+		$limits = $conf->limits;
+		$this->view->cookie_days = round($limits['cookie_duration'] / 86400, 1);
+
+		if (Minz_Request::isPost()) {
+			$nonce = Minz_Session::param('nonce');
+			$username = Minz_Request::param('username', '');
+			$challenge = Minz_Request::param('challenge', '');
+
+			$conf = get_user_configuration($username);
+			if (is_null($conf)) {
+				Minz_Error::error(403, array(_t('feedback.auth.login.invalid')), false);
+				return;
+			}
+
+			$ok = FreshRSS_FormAuth::checkCredentials(
+				$username, $conf->passwordHash, $nonce, $challenge
+			);
+			if ($ok) {
+				// Set session parameter to give access to the user.
+				Minz_Session::_param('currentUser', $username);
+				Minz_Session::_param('passwordHash', $conf->passwordHash);
+				FreshRSS_Auth::giveAccess();
+
+				// Set cookie parameter if nedded.
+				if (Minz_Request::param('keep_logged_in')) {
+					FreshRSS_FormAuth::makeCookie($username, $conf->passwordHash);
+				} else {
+					FreshRSS_FormAuth::deleteCookie();
+				}
+
+				// All is good, go back to the index.
+				Minz_Request::good(_t('feedback.auth.login.success'),
+				                   array('c' => 'index', 'a' => 'index'));
+			} else {
+				Minz_Log::warning('Password mismatch for' .
+				                  ' user=' . $username .
+				                  ', nonce=' . $nonce .
+				                  ', c=' . $challenge);
+				Minz_Error::error(403, array(_t('feedback.auth.login.invalid')), false);
+			}
+		} elseif (FreshRSS_Context::$system_conf->unsafe_autologin_enabled) {
+			$username = Minz_Request::param('u', '');
+			$password = Minz_Request::param('p', '');
+			Minz_Request::_param('p');
+
+			if (!$username) {
+				return;
+			}
+
+			$conf = get_user_configuration($username);
+			if (is_null($conf)) {
+				return;
+			}
+
+			if (!function_exists('password_verify')) {
+				include_once(LIB_PATH . '/password_compat.php');
+			}
+
+			$s = $conf->passwordHash;
+			$ok = password_verify($password, $s);
+			unset($password);
+			if ($ok) {
+				Minz_Session::_param('currentUser', $username);
+				Minz_Session::_param('passwordHash', $s);
+				FreshRSS_Auth::giveAccess();
+
+				Minz_Request::good(_t('feedback.auth.login.success'),
+				                   array('c' => 'index', 'a' => 'index'));
+			} else {
+				Minz_Log::warning('Unsafe password mismatch for user ' . $username);
+				Minz_Error::error(403, array(_t('feedback.auth.login.invalid')), false);
+			}
+		}
+	}
+
+	/**
+	 * This action removes all accesses of the current user.
+	 */
+	public function logoutAction() {
+		invalidateHttpCache();
+		FreshRSS_Auth::removeAccess();
+		Minz_Request::good(_t('feedback.auth.logout.success'),
+		                   array('c' => 'index', 'a' => 'index'));
+	}
+
+	/**
+	 * This action gives possibility to a user to create an account.
+	 */
+	public function registerAction() {
+		if (max_registrations_reached()) {
+			Minz_Error::error(403);
+		}
+
+		Minz_View::prependTitle(_t('gen.auth.registration.title') . ' · ');
+	}
+}
diff --git a/app/Controllers/categoryController.php b/app/Controllers/categoryController.php
new file mode 100644
index 000000000..922f92844
--- /dev/null
+++ b/app/Controllers/categoryController.php
@@ -0,0 +1,193 @@
+<?php
+
+/**
+ * Controller to handle actions relative to categories.
+ * User needs to be connected.
+ */
+class FreshRSS_category_Controller extends Minz_ActionController {
+	/**
+	 * This action is called before every other action in that class. It is
+	 * the common boiler plate for every action. It is triggered by the
+	 * underlying framework.
+	 *
+	 */
+	public function firstAction() {
+		if (!FreshRSS_Auth::hasAccess()) {
+			Minz_Error::error(403);
+		}
+
+		$catDAO = new FreshRSS_CategoryDAO();
+		$catDAO->checkDefault();
+	}
+
+	/**
+	 * This action creates a new category.
+	 *
+	 * Request parameter is:
+	 *   - new-category
+	 */
+	public function createAction() {
+		$catDAO = new FreshRSS_CategoryDAO();
+		$url_redirect = array('c' => 'subscription', 'a' => 'index');
+
+		$limits = FreshRSS_Context::$system_conf->limits;
+		$this->view->categories = $catDAO->listCategories(false);
+
+		if (count($this->view->categories) >= $limits['max_categories']) {
+			Minz_Request::bad(_t('feedback.sub.category.over_max', $limits['max_categories']),
+			                  $url_redirect);
+		}
+
+		if (Minz_Request::isPost()) {
+			invalidateHttpCache();
+
+			$cat_name = Minz_Request::param('new-category');
+			if (!$cat_name) {
+				Minz_Request::bad(_t('feedback.sub.category.no_name'), $url_redirect);
+			}
+
+			$cat = new FreshRSS_Category($cat_name);
+
+			if ($catDAO->searchByName($cat->name()) != null) {
+				Minz_Request::bad(_t('feedback.sub.category.name_exists'), $url_redirect);
+			}
+
+			$values = array(
+				'id' => $cat->id(),
+				'name' => $cat->name(),
+			);
+
+			if ($catDAO->addCategory($values)) {
+				Minz_Request::good(_t('feedback.sub.category.created', $cat->name()), $url_redirect);
+			} else {
+				Minz_Request::bad(_t('feedback.sub.category.error'), $url_redirect);
+			}
+		}
+
+		Minz_Request::forward($url_redirect, true);
+	}
+
+	/**
+	 * This action updates the given category.
+	 *
+	 * Request parameters are:
+	 *   - id
+	 *   - name
+	 */
+	public function updateAction() {
+		$catDAO = new FreshRSS_CategoryDAO();
+		$url_redirect = array('c' => 'subscription', 'a' => 'index');
+
+		if (Minz_Request::isPost()) {
+			invalidateHttpCache();
+
+			$id = Minz_Request::param('id');
+			$name = Minz_Request::param('name', '');
+			if (strlen($name) <= 0) {
+				Minz_Request::bad(_t('feedback.sub.category.no_name'), $url_redirect);
+			}
+
+			if ($catDAO->searchById($id) == null) {
+				Minz_Request::bad(_t('feedback.sub.category.not_exist'), $url_redirect);
+			}
+
+			$cat = new FreshRSS_Category($name);
+			$values = array(
+				'name' => $cat->name(),
+			);
+
+			if ($catDAO->updateCategory($id, $values)) {
+				Minz_Request::good(_t('feedback.sub.category.updated'), $url_redirect);
+			} else {
+				Minz_Request::bad(_t('feedback.sub.category.error'), $url_redirect);
+			}
+		}
+
+		Minz_Request::forward($url_redirect, true);
+	}
+
+	/**
+	 * This action deletes a category.
+	 * Feeds in the given category are moved in the default category.
+	 * Related user queries are deleted too.
+	 *
+	 * Request parameter is:
+	 *   - id (of a category)
+	 */
+	public function deleteAction() {
+		$feedDAO = FreshRSS_Factory::createFeedDao();
+		$catDAO = new FreshRSS_CategoryDAO();
+		$url_redirect = array('c' => 'subscription', 'a' => 'index');
+
+		if (Minz_Request::isPost()) {
+			invalidateHttpCache();
+
+			$id = Minz_Request::param('id');
+			if (!$id) {
+				Minz_Request::bad(_t('feedback.sub.category.no_id'), $url_redirect);
+			}
+
+			if ($id === FreshRSS_CategoryDAO::defaultCategoryId) {
+				Minz_Request::bad(_t('feedback.sub.category.not_delete_default'), $url_redirect);
+			}
+
+			if ($feedDAO->changeCategory($id, FreshRSS_CategoryDAO::defaultCategoryId) === false) {
+				Minz_Request::bad(_t('feedback.sub.category.error'), $url_redirect);
+			}
+
+			if ($catDAO->deleteCategory($id) === false) {
+				Minz_Request::bad(_t('feedback.sub.category.error'), $url_redirect);
+			}
+
+			// Remove related queries.
+			FreshRSS_Context::$user_conf->queries = remove_query_by_get(
+				'c_' . $id, FreshRSS_Context::$user_conf->queries);
+			FreshRSS_Context::$user_conf->save();
+
+			Minz_Request::good(_t('feedback.sub.category.deleted'), $url_redirect);
+		}
+
+		Minz_Request::forward($url_redirect, true);
+	}
+
+	/**
+	 * This action deletes all the feeds relative to a given category.
+	 * Feed-related queries are deleted.
+	 *
+	 * Request parameter is:
+	 *   - id (of a category)
+	 */
+	public function emptyAction() {
+		$feedDAO = FreshRSS_Factory::createFeedDao();
+		$url_redirect = array('c' => 'subscription', 'a' => 'index');
+
+		if (Minz_Request::isPost()) {
+			invalidateHttpCache();
+
+			$id = Minz_Request::param('id');
+			if (!$id) {
+				Minz_Request::bad(_t('feedback.sub.category.no_id'), $url_redirect);
+			}
+
+			// List feeds to remove then related user queries.
+			$feeds = $feedDAO->listByCategory($id);
+
+			if ($feedDAO->deleteFeedByCategory($id)) {
+				// TODO: Delete old favicons
+
+				// Remove related queries
+				foreach ($feeds as $feed) {
+					FreshRSS_Context::$user_conf->queries = remove_query_by_get(
+						'f_' . $feed->id(), FreshRSS_Context::$user_conf->queries);
+				}
+				FreshRSS_Context::$user_conf->save();
+
+				Minz_Request::good(_t('feedback.sub.category.emptied'), $url_redirect);
+			} else {
+				Minz_Request::bad(_t('feedback.sub.category.error'), $url_redirect);
+			}
+		}
+
+		Minz_Request::forward($url_redirect, true);
+	}
+}
diff --git a/app/Controllers/configureController.php b/app/Controllers/configureController.php
index ad8bc546a..e73f106a6 100755
--- a/app/Controllers/configureController.php
+++ b/app/Controllers/configureController.php
@@ -1,354 +1,331 @@
 <?php
 
+/**
+ * Controller to handle every configuration options.
+ */
 class FreshRSS_configure_Controller extends Minz_ActionController {
-	public function firstAction () {
-		if (!$this->view->loginOk) {
-			Minz_Error::error (
-				403,
-				array ('error' => array (Minz_Translate::t ('access_denied')))
-			);
+	/**
+	 * This action is called before every other action in that class. It is
+	 * the common boiler plate for every action. It is triggered by the
+	 * underlying framework.
+	 */
+	public function firstAction() {
+		if (!FreshRSS_Auth::hasAccess()) {
+			Minz_Error::error(403);
 		}
-
-		$catDAO = new FreshRSS_CategoryDAO ();
-		$catDAO->checkDefault ();
 	}
 
-	public function categorizeAction () {
-		$feedDAO = new FreshRSS_FeedDAO ();
-		$catDAO = new FreshRSS_CategoryDAO ();
-		$defaultCategory = $catDAO->getDefault ();
-		$defaultId = $defaultCategory->id ();
-
-		if (Minz_Request::isPost ()) {
-			$cats = Minz_Request::param ('categories', array ());
-			$ids = Minz_Request::param ('ids', array ());
-			$newCat = trim (Minz_Request::param ('new_category', ''));
-
-			foreach ($cats as $key => $name) {
-				if (strlen ($name) > 0) {
-					$cat = new FreshRSS_Category ($name);
-					$values = array (
-						'name' => $cat->name (),
-					);
-					$catDAO->updateCategory ($ids[$key], $values);
-				} elseif ($ids[$key] != $defaultId) {
-					$feedDAO->changeCategory ($ids[$key], $defaultId);
-					$catDAO->deleteCategory ($ids[$key]);
-				}
-			}
-
-			if ($newCat != '') {
-				$cat = new FreshRSS_Category ($newCat);
-				$values = array (
-					'id' => $cat->id (),
-					'name' => $cat->name (),
-				);
-
-				if ($catDAO->searchByName ($newCat) == false) {
-					$catDAO->addCategory ($values);
-				}
-			}
+	/**
+	 * This action handles the display configuration page.
+	 *
+	 * It displays the display configuration page.
+	 * If this action is reached through a POST request, it stores all new
+	 * configuration values then sends a notification to the user.
+	 *
+	 * The options available on the page are:
+	 *   - language (default: en)
+	 *   - theme (default: Origin)
+	 *   - content width (default: thin)
+	 *   - display of read action in header
+	 *   - display of favorite action in header
+	 *   - display of date in header
+	 *   - display of open action in header
+	 *   - display of read action in footer
+	 *   - display of favorite action in footer
+	 *   - display of sharing action in footer
+	 *   - display of tags in footer
+	 *   - display of date in footer
+	 *   - display of open action in footer
+	 *   - html5 notification timeout (default: 0)
+	 * Default values are false unless specified.
+	 */
+	public function displayAction() {
+		if (Minz_Request::isPost()) {
+			FreshRSS_Context::$user_conf->language = Minz_Request::param('language', 'en');
+			FreshRSS_Context::$user_conf->theme = Minz_Request::param('theme', FreshRSS_Themes::$defaultTheme);
+			FreshRSS_Context::$user_conf->content_width = Minz_Request::param('content_width', 'thin');
+			FreshRSS_Context::$user_conf->topline_read = Minz_Request::param('topline_read', false);
+			FreshRSS_Context::$user_conf->topline_favorite = Minz_Request::param('topline_favorite', false);
+			FreshRSS_Context::$user_conf->topline_date = Minz_Request::param('topline_date', false);
+			FreshRSS_Context::$user_conf->topline_link = Minz_Request::param('topline_link', false);
+			FreshRSS_Context::$user_conf->bottomline_read = Minz_Request::param('bottomline_read', false);
+			FreshRSS_Context::$user_conf->bottomline_favorite = Minz_Request::param('bottomline_favorite', false);
+			FreshRSS_Context::$user_conf->bottomline_sharing = Minz_Request::param('bottomline_sharing', false);
+			FreshRSS_Context::$user_conf->bottomline_tags = Minz_Request::param('bottomline_tags', false);
+			FreshRSS_Context::$user_conf->bottomline_date = Minz_Request::param('bottomline_date', false);
+			FreshRSS_Context::$user_conf->bottomline_link = Minz_Request::param('bottomline_link', false);
+			FreshRSS_Context::$user_conf->html5_notif_timeout = Minz_Request::param('html5_notif_timeout', 0);
+			FreshRSS_Context::$user_conf->save();
+
+			Minz_Session::_param('language', FreshRSS_Context::$user_conf->language);
+			Minz_Translate::reset(FreshRSS_Context::$user_conf->language);
 			invalidateHttpCache();
 
-			$notif = array (
-				'type' => 'good',
-				'content' => Minz_Translate::t ('categories_updated')
-			);
-			Minz_Session::_param ('notification', $notif);
-
-			Minz_Request::forward (array ('c' => 'configure', 'a' => 'categorize'), true);
+			Minz_Request::good(_t('feedback.conf.updated'),
+			                   array('c' => 'configure', 'a' => 'display'));
 		}
 
-		$this->view->categories = $catDAO->listCategories (false);
-		$this->view->defaultCategory = $catDAO->getDefault ();
-		$this->view->feeds = $feedDAO->listFeeds ();
-		$this->view->flux = false;
+		$this->view->themes = FreshRSS_Themes::get();
 
-		Minz_View::prependTitle (Minz_Translate::t ('categories_management') . ' · ');
+		Minz_View::prependTitle(_t('conf.display.title') . ' · ');
 	}
 
-	public function feedAction () {
-		$catDAO = new FreshRSS_CategoryDAO ();
-		$this->view->categories = $catDAO->listCategories (false);
-
-		$feedDAO = new FreshRSS_FeedDAO ();
-		$this->view->feeds = $feedDAO->listFeeds ();
-
-		$id = Minz_Request::param ('id');
-		if ($id == false && !empty ($this->view->feeds)) {
-			$id = current ($this->view->feeds)->id ();
-		}
-
-		$this->view->flux = false;
-		if ($id != false) {
-			$this->view->flux = $this->view->feeds[$id];
-
-			if (!$this->view->flux) {
-				Minz_Error::error (
-					404,
-					array ('error' => array (Minz_Translate::t ('page_not_found')))
-				);
-			} else {
-				if (Minz_Request::isPost () && $this->view->flux) {
-					$user = Minz_Request::param ('http_user', '');
-					$pass = Minz_Request::param ('http_pass', '');
-
-					$httpAuth = '';
-					if ($user != '' || $pass != '') {
-						$httpAuth = $user . ':' . $pass;
-					}
-
-					$cat = intval(Minz_Request::param('category', 0));
-
-					$values = array (
-						'name' => Minz_Request::param ('name', ''),
-						'description' => sanitizeHTML(Minz_Request::param('description', '', true)),
-						'website' => Minz_Request::param('website', ''),
-						'url' => Minz_Request::param('url', ''),
-						'category' => $cat,
-						'pathEntries' => Minz_Request::param ('path_entries', ''),
-						'priority' => intval(Minz_Request::param ('priority', 0)),
-						'httpAuth' => $httpAuth,
-						'keep_history' => intval(Minz_Request::param ('keep_history', -2)),
-					);
-
-					if ($feedDAO->updateFeed ($id, $values)) {
-						$this->view->flux->_category ($cat);
-						$this->view->flux->faviconPrepare();
-						$notif = array (
-							'type' => 'good',
-							'content' => Minz_Translate::t ('feed_updated')
-						);
-					} else {
-						$notif = array (
-							'type' => 'bad',
-							'content' => Minz_Translate::t ('error_occurred_update')
-						);
-					}
-					invalidateHttpCache();
-
-					Minz_Session::_param ('notification', $notif);
-					Minz_Request::forward (array ('c' => 'configure', 'a' => 'feed', 'params' => array ('id' => $id)), true);
-				}
-
-				Minz_View::prependTitle (Minz_Translate::t ('rss_feed_management') . ' — ' . $this->view->flux->name () . ' · ');
-			}
-		} else {
-			Minz_View::prependTitle (Minz_Translate::t ('rss_feed_management') . ' · ');
-		}
-	}
-
-	public function displayAction () {
+	/**
+	 * This action handles the reading configuration page.
+	 *
+	 * It displays the reading configuration page.
+	 * If this action is reached through a POST request, it stores all new
+	 * configuration values then sends a notification to the user.
+	 *
+	 * The options available on the page are:
+	 *   - number of posts per page (default: 10)
+	 *   - view mode (default: normal)
+	 *   - default article view (default: all)
+	 *   - load automatically articles
+	 *   - display expanded articles
+	 *   - display expanded categories
+	 *   - hide categories and feeds without unread articles
+	 *   - jump on next category or feed when marked as read
+	 *   - image lazy loading
+	 *   - stick open articles to the top
+	 *   - display a confirmation when reading all articles
+	 *   - auto remove article after reading
+	 *   - article order (default: DESC)
+	 *   - mark articles as read when:
+	 *       - displayed
+	 *       - opened on site
+	 *       - scrolled
+	 *       - received
+	 * Default values are false unless specified.
+	 */
+	public function readingAction() {
 		if (Minz_Request::isPost()) {
-			$this->view->conf->_language(Minz_Request::param('language', 'en'));
-			$this->view->conf->_posts_per_page(Minz_Request::param('posts_per_page', 10));
-			$this->view->conf->_view_mode(Minz_Request::param('view_mode', 'normal'));
-			$this->view->conf->_default_view (Minz_Request::param('default_view', 'a'));
-			$this->view->conf->_auto_load_more(Minz_Request::param('auto_load_more', false));
-			$this->view->conf->_display_posts(Minz_Request::param('display_posts', false));
-			$this->view->conf->_onread_jump_next(Minz_Request::param('onread_jump_next', false));
-			$this->view->conf->_lazyload (Minz_Request::param('lazyload', false));
-			$this->view->conf->_sort_order(Minz_Request::param('sort_order', 'DESC'));
-			$this->view->conf->_mark_when (array(
+			FreshRSS_Context::$user_conf->posts_per_page = Minz_Request::param('posts_per_page', 10);
+			FreshRSS_Context::$user_conf->view_mode = Minz_Request::param('view_mode', 'normal');
+			FreshRSS_Context::$user_conf->default_view = Minz_Request::param('default_view', 'adaptive');
+			FreshRSS_Context::$user_conf->auto_load_more = Minz_Request::param('auto_load_more', false);
+			FreshRSS_Context::$user_conf->display_posts = Minz_Request::param('display_posts', false);
+			FreshRSS_Context::$user_conf->display_categories = Minz_Request::param('display_categories', false);
+			FreshRSS_Context::$user_conf->hide_read_feeds = Minz_Request::param('hide_read_feeds', false);
+			FreshRSS_Context::$user_conf->onread_jump_next = Minz_Request::param('onread_jump_next', false);
+			FreshRSS_Context::$user_conf->lazyload = Minz_Request::param('lazyload', false);
+			FreshRSS_Context::$user_conf->sticky_post = Minz_Request::param('sticky_post', false);
+			FreshRSS_Context::$user_conf->reading_confirm = Minz_Request::param('reading_confirm', false);
+			FreshRSS_Context::$user_conf->auto_remove_article = Minz_Request::param('auto_remove_article', false);
+			FreshRSS_Context::$user_conf->mark_updated_article_unread = Minz_Request::param('mark_updated_article_unread', false);
+			FreshRSS_Context::$user_conf->sort_order = Minz_Request::param('sort_order', 'DESC');
+			FreshRSS_Context::$user_conf->mark_when = array(
 				'article' => Minz_Request::param('mark_open_article', false),
 				'site' => Minz_Request::param('mark_open_site', false),
 				'scroll' => Minz_Request::param('mark_scroll', false),
 				'reception' => Minz_Request::param('mark_upon_reception', false),
-			));
-			$themeId = Minz_Request::param('theme', '');
-			if ($themeId == '') {
-				$themeId = FreshRSS_Themes::defaultTheme;
-			}
-			$this->view->conf->_theme($themeId);
-			$this->view->conf->_topline_read(Minz_Request::param('topline_read', false));
-			$this->view->conf->_topline_favorite(Minz_Request::param('topline_favorite', false));
-			$this->view->conf->_topline_date(Minz_Request::param('topline_date', false));
-			$this->view->conf->_topline_link(Minz_Request::param('topline_link', false));
-			$this->view->conf->_bottomline_read(Minz_Request::param('bottomline_read', false));
-			$this->view->conf->_bottomline_favorite(Minz_Request::param('bottomline_favorite', false));
-			$this->view->conf->_bottomline_sharing(Minz_Request::param('bottomline_sharing', false));
-			$this->view->conf->_bottomline_tags(Minz_Request::param('bottomline_tags', false));
-			$this->view->conf->_bottomline_date(Minz_Request::param('bottomline_date', false));
-			$this->view->conf->_bottomline_link(Minz_Request::param('bottomline_link', false));
-			$this->view->conf->save();
-
-			Minz_Session::_param ('language', $this->view->conf->language);
-			Minz_Translate::reset ();
-			invalidateHttpCache();
-
-			$notif = array (
-				'type' => 'good',
-				'content' => Minz_Translate::t ('configuration_updated')
 			);
-			Minz_Session::_param ('notification', $notif);
+			FreshRSS_Context::$user_conf->save();
+			invalidateHttpCache();
 
-			Minz_Request::forward (array ('c' => 'configure', 'a' => 'display'), true);
+			Minz_Request::good(_t('feedback.conf.updated'),
+			                   array('c' => 'configure', 'a' => 'reading'));
 		}
 
-		$this->view->themes = FreshRSS_Themes::get();
-
-		Minz_View::prependTitle (Minz_Translate::t ('reading_configuration') . ' · ');
+		Minz_View::prependTitle(_t('conf.reading.title') . ' · ');
 	}
 
-	public function sharingAction () {
-		if (Minz_Request::isPost ()) {
-			$this->view->conf->_sharing (array(
-				'shaarli' => Minz_Request::param ('shaarli', false),
-				'wallabag' => Minz_Request::param ('wallabag', false),
-				'diaspora' => Minz_Request::param ('diaspora', false),
-				'twitter' => Minz_Request::param ('twitter', false),
-				'g+' => Minz_Request::param ('g+', false),
-				'facebook' => Minz_Request::param ('facebook', false),
-				'email' => Minz_Request::param ('email', false),
-				'print' => Minz_Request::param ('print', false),
-			));
-			$this->view->conf->save();
+	/**
+	 * This action handles the sharing configuration page.
+	 *
+	 * It displays the sharing configuration page.
+	 * If this action is reached through a POST request, it stores all
+	 * configuration values then sends a notification to the user.
+	 */
+	public function sharingAction() {
+		if (Minz_Request::isPost()) {
+			$params = Minz_Request::fetchPOST();
+			FreshRSS_Context::$user_conf->sharing = $params['share'];
+			FreshRSS_Context::$user_conf->save();
 			invalidateHttpCache();
 
-			$notif = array (
-				'type' => 'good',
-				'content' => Minz_Translate::t ('configuration_updated')
-			);
-			Minz_Session::_param ('notification', $notif);
-
-			Minz_Request::forward (array ('c' => 'configure', 'a' => 'sharing'), true);
+			Minz_Request::good(_t('feedback.conf.updated'),
+			                   array('c' => 'configure', 'a' => 'sharing'));
 		}
 
-		Minz_View::prependTitle (Minz_Translate::t ('sharing') . ' · ');
+		Minz_View::prependTitle(_t('conf.sharing.title') . ' · ');
 	}
 
-	public function importExportAction () {
-		require_once(LIB_PATH . '/lib_opml.php');
-		$catDAO = new FreshRSS_CategoryDAO ();
-		$this->view->categories = $catDAO->listCategories ();
+	/**
+	 * This action handles the shortcut configuration page.
+	 *
+	 * It displays the shortcut configuration page.
+	 * If this action is reached through a POST request, it stores all new
+	 * configuration values then sends a notification to the user.
+	 *
+	 * The authorized values for shortcuts are letters (a to z), numbers (0
+	 * to 9), function keys (f1 to f12), backspace, delete, down, end, enter,
+	 * escape, home, insert, left, page down, page up, return, right, space,
+	 * tab and up.
+	 */
+	public function shortcutAction() {
+		$list_keys = array('a', 'b', 'backspace', 'c', 'd', 'delete', 'down', 'e', 'end', 'enter',
+		                   'escape', 'f', 'g', 'h', 'home', 'i', 'insert', 'j', 'k', 'l', 'left',
+		                   'm', 'n', 'o', 'p', 'page_down', 'page_up', 'q', 'r', 'return', 'right',
+		                   's', 'space', 't', 'tab', 'u', 'up', 'v', 'w', 'x', 'y',
+		                   'z', 'f1', 'f2', 'f3', 'f4', 'f5', 'f6', 'f7', 'f8', 'f9',
+		                   'f10', 'f11', 'f12');
+		$this->view->list_keys = $list_keys;
 
-		$this->view->req = Minz_Request::param ('q');
+		if (Minz_Request::isPost()) {
+			$shortcuts = Minz_Request::param('shortcuts');
+			$shortcuts_ok = array();
+
+			foreach ($shortcuts as $key => $value) {
+				if (in_array($value, $list_keys)) {
+					$shortcuts_ok[$key] = $value;
+				}
+			}
 
-		if ($this->view->req == 'export') {
-			Minz_View::_title ('freshrss_feeds.opml');
+			FreshRSS_Context::$user_conf->shortcuts = $shortcuts_ok;
+			FreshRSS_Context::$user_conf->save();
+			invalidateHttpCache();
 
-			$this->view->_useLayout (false);
-			header('Content-Type: application/xml; charset=utf-8');
-			header('Content-disposition: attachment; filename=freshrss_feeds.opml');
+			Minz_Request::good(_t('feedback.conf.shortcuts_updated'),
+			                   array('c' => 'configure', 'a' => 'shortcut'));
+		}
 
-			$feedDAO = new FreshRSS_FeedDAO ();
-			$catDAO = new FreshRSS_CategoryDAO ();
+		Minz_View::prependTitle(_t('conf.shortcut.title') . ' · ');
+	}
 
-			$list = array ();
-			foreach ($catDAO->listCategories () as $key => $cat) {
-				$list[$key]['name'] = $cat->name ();
-				$list[$key]['feeds'] = $feedDAO->listByCategory ($cat->id ());
-			}
+	/**
+	 * This action handles the archive configuration page.
+	 *
+	 * It displays the archive configuration page.
+	 * If this action is reached through a POST request, it stores all new
+	 * configuration values then sends a notification to the user.
+	 *
+	 * The options available on that page are:
+	 *   - duration to retain old article (default: 3)
+	 *   - number of article to retain per feed (default: 0)
+	 *   - refresh frequency (default: -2)
+	 *
+	 * @todo explain why the default value is -2 but this value does not
+	 *       exist in the drop-down list
+	 */
+	public function archivingAction() {
+		if (Minz_Request::isPost()) {
+			FreshRSS_Context::$user_conf->old_entries = Minz_Request::param('old_entries', 3);
+			FreshRSS_Context::$user_conf->keep_history_default = Minz_Request::param('keep_history_default', 0);
+			FreshRSS_Context::$user_conf->ttl_default = Minz_Request::param('ttl_default', -2);
+			FreshRSS_Context::$user_conf->save();
+			invalidateHttpCache();
 
-			$this->view->categories = $list;
-		} elseif ($this->view->req == 'import' && Minz_Request::isPost ()) {
-			if ($_FILES['file']['error'] == 0) {
-				invalidateHttpCache();
-				// on parse le fichier OPML pour récupérer les catégories et les flux associés
-				try {
-					list ($categories, $feeds) = opml_import (
-						file_get_contents ($_FILES['file']['tmp_name'])
-					);
-
-					// On redirige vers le controller feed qui va se charger d'insérer les flux en BDD
-					// les flux sont mis au préalable dans des variables de Request
-					Minz_Request::_param ('q', 'null');
-					Minz_Request::_param ('categories', $categories);
-					Minz_Request::_param ('feeds', $feeds);
-					Minz_Request::forward (array ('c' => 'feed', 'a' => 'massiveImport'));
-				} catch (FreshRSS_Opml_Exception $e) {
-					Minz_Log::record ($e->getMessage (), Minz_Log::WARNING);
-
-					$notif = array (
-						'type' => 'bad',
-						'content' => Minz_Translate::t ('bad_opml_file')
-					);
-					Minz_Session::_param ('notification', $notif);
-
-					Minz_Request::forward (array (
-						'c' => 'configure',
-						'a' => 'importExport'
-					), true);
-				}
-			}
+			Minz_Request::good(_t('feedback.conf.updated'),
+			                   array('c' => 'configure', 'a' => 'archiving'));
 		}
 
-		$feedDAO = new FreshRSS_FeedDAO ();
-		$this->view->feeds = $feedDAO->listFeeds ();
+		Minz_View::prependTitle(_t('conf.archiving.title') . ' · ');
 
-		// au niveau de la vue, permet de ne pas voir un flux sélectionné dans la liste
-		$this->view->flux = false;
+		$entryDAO = FreshRSS_Factory::createEntryDao();
+		$this->view->nb_total = $entryDAO->count();
+		$this->view->size_user = $entryDAO->size();
 
-		Minz_View::prependTitle (Minz_Translate::t ('import_export_opml') . ' · ');
+		if (FreshRSS_Auth::hasAccess('admin')) {
+			$this->view->size_total = $entryDAO->size(true);
+		}
 	}
 
-	public function shortcutAction () {
-		$list_keys = array ('a', 'b', 'backspace', 'c', 'd', 'delete', 'down', 'e', 'end', 'enter',
-		                    'escape', 'f', 'g', 'h', 'home', 'i', 'insert', 'j', 'k', 'l', 'left',
-		                    'm', 'n', 'o', 'p', 'page_down', 'page_up', 'q', 'r', 'return', 'right',
-		                    's', 'space', 't', 'tab', 'u', 'up', 'v', 'w', 'x', 'y',
-		                    'z', '0', '1', '2', '3', '4', '5', '6', '7', '8',
-		                    '9', 'f1', 'f2', 'f3', 'f4', 'f5', 'f6', 'f7', 'f8', 'f9',
-		                    'f10', 'f11', 'f12');
-		$this->view->list_keys = $list_keys;
-
-		if (Minz_Request::isPost ()) {
-			$shortcuts = Minz_Request::param ('shortcuts');
-			$shortcuts_ok = array ();
+	/**
+	 * This action handles the user queries configuration page.
+	 *
+	 * If this action is reached through a POST request, it stores all new
+	 * configuration values then sends a notification to the user then
+	 * redirect to the same page.
+	 * If this action is not reached through a POST request, it displays the
+	 * configuration page and verifies that every user query is runable by
+	 * checking if categories and feeds are still in use.
+	 */
+	public function queriesAction() {
+		$category_dao = new FreshRSS_CategoryDAO();
+		$feed_dao = FreshRSS_Factory::createFeedDao();
+		if (Minz_Request::isPost()) {
+			$params = Minz_Request::param('queries', array());
 
-			foreach ($shortcuts as $key => $value) {
-				if (in_array($value, $list_keys)) {
-					$shortcuts_ok[$key] = $value;
+			foreach ($params as $key => $query) {
+				if (!$query['name']) {
+					$query['name'] = _t('conf.query.number', $key + 1);
 				}
+				$queries[] = new FreshRSS_UserQuery($query, $feed_dao, $category_dao);
 			}
+			FreshRSS_Context::$user_conf->queries = $queries;
+			FreshRSS_Context::$user_conf->save();
 
-			$this->view->conf->_shortcuts ($shortcuts_ok);
-			$this->view->conf->save();
-			invalidateHttpCache();
+			Minz_Request::good(_t('feedback.conf.updated'),
+			                   array('c' => 'configure', 'a' => 'queries'));
+		} else {
+			$this->view->queries = array();
+			foreach (FreshRSS_Context::$user_conf->queries as $key => $query) {
+				$this->view->queries[$key] = new FreshRSS_UserQuery($query, $feed_dao, $category_dao);
+			}
+		}
 
-			$notif = array (
-				'type' => 'good',
-				'content' => Minz_Translate::t ('shortcuts_updated')
-			);
-			Minz_Session::_param ('notification', $notif);
+		Minz_View::prependTitle(_t('conf.query.title') . ' · ');
+	}
 
-			Minz_Request::forward (array ('c' => 'configure', 'a' => 'shortcut'), true);
+	/**
+	 * This action handles the creation of a user query.
+	 *
+	 * It gets the GET parameters and stores them in the configuration query
+	 * storage. Before it is saved, the unwanted parameters are unset to keep
+	 * lean data.
+	 */
+	public function addQueryAction() {
+		$category_dao = new FreshRSS_CategoryDAO();
+		$feed_dao = FreshRSS_Factory::createFeedDao();
+		$queries = array();
+		foreach (FreshRSS_Context::$user_conf->queries as $key => $query) {
+			$queries[$key] = new FreshRSS_UserQuery($query, $feed_dao, $category_dao);
 		}
+		$params = Minz_Request::fetchGET();
+		$params['url'] = Minz_Url::display(array('params' => $params));
+		$params['name'] = _t('conf.query.number', count($queries) + 1);
+		$queries[] = new FreshRSS_UserQuery($params, $feed_dao, $category_dao);
 
-		Minz_View::prependTitle (Minz_Translate::t ('shortcuts') . ' · ');
-	}
+		FreshRSS_Context::$user_conf->queries = $queries;
+		FreshRSS_Context::$user_conf->save();
 
-	public function usersAction() {
-		Minz_View::prependTitle(Minz_Translate::t ('users') . ' · ');
+		Minz_Request::good(_t('feedback.conf.query_created', $query['name']),
+		                   array('c' => 'configure', 'a' => 'queries'));
 	}
 
-	public function archivingAction () {
+	/**
+	 * This action handles the system configuration page.
+	 *
+	 * It displays the system configuration page.
+	 * If this action is reach through a POST request, it stores all new
+	 * configuration values then sends a notification to the user.
+	 *
+	 * The options available on the page are:
+	 *   - user limit (default: 1)
+	 *   - user category limit (default: 16384)
+	 *   - user feed limit (default: 16384)
+	 */
+	public function systemAction() {
+		if (!FreshRSS_Auth::hasAccess('admin')) {
+			Minz_Error::error(403);
+		}
 		if (Minz_Request::isPost()) {
-			$old = Minz_Request::param('old_entries', 3);
-			$keepHistoryDefault = Minz_Request::param('keep_history_default', 0);
+			$limits = FreshRSS_Context::$system_conf->limits;
+			$limits['max_registrations'] = Minz_Request::param('max-registrations', 1);
+			$limits['max_feeds'] = Minz_Request::param('max-feeds', 16384);
+			$limits['max_categories'] = Minz_Request::param('max-categories', 16384);
+			FreshRSS_Context::$system_conf->limits = $limits;
+			FreshRSS_Context::$system_conf->title = Minz_Request::param('instance-name', 'FreshRSS');
+			FreshRSS_Context::$system_conf->auto_update_url = Minz_Request::param('auto-update-url', false);
+			FreshRSS_Context::$system_conf->save();
 
-			$this->view->conf->_old_entries($old);
-			$this->view->conf->_keep_history_default($keepHistoryDefault);
-			$this->view->conf->save();
 			invalidateHttpCache();
 
-			$notif = array(
+			Minz_Session::_param('notification', array(
 				'type' => 'good',
-				'content' => Minz_Translate::t('configuration_updated')
-			);
-			Minz_Session::_param('notification', $notif);
-
-			Minz_Request::forward(array('c' => 'configure', 'a' => 'archiving'), true);
-		}
-
-		Minz_View::prependTitle(Minz_Translate::t('archiving_configuration') . ' · ');
-
-		$entryDAO = new FreshRSS_EntryDAO();
-		$this->view->nb_total = $entryDAO->count();
-		$this->view->size_user = $entryDAO->size();
-
-		if (Minz_Configuration::isAdmin(Minz_Session::param('currentUser', '_'))) {
-			$this->view->size_total = $entryDAO->size(true);
+				'content' => _t('feedback.conf.updated')
+			));
 		}
 	}
 }
diff --git a/app/Controllers/entryController.php b/app/Controllers/entryController.php
index 1756c91e5..c40588105 100755
--- a/app/Controllers/entryController.php
+++ b/app/Controllers/entryController.php
@@ -1,158 +1,203 @@
 <?php
 
+/**
+ * Controller to handle every entry actions.
+ */
 class FreshRSS_entry_Controller extends Minz_ActionController {
-	public function firstAction () {
-		if (!$this->view->loginOk) {
-			Minz_Error::error (
-				403,
-				array ('error' => array (Minz_Translate::t ('access_denied')))
-			);
+	/**
+	 * This action is called before every other action in that class. It is
+	 * the common boiler plate for every action. It is triggered by the
+	 * underlying framework.
+	 */
+	public function firstAction() {
+		if (!FreshRSS_Auth::hasAccess()) {
+			Minz_Error::error(403);
 		}
 
-		$this->params = array ();
-		$output = Minz_Request::param('output', '');
-		if (($output != '') && ($this->view->conf->view_mode !== $output)) {
-			$this->params['output'] = $output;
-		}
-
-		$this->redirect = false;
-		$ajax = Minz_Request::param ('ajax');
-		if ($ajax) {
-			$this->view->_useLayout (false);
+		// If ajax request, we do not print layout
+		$this->ajax = Minz_Request::param('ajax');
+		if ($this->ajax) {
+			$this->view->_useLayout(false);
+			Minz_Request::_param('ajax');
 		}
 	}
 
-	public function lastAction () {
-		$ajax = Minz_Request::param ('ajax');
-		if (!$ajax && $this->redirect) {
-			Minz_Request::forward (array (
-				'c' => 'index',
-				'a' => 'index',
-				'params' => $this->params
-			), true);
+	/**
+	 * Mark one or several entries as read (or not!).
+	 *
+	 * If request concerns several entries, it MUST be a POST request.
+	 * If request concerns several entries, only mark them as read is available.
+	 *
+	 * Parameters are:
+	 *   - id (default: false)
+	 *   - get (default: false) /(c_\d+|f_\d+|s|a)/
+	 *   - nextGet (default: $get)
+	 *   - idMax (default: 0)
+	 *   - is_read (default: true)
+	 */
+	public function readAction() {
+		$id = Minz_Request::param('id');
+		$get = Minz_Request::param('get');
+		$next_get = Minz_Request::param('nextGet', $get);
+		$id_max = Minz_Request::param('idMax', 0);
+		FreshRSS_Context::$search = new FreshRSS_Search(Minz_Request::param('search', ''));
+
+		FreshRSS_Context::$state = Minz_Request::param('state', 0);
+		if (FreshRSS_Context::isStateEnabled(FreshRSS_Entry::STATE_FAVORITE)) {
+			FreshRSS_Context::$state = FreshRSS_Entry::STATE_FAVORITE;
+		} elseif (FreshRSS_Context::isStateEnabled(FreshRSS_Entry::STATE_NOT_FAVORITE)) {
+			FreshRSS_Context::$state = FreshRSS_Entry::STATE_NOT_FAVORITE;
 		} else {
-			Minz_Request::_param ('ajax');
+			FreshRSS_Context::$state = 0;
 		}
-	}
 
-	public function readAction () {
-		$this->redirect = true;
+		$params = array();
 
-		$id = Minz_Request::param ('id');
-		$get = Minz_Request::param ('get');
-		$nextGet = Minz_Request::param ('nextGet', $get); 
-		$idMax = Minz_Request::param ('idMax', 0);
+		$entryDAO = FreshRSS_Factory::createEntryDao();
+		if ($id === false) {
+			// id is false? It MUST be a POST request!
+			if (!Minz_Request::isPost()) {
+				Minz_Request::bad(_t('feedback.access.not_found'), array('c' => 'index', 'a' => 'index'));
+				return;
+			}
 
-		$entryDAO = new FreshRSS_EntryDAO ();
-		if ($id == false) {
 			if (!$get) {
-				$entryDAO->markReadEntries ($idMax);
+				// No get? Mark all entries as read (from $id_max)
+				$entryDAO->markReadEntries($id_max);
 			} else {
-				$typeGet = $get[0];
-				$get = substr ($get, 2);
-				switch ($typeGet) {
-					case 'c':
-						$entryDAO->markReadCat ($get, $idMax);
-						break;
-					case 'f':
-						$entryDAO->markReadFeed ($get, $idMax);
-						break;
-					case 's':
-						$entryDAO->markReadEntries ($idMax, true);
-						break;
-					case 'a':
-						$entryDAO->markReadEntries ($idMax);
-						break;
+				$type_get = $get[0];
+				$get = substr($get, 2);
+				switch($type_get) {
+				case 'c':
+					$entryDAO->markReadCat($get, $id_max, FreshRSS_Context::$search, FreshRSS_Context::$state);
+					break;
+				case 'f':
+					$entryDAO->markReadFeed($get, $id_max, FreshRSS_Context::$search, FreshRSS_Context::$state);
+					break;
+				case 's':
+					$entryDAO->markReadEntries($id_max, true, 0, FreshRSS_Context::$search);
+					break;
+				case 'a':
+					$entryDAO->markReadEntries($id_max, false, 0, FreshRSS_Context::$search, FreshRSS_Context::$state);
+					break;
 				}
-				if ($nextGet !== 'a') {
-					$this->params['get'] = $nextGet;
+
+				if ($next_get !== 'a') {
+					// Redirect to the correct page (category, feed or starred)
+					// Not "a" because it is the default value if nothing is
+					// given.
+					$params['get'] = $next_get;
 				}
 			}
-
-			$notif = array (
-				'type' => 'good',
-				'content' => Minz_Translate::t ('feeds_marked_read')
-			);
-			Minz_Session::_param ('notification', $notif);
 		} else {
-			$is_read = (bool)(Minz_Request::param ('is_read', true));
-			$entryDAO->markRead ($id, $is_read);
+			$is_read = (bool)(Minz_Request::param('is_read', true));
+			$entryDAO->markRead($id, $is_read);
+		}
+
+		if (!$this->ajax) {
+			Minz_Request::good(_t('feedback.sub.feed.marked_read'), array(
+				'c' => 'index',
+				'a' => 'index',
+				'params' => $params,
+			), true);
 		}
 	}
 
-	public function bookmarkAction () {
-		$this->redirect = true;
+	/**
+	 * This action marks an entry as favourite (bookmark) or not.
+	 *
+	 * Parameter is:
+	 *   - id (default: false)
+	 *   - is_favorite (default: true)
+	 * If id is false, nothing happened.
+	 */
+	public function bookmarkAction() {
+		$id = Minz_Request::param('id');
+		$is_favourite = (bool)Minz_Request::param('is_favorite', true);
+		if ($id !== false) {
+			$entryDAO = FreshRSS_Factory::createEntryDao();
+			$entryDAO->markFavorite($id, $is_favourite);
+		}
 
-		$id = Minz_Request::param ('id');
-		if ($id) {
-			$entryDAO = new FreshRSS_EntryDAO ();
-			$entryDAO->markFavorite ($id, (bool)(Minz_Request::param ('is_favorite', true)));
+		if (!$this->ajax) {
+			Minz_Request::forward(array(
+				'c' => 'index',
+				'a' => 'index',
+			), true);
 		}
 	}
 
+	/**
+	 * This action optimizes database to reduce its size.
+	 *
+	 * This action shouldbe reached by a POST request.
+	 *
+	 * @todo move this action in configure controller.
+	 * @todo call this action through web-cron when available
+	 */
 	public function optimizeAction() {
-		if (Minz_Request::isPost()) {
-			@set_time_limit(300);
-
-			// La table des entrées a tendance à grossir énormément
-			// Cette action permet d'optimiser cette table permettant de grapiller un peu de place
-			// Cette fonctionnalité n'est à appeler qu'occasionnellement
-			$entryDAO = new FreshRSS_EntryDAO();
-			$entryDAO->optimizeTable();
-
-			invalidateHttpCache();
-
-			$notif = array (
-				'type' => 'good',
-				'content' => Minz_Translate::t ('optimization_complete')
-			);
-			Minz_Session::_param ('notification', $notif);
+		$url_redirect = array(
+			'c' => 'configure',
+			'a' => 'archiving',
+		);
+
+		if (!Minz_Request::isPost()) {
+			Minz_Request::forward($url_redirect, true);
 		}
 
-		Minz_Request::forward(array(
-			'c' => 'configure',
-			'a' => 'archiving'
-		), true);
+		@set_time_limit(300);
+
+		$entryDAO = FreshRSS_Factory::createEntryDao();
+		$entryDAO->optimizeTable();
+
+		$feedDAO = FreshRSS_Factory::createFeedDao();
+		$feedDAO->updateCachedValues();
+
+		invalidateHttpCache();
+		Minz_Request::good(_t('feedback.admin.optimization_complete'), $url_redirect);
 	}
 
+	/**
+	 * This action purges old entries from feeds.
+	 *
+	 * @todo should be a POST request
+	 * @todo should be in feedController
+	 */
 	public function purgeAction() {
 		@set_time_limit(300);
 
-		$nb_month_old = max($this->view->conf->old_entries, 1);
+		$nb_month_old = max(FreshRSS_Context::$user_conf->old_entries, 1);
 		$date_min = time() - (3600 * 24 * 30 * $nb_month_old);
 
-		$feedDAO = new FreshRSS_FeedDAO();
-		$feeds = $feedDAO->listFeedsOrderUpdate();
-		$nbTotal = 0;
+		$feedDAO = FreshRSS_Factory::createFeedDao();
+		$feeds = $feedDAO->listFeeds();
+		$nb_total = 0;
 
 		invalidateHttpCache();
 
 		foreach ($feeds as $feed) {
-			$feedHistory = $feed->keepHistory();
-			if ($feedHistory == -2) {	//default
-				$feedHistory = $this->view->conf->keep_history_default;
+			$feed_history = $feed->keepHistory();
+			if ($feed_history == -2) {
+				// TODO: -2 must be a constant!
+				// -2 means we take the default value from configuration
+				$feed_history = FreshRSS_Context::$user_conf->keep_history_default;
 			}
-			if ($feedHistory >= 0) {
-				$nb = $feedDAO->cleanOldEntries($feed->id(), $date_min, $feedHistory);
+
+			if ($feed_history >= 0) {
+				$nb = $feedDAO->cleanOldEntries($feed->id(), $date_min, $feed_history);
 				if ($nb > 0) {
-					$nbTotal += $nb;
-					Minz_Log::record($nb . ' old entries cleaned in feed [' . $feed->url() . ']', Minz_Log::DEBUG);
-					$feedDAO->updateLastUpdate($feed->id());
+					$nb_total += $nb;
+					Minz_Log::debug($nb . ' old entries cleaned in feed [' . $feed->url() . ']');
 				}
 			}
 		}
 
-		invalidateHttpCache();
-
-		$notif = array(
-			'type' => 'good',
-			'content' => Minz_Translate::t('purge_completed', $nbTotal)
-		);
-		Minz_Session::_param('notification', $notif);
+		$feedDAO->updateCachedValues();
 
-		Minz_Request::forward(array(
+		invalidateHttpCache();
+		Minz_Request::good(_t('feedback.sub.purge_completed', $nb_total), array(
 			'c' => 'configure',
 			'a' => 'archiving'
-		), true);
+		));
 	}
 }
diff --git a/app/Controllers/errorController.php b/app/Controllers/errorController.php
index dc9a2ee25..b0bafda72 100644
--- a/app/Controllers/errorController.php
+++ b/app/Controllers/errorController.php
@@ -1,26 +1,53 @@
 <?php
 
+/**
+ * Controller to handle error page.
+ */
 class FreshRSS_error_Controller extends Minz_ActionController {
-	public function indexAction () {
-		switch (Minz_Request::param ('code')) {
+	/**
+	 * This action is the default one for the controller.
+	 *
+	 * It is called by Minz_Error::error() method.
+	 *
+	 * Parameters are passed by Minz_Session to have a proper url:
+	 *   - error_code (default: 404)
+	 *   - error_logs (default: array())
+	 */
+	public function indexAction() {
+		$code_int = Minz_Session::param('error_code', 404);
+		$error_logs = Minz_Session::param('error_logs', array());
+		Minz_Session::_param('error_code');
+		Minz_Session::_param('error_logs');
+
+		switch ($code_int) {
+		case 200 :
+			header('HTTP/1.1 200 OK');
+			break;
 		case 403:
+			header('HTTP/1.1 403 Forbidden');
 			$this->view->code = 'Error 403 - Forbidden';
-			break;
-		case 404:
-			$this->view->code = 'Error 404 - Not found';
+			$this->view->errorMessage = _t('feedback.access.denied');
 			break;
 		case 500:
+			header('HTTP/1.1 500 Internal Server Error');
 			$this->view->code = 'Error 500 - Internal Server Error';
 			break;
 		case 503:
+			header('HTTP/1.1 503 Service Unavailable');
 			$this->view->code = 'Error 503 - Service Unavailable';
 			break;
+		case 404:
 		default:
+			header('HTTP/1.1 404 Not Found');
 			$this->view->code = 'Error 404 - Not found';
+			$this->view->errorMessage = _t('feedback.access.not_found');
+		}
+
+		$error_message = trim(implode($error_logs));
+		if ($error_message !== '') {
+			$this->view->errorMessage = $error_message;
 		}
-		
-		$this->view->logs = Minz_Request::param ('logs');
-		
-		Minz_View::prependTitle ($this->view->code . ' · ');
+
+		Minz_View::prependTitle($this->view->code . ' · ');
 	}
 }
diff --git a/app/Controllers/extensionController.php b/app/Controllers/extensionController.php
new file mode 100644
index 000000000..b6d2d3fe4
--- /dev/null
+++ b/app/Controllers/extensionController.php
@@ -0,0 +1,215 @@
+<?php
+
+/**
+ * The controller to manage extensions.
+ */
+class FreshRSS_extension_Controller extends Minz_ActionController {
+	/**
+	 * This action is called before every other action in that class. It is
+	 * the common boiler plate for every action. It is triggered by the
+	 * underlying framework.
+	 */
+	public function firstAction() {
+		if (!FreshRSS_Auth::hasAccess()) {
+			Minz_Error::error(403);
+		}
+	}
+
+	/**
+	 * This action lists all the extensions available to the current user.
+	 */
+	public function indexAction() {
+		Minz_View::prependTitle(_t('admin.extensions.title') . ' · ');
+		$this->view->extension_list = array(
+			'system' => array(),
+			'user' => array(),
+		);
+
+		$extensions = Minz_ExtensionManager::listExtensions();
+		foreach ($extensions as $ext) {
+			$this->view->extension_list[$ext->getType()][] = $ext;
+		}
+	}
+
+	/**
+	 * This action handles configuration of a given extension.
+	 *
+	 * Only administrator can configure a system extension.
+	 *
+	 * Parameters are:
+	 * - e: the extension name (urlencoded)
+	 * - additional parameters which should be handle by the extension
+	 *   handleConfigureAction() method (POST request).
+	 */
+	public function configureAction() {
+		if (Minz_Request::param('ajax')) {
+			$this->view->_useLayout(false);
+		} else {
+			$this->indexAction();
+			$this->view->change_view('extension', 'index');
+		}
+
+		$ext_name = urldecode(Minz_Request::param('e'));
+		$ext = Minz_ExtensionManager::findExtension($ext_name);
+
+		if (is_null($ext)) {
+			Minz_Error::error(404);
+		}
+		if ($ext->getType() === 'system' && !FreshRSS_Auth::hasAccess('admin')) {
+			Minz_Error::error(403);
+		}
+
+		$this->view->extension = $ext;
+		$this->view->extension->handleConfigureAction();
+	}
+
+	/**
+	 * This action enables a disabled extension for the current user.
+	 *
+	 * System extensions can only be enabled by an administrator.
+	 * This action must be reached by a POST request.
+	 *
+	 * Parameter is:
+	 * - e: the extension name (urlencoded).
+	 */
+	public function enableAction() {
+		$url_redirect = array('c' => 'extension', 'a' => 'index');
+
+		if (Minz_Request::isPost()) {
+			$ext_name = urldecode(Minz_Request::param('e'));
+			$ext = Minz_ExtensionManager::findExtension($ext_name);
+
+			if (is_null($ext)) {
+				Minz_Request::bad(_t('feedback.extensions.not_found', $ext_name),
+				                  $url_redirect);
+			}
+
+			if ($ext->isEnabled()) {
+				Minz_Request::bad(_t('feedback.extensions.already_enabled', $ext_name),
+				                  $url_redirect);
+			}
+
+			$conf = null;
+			if ($ext->getType() === 'system' && FreshRSS_Auth::hasAccess('admin')) {
+				$conf = FreshRSS_Context::$system_conf;
+			} elseif ($ext->getType() === 'user') {
+				$conf = FreshRSS_Context::$user_conf;
+			} else {
+				Minz_Request::bad(_t('feedback.extensions.no_access', $ext_name),
+				                  $url_redirect);
+			}
+
+			$res = $ext->install();
+
+			if ($res === true) {
+				$ext_list = $conf->extensions_enabled;
+				array_push_unique($ext_list, $ext_name);
+				$conf->extensions_enabled = $ext_list;
+				$conf->save();
+
+				Minz_Request::good(_t('feedback.extensions.enable.ok', $ext_name),
+				                   $url_redirect);
+			} else {
+				Minz_Log::warning('Can not enable extension ' . $ext_name . ': ' . $res);
+				Minz_Request::bad(_t('feedback.extensions.enable.ko', $ext_name, _url('index', 'logs')),
+				                  $url_redirect);
+			}
+		}
+
+		Minz_Request::forward($url_redirect, true);
+	}
+
+	/**
+	 * This action disables an enabled extension for the current user.
+	 *
+	 * System extensions can only be disabled by an administrator.
+	 * This action must be reached by a POST request.
+	 *
+	 * Parameter is:
+	 * - e: the extension name (urlencoded).
+	 */
+	public function disableAction() {
+		$url_redirect = array('c' => 'extension', 'a' => 'index');
+
+		if (Minz_Request::isPost()) {
+			$ext_name = urldecode(Minz_Request::param('e'));
+			$ext = Minz_ExtensionManager::findExtension($ext_name);
+
+			if (is_null($ext)) {
+				Minz_Request::bad(_t('feedback.extensions.not_found', $ext_name),
+				                  $url_redirect);
+			}
+
+			if (!$ext->isEnabled()) {
+				Minz_Request::bad(_t('feedback.extensions.not_enabled', $ext_name),
+				                  $url_redirect);
+			}
+
+			$conf = null;
+			if ($ext->getType() === 'system' && FreshRSS_Auth::hasAccess('admin')) {
+				$conf = FreshRSS_Context::$system_conf;
+			} elseif ($ext->getType() === 'user') {
+				$conf = FreshRSS_Context::$user_conf;
+			} else {
+				Minz_Request::bad(_t('feedback.extensions.no_access', $ext_name),
+				                  $url_redirect);
+			}
+
+			$res = $ext->uninstall();
+
+			if ($res === true) {
+				$ext_list = $conf->extensions_enabled;
+				array_remove($ext_list, $ext_name);
+				$conf->extensions_enabled = $ext_list;
+				$conf->save();
+
+				Minz_Request::good(_t('feedback.extensions.disable.ok', $ext_name),
+				                   $url_redirect);
+			} else {
+				Minz_Log::warning('Can not unable extension ' . $ext_name . ': ' . $res);
+				Minz_Request::bad(_t('feedback.extensions.disable.ko', $ext_name, _url('index', 'logs')),
+				                  $url_redirect);
+			}
+		}
+
+		Minz_Request::forward($url_redirect, true);
+	}
+
+	/**
+	 * This action handles deletion of an extension.
+	 *
+	 * Only administrator can remove an extension.
+	 * This action must be reached by a POST request.
+	 *
+	 * Parameter is:
+	 * -e: extension name (urlencoded)
+	 */
+	public function removeAction() {
+		if (!FreshRSS_Auth::hasAccess('admin')) {
+			Minz_Error::error(403);
+		}
+
+		$url_redirect = array('c' => 'extension', 'a' => 'index');
+
+		if (Minz_Request::isPost()) {
+			$ext_name = urldecode(Minz_Request::param('e'));
+			$ext = Minz_ExtensionManager::findExtension($ext_name);
+
+			if (is_null($ext)) {
+				Minz_Request::bad(_t('feedback.extensions.not_found', $ext_name),
+				                  $url_redirect);
+			}
+
+			$res = recursive_unlink($ext->getPath());
+			if ($res) {
+				Minz_Request::good(_t('feedback.extensions.removed', $ext_name),
+				                  $url_redirect);
+			} else {
+				Minz_Request::bad(_t('feedback.extensions.cannot_delete', $ext_name),
+				                  $url_redirect);
+			}
+		}
+
+		Minz_Request::forward($url_redirect, true);
+	}
+}
diff --git a/app/Controllers/feedController.php b/app/Controllers/feedController.php
index c718fcd5c..f71f26a4e 100755
--- a/app/Controllers/feedController.php
+++ b/app/Controllers/feedController.php
@@ -1,451 +1,591 @@
 <?php
 
+/**
+ * Controller to handle every feed actions.
+ */
 class FreshRSS_feed_Controller extends Minz_ActionController {
-	public function firstAction () {
-		if (!$this->view->loginOk) {
+	/**
+	 * This action is called before every other action in that class. It is
+	 * the common boiler plate for every action. It is triggered by the
+	 * underlying framework.
+	 */
+	public function firstAction() {
+		if (!FreshRSS_Auth::hasAccess()) {
 			// 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 = FreshRSS_Context::$user_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 (Minz_Translate::t ('access_denied')))
-				);
+			$action = Minz_Request::actionName();
+			$allow_anonymous_refresh = FreshRSS_Context::$system_conf->allow_anonymous_refresh;
+			if ($action !== 'actualize' ||
+					!($allow_anonymous_refresh || $token_is_ok)) {
+				Minz_Error::error(403);
 			}
 		}
 	}
 
-	public function addAction () {
+	public static function addFeed($url, $title = '', $cat_id = 0, $new_cat_name = '', $http_auth = '') {
+		FreshRSS_UserDAO::touch();
 		@set_time_limit(300);
 
-		if (Minz_Request::isPost ()) {
-			$this->catDAO = new FreshRSS_CategoryDAO ();
-			$this->catDAO->checkDefault ();
+		$catDAO = new FreshRSS_CategoryDAO();
 
-			$url = Minz_Request::param ('url_rss');
-			$cat = Minz_Request::param ('category', false);
-			if ($cat === false) {
-				$def_cat = $this->catDAO->getDefault ();
-				$cat = $def_cat->id ();
+		$cat = null;
+		if ($cat_id > 0) {
+			$cat = $catDAO->searchById($cat_id);
+		}
+		if ($cat == null && $new_cat_name != '') {
+			$cat = $catDAO->addCategory(array('name' => $new_cat_name));
+		}
+		if ($cat == null) {
+			$catDAO->checkDefault();
+		}
+		$cat_id = $cat == null ? FreshRSS_CategoryDAO::defaultCategoryId : $cat->id();
+
+		$feed = new FreshRSS_Feed($url);	//Throws FreshRSS_BadUrl_Exception
+		$feed->_httpAuth($http_auth);
+		$feed->load(true);	//Throws FreshRSS_Feed_Exception, Minz_FileNotExistException
+		$feed->_category($cat_id);
+
+		$feedDAO = FreshRSS_Factory::createFeedDao();
+		if ($feedDAO->searchByUrl($feed->url())) {
+			throw new FreshRSS_AlreadySubscribed_Exception($url, $feed->name());
+		}
+
+		// Call the extension hook
+		$feed = Minz_ExtensionManager::callHook('feed_before_insert', $feed);
+		if ($feed === null) {
+			throw new FreshRSS_FeedNotAdded_Exception($url, $feed->name());
+		}
+
+		$values = array(
+			'url' => $feed->url(),
+			'category' => $feed->category(),
+			'name' => $title != '' ? $title : $feed->name(),
+			'website' => $feed->website(),
+			'description' => $feed->description(),
+			'lastUpdate' => time(),
+			'httpAuth' => $feed->httpAuth(),
+		);
+
+		$id = $feedDAO->addFeed($values);
+		if (!$id) {
+			// There was an error in database... we cannot say what here.
+			throw new FreshRSS_FeedNotAdded_Exception($url, $feed->name());
+		}
+		$feed->_id($id);
+
+		// Ok, feed has been added in database. Now we have to refresh entries.
+		self::actualizeFeed($id, $url, false, null, true);
+
+		return $feed;
+	}
+
+	/**
+	 * This action subscribes to a feed.
+	 *
+	 * It can be reached by both GET and POST requests.
+	 *
+	 * GET request displays a form to add and configure a feed.
+	 * Request parameter is:
+	 *   - url_rss (default: false)
+	 *
+	 * POST request adds a feed in database.
+	 * Parameters are:
+	 *   - url_rss (default: false)
+	 *   - category (default: false)
+	 *   - new_category (required if category == 'nc')
+	 *   - http_user (default: false)
+	 *   - http_pass (default: false)
+	 * It tries to get website information from RSS feed.
+	 * If no category is given, feed is added to the default one.
+	 *
+	 * If url_rss is false, nothing happened.
+	 */
+	public function addAction() {
+		$url = Minz_Request::param('url_rss');
+
+		if ($url === false) {
+			// No url, do nothing
+			Minz_Request::forward(array(
+				'c' => 'subscription',
+				'a' => 'index'
+			), true);
+		}
+
+		$feedDAO = FreshRSS_Factory::createFeedDao();
+		$url_redirect = array(
+			'c' => 'subscription',
+			'a' => 'index',
+			'params' => array(),
+		);
+
+		$limits = FreshRSS_Context::$system_conf->limits;
+		$this->view->feeds = $feedDAO->listFeeds();
+		if (count($this->view->feeds) >= $limits['max_feeds']) {
+			Minz_Request::bad(_t('feedback.sub.feed.over_max', $limits['max_feeds']),
+			                  $url_redirect);
+		}
+
+		if (Minz_Request::isPost()) {
+			$cat = Minz_Request::param('category');
+			$new_cat_name = '';
+			if ($cat === 'nc') {
+				// User want to create a new category, new_category parameter
+				// must exist
+				$new_cat = Minz_Request::param('new_category');
+				$new_cat_name = isset($new_cat['name']) ? $new_cat['name'] : '';
 			}
 
-			$user = Minz_Request::param ('http_user');
-			$pass = Minz_Request::param ('http_pass');
-			$params = array ();
+			// HTTP information are useful if feed is protected behind a
+			// HTTP authentication
+			$user = trim(Minz_Request::param('http_user', ''));
+			$pass = Minz_Request::param('http_pass', '');
+			$http_auth = '';
+			if ($user != '' && $pass != '') {	//TODO: Sanitize
+				$http_auth = $user . ':' . $pass;
+			}
 
-			$transactionStarted = false;
 			try {
-				$feed = new FreshRSS_Feed ($url);
-				$feed->_category ($cat);
-
-				$httpAuth = '';
-				if ($user != '' || $pass != '') {
-					$httpAuth = $user . ':' . $pass;
-				}
-				$feed->_httpAuth ($httpAuth);
-
-				$feed->load(true);
-
-				$feedDAO = new FreshRSS_FeedDAO ();
-				$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' => Minz_Translate::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' => Minz_Translate::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 = new FreshRSS_EntryDAO ();
-						$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);
-
-						$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);
-						}
-						$feedDAO->updateLastUpdate ($feed->id ());
-						$feedDAO->commit ();
-						$transactionStarted = false;
-
-						// ok, ajout terminé
-						$notif = array (
-							'type' => 'good',
-							'content' => Minz_Translate::t ('feed_added', $feed->name ())
-						);
-						Minz_Session::_param ('notification', $notif);
-
-						// permet de rediriger vers la page de conf du flux
-						$params['id'] = $feed->id ();
-					}
-				}
+				$feed = self::addFeed($url, '', $cat, $new_cat_name, $http_auth);
 			} catch (FreshRSS_BadUrl_Exception $e) {
-				Minz_Log::record ($e->getMessage (), Minz_Log::WARNING);
-				$notif = array (
-					'type' => 'bad',
-					'content' => Minz_Translate::t ('invalid_url', $url)
-				);
-				Minz_Session::_param ('notification', $notif);
+				// Given url was not a valid url!
+				Minz_Log::warning($e->getMessage());
+				Minz_Request::bad(_t('feedback.sub.feed.invalid_url', $url), $url_redirect);
 			} catch (FreshRSS_Feed_Exception $e) {
-				Minz_Log::record ($e->getMessage (), Minz_Log::WARNING);
-				$notif = array (
-					'type' => 'bad',
-					'content' => Minz_Translate::t ('internal_problem_feed')
-				);
-				Minz_Session::_param ('notification', $notif);
+				// Something went bad (timeout, server not found, etc.)
+				Minz_Log::warning($e->getMessage());
+				Minz_Request::bad(_t('feedback.sub.feed.internal_problem', _url('index', 'logs')), $url_redirect);
 			} catch (Minz_FileNotExistException $e) {
-				// Répertoire de cache n'existe pas
-				Minz_Log::record ($e->getMessage (), Minz_Log::ERROR);
-				$notif = array (
-					'type' => 'bad',
-					'content' => Minz_Translate::t ('internal_problem_feed')
-				);
-				Minz_Session::_param ('notification', $notif);
+				// Cache directory doesn't exist!
+				Minz_Log::error($e->getMessage());
+				Minz_Request::bad(_t('feedback.sub.feed.internal_problem', _url('index', 'logs')), $url_redirect);
+			} catch (FreshRSS_AlreadySubscribed_Exception $e) {
+				Minz_Request::bad(_t('feedback.sub.feed.already_subscribed', $e->feedName()), $url_redirect);
+			} catch (FreshRSS_FeedNotAdded_Exception $e) {
+				Minz_Request::bad(_t('feedback.sub.feed.not_added', $e->feedName()), $url_redirect);
 			}
-			if ($transactionStarted) {
-				$feedDAO->rollBack ();
+
+			// Entries are in DB, we redirect to feed configuration page.
+			$url_redirect['params']['id'] = $feed->id();
+			Minz_Request::good(_t('feedback.sub.feed.added', $feed->name()), $url_redirect);
+		} else {
+			// GET request: we must ask confirmation to user before adding feed.
+			Minz_View::prependTitle(_t('sub.feed.title_add') . ' · ');
+
+			$this->catDAO = new FreshRSS_CategoryDAO();
+			$this->view->categories = $this->catDAO->listCategories(false);
+			$this->view->feed = new FreshRSS_Feed($url);
+			try {
+				// We try to get more information about the feed.
+				$this->view->feed->load(true);
+				$this->view->load_ok = true;
+			} catch (Exception $e) {
+				$this->view->load_ok = false;
 			}
 
-			Minz_Request::forward (array ('c' => 'configure', 'a' => 'feed', 'params' => $params), true);
+			$feed = $feedDAO->searchByUrl($this->view->feed->url());
+			if ($feed) {
+				// Already subscribe so we redirect to the feed configuration page.
+				$url_redirect['params']['id'] = $feed->id();
+				Minz_Request::good(_t('feedback.sub.feed.already_subscribed', $feed->name()), $url_redirect);
+			}
 		}
 	}
 
-	public function truncateAction () {
-		if (Minz_Request::isPost ()) {
-			$id = Minz_Request::param ('id');
-			$feedDAO = new FreshRSS_FeedDAO ();
-			$n = $feedDAO->truncate($id);
-			$notif = array(
-				'type' => $n === false ? 'bad' : 'good',
-				'content' => Minz_Translate::t ('n_entries_deleted', $n)
-			);
-			Minz_Session::_param ('notification', $notif);
-			invalidateHttpCache();
-			Minz_Request::forward (array ('c' => 'configure', 'a' => 'feed', 'params' => array('id' => $id)), true);
+	/**
+	 * This action remove entries from a given feed.
+	 *
+	 * It should be reached by a POST action.
+	 *
+	 * Parameter is:
+	 *   - id (default: false)
+	 */
+	public function truncateAction() {
+		$id = Minz_Request::param('id');
+		$url_redirect = array(
+			'c' => 'subscription',
+			'a' => 'index',
+			'params' => array('id' => $id)
+		);
+
+		if (!Minz_Request::isPost()) {
+			Minz_Request::forward($url_redirect, true);
+		}
+
+		$feedDAO = FreshRSS_Factory::createFeedDao();
+		$n = $feedDAO->truncate($id);
+
+		invalidateHttpCache();
+		if ($n === false) {
+			Minz_Request::bad(_t('feedback.sub.feed.error'), $url_redirect);
+		} else {
+			Minz_Request::good(_t('feedback.sub.feed.n_entries_deleted', $n), $url_redirect);
 		}
 	}
 
-	public function actualizeAction () {
+	public static function actualizeFeed($feed_id, $feed_url, $force, $simplePiePush = null, $isNewFeed = false) {
 		@set_time_limit(300);
 
-		$feedDAO = new FreshRSS_FeedDAO ();
-		$entryDAO = new FreshRSS_EntryDAO ();
+		$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);
+		// Create a list of feeds to actualize.
+		// If feed_id is set and valid, corresponding feed is added to the list but
+		// alone in order to automatize further process.
+		$feeds = array();
+		if ($feed_id > 0 || $feed_url) {
+			$feed = $feed_id > 0 ? $feedDAO->searchById($feed_id) : $feedDAO->searchByUrl($feed_url);
 			if ($feed) {
-				$feeds = array ($feed);
+				$feeds[] = $feed;
 			}
 		} else {
-			$feeds = $feedDAO->listFeedsOrderUpdate ();
+			$feeds = $feedDAO->listFeedsOrderUpdate(-1);
 		}
 
-		// 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);
+		// Calculate date of oldest entries we accept in DB.
+		$nb_month_old = max(FreshRSS_Context::$user_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;
+		// PubSubHubbub support
+		$pubsubhubbubEnabledGeneral = FreshRSS_Context::$system_conf->pubsubhubbub_enabled;
+		$pshbMinAge = time() - (3600 * 24);  //TODO: Make a configuration.
+
+		$updated_feeds = 0;
+		$is_read = FreshRSS_Context::$user_conf->mark_when['reception'] ? 1 : 0;
 		foreach ($feeds as $feed) {
+			$url = $feed->url();	//For detection of HTTP 301
+
+			$pubSubHubbubEnabled = $pubsubhubbubEnabledGeneral && $feed->pubSubHubbubEnabled();
+			if ((!$simplePiePush) && (!$feed_id) && $pubSubHubbubEnabled && ($feed->lastUpdate() > $pshbMinAge)) {
+				//$text = 'Skip pull of feed using PubSubHubbub: ' . $url;
+				//Minz_Log::debug($text);
+				//file_put_contents(USERS_PATH . '/_/log_pshb.txt', date('c') . "\t" . $text . "\n", FILE_APPEND);
+				continue;	//When PubSubHubbub is used, do not pull refresh so often
+			}
+
+			$mtime = 0;
+			$ttl = $feed->ttl();
+			if ($ttl == -1) {
+				continue;	//Feed refresh is disabled
+			}
+			if ((!$simplePiePush) && (!$feed_id) &&
+				($feed->lastUpdate() + 10 >= time() - ($ttl == -2 ? FreshRSS_Context::$user_conf->ttl_default : $ttl))) {
+				//Too early to refresh from source, but check whether the feed was updated by another user
+				$mtime = $feed->cacheModifiedTime();
+				if ($feed->lastUpdate() + 10 >= $mtime) {
+					continue;	//Nothing newer from other users
+				}
+				//Minz_Log::debug($feed->url() . ' was updated at ' . date('c', $mtime) . ' by another user');
+				//Will take advantage of the newer cache
+			}
+
 			if (!$feed->lock()) {
-				Minz_Log::record('Feed already being actualized: ' . $feed->url(), Minz_Log::NOTICE);
+				Minz_Log::notice('Feed already being actualized: ' . $feed->url());
 				continue;
 			}
+
 			try {
-				$url = $feed->url();
-				$feedHistory = $feed->keepHistory();
+				if ($simplePiePush) {
+					$feed->loadEntries($simplePiePush);	//Used by PubSubHubbub
+				} else {
+					$feed->load(false, $isNewFeed);
+				}
+			} catch (FreshRSS_Feed_Exception $e) {
+				Minz_Log::warning($e->getMessage());
+				$feedDAO->updateLastUpdate($feed->id(), true);
+				$feed->unlock();
+				continue;
+			}
 
-				$feed->load(false);
-				$entries = array_reverse($feed->entries());	//We want chronological order and SimplePie uses reverse order
-				$hasTransaction = false;
+			$feed_history = $feed->keepHistory();
+			if ($isNewFeed) {
+				$feed_history = -1; //∞
+			} elseif ($feed_history == -2) {
+				// TODO: -2 must be a constant!
+				// -2 means we take the default value from configuration
+				$feed_history = FreshRSS_Context::$user_conf->keep_history_default;
+			}
 
-				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);
+			// We want chronological order and SimplePie uses reverse order.
+			$entries = array_reverse($feed->entries());
+			if (count($entries) > 0) {
+				$newGuids = array();
+				foreach ($entries as $entry) {
+					$newGuids[] = safe_ascii($entry->guid());
+				}
+				// For this feed, check existing GUIDs already in database.
+				$existingHashForGuids = $entryDAO->listHashForFeedGuids($feed->id(), $newGuids);
+				unset($newGuids);
+
+				$oldGuids = array();
+				// Add entries in database if possible.
+				foreach ($entries as $entry) {
+					$entry_date = $entry->date(true);
+					if (isset($existingHashForGuids[$entry->guid()])) {
+						$existingHash = $existingHashForGuids[$entry->guid()];
+						if (strcasecmp($existingHash, $entry->hash()) === 0 || trim($existingHash, '0') == '') {
+							//This entry already exists and is unchanged. TODO: Remove the test with the zero'ed hash in FreshRSS v1.3
+							$oldGuids[] = $entry->guid();
+						} else {	//This entry already exists but has been updated
+							//Minz_Log::debug('Entry with GUID `' . $entry->guid() . '` updated in feed ' . $feed->id() .
+								//', old hash ' . $existingHash . ', new hash ' . $entry->hash());
+							//TODO: Make an updated/is_read policy by feed, in addition to the global one.
+							$entry->_isRead(FreshRSS_Context::$user_conf->mark_updated_article_unread ? false : null);	//Change is_read according to policy.
+							if (!$entryDAO->inTransaction()) {
+								$entryDAO->beginTransaction();
+							}
+							$entryDAO->updateEntry($entry->toArray());
+						}
+					} elseif ($feed_history == 0 && $entry_date < $date_min) {
+						// This entry should not be added considering configuration and date.
+						$oldGuids[] = $entry->guid();
+					} else {
+						if ($isNewFeed) {
+							$id = min(time(), $entry_date) . uSecString();
+						} elseif ($entry_date < $date_min) {
+							$id = min(time(), $entry_date) . uSecString();
+							$entry->_isRead(true);	//Old article that was not in database. Probably an error, so mark as read
+						} else {
+							$id = uTimeString();
+							$entry->_isRead($is_read);
+						}
+						$entry->_id($id);
 
-					if ($feedHistory == -2) {	//default
-						$feedHistory = $this->view->conf->keep_history_default;
-					}
+						$entry = Minz_ExtensionManager::callHook('entry_before_insert', $entry);
+						if ($entry === null) {
+							// An extension has returned a null value, there is nothing to insert.
+							continue;
+						}
 
-					$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);
+						if ($pubSubHubbubEnabled && !$simplePiePush) {	//We use push, but have discovered an article by pull!
+							$text = 'An article was discovered by pull although we use PubSubHubbub!: Feed ' . $url . ' GUID ' . $entry->guid();
+							file_put_contents(USERS_PATH . '/_/log_pshb.txt', date('c') . "\t" . $text . "\n", FILE_APPEND);
+							Minz_Log::warning($text);
+							$pubSubHubbubEnabled = false;
+							$feed->pubSubHubbubError(true);
 						}
+
+						if (!$entryDAO->inTransaction()) {
+							$entryDAO->beginTransaction();
+						}
+						$entryDAO->addEntry($entry->toArray());
 					}
 				}
+				$entryDAO->updateLastSeen($feed->id(), $oldGuids, $mtime);
+			}
 
-				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::record ($nb . ' old entries cleaned in feed [' . $feed->url() . ']', Minz_Log::DEBUG);
-					}
+			if ($feed_history >= 0 && rand(0, 30) === 1) {
+				// TODO: move this function in web cron when available (see entry::purge)
+				// Remove old entries once in 30.
+				if (!$entryDAO->inTransaction()) {
+					$entryDAO->beginTransaction();
 				}
 
-				// on indique que le flux vient d'être mis à jour en BDD
-				$feedDAO->updateLastUpdate ($feed->id (), 0, $hasTransaction);
-				if ($hasTransaction) {
-					$feedDAO->commit();
+				$nb = $feedDAO->cleanOldEntries($feed->id(),
+				                                $date_min,
+				                                max($feed_history, count($entries) + 10));
+				if ($nb > 0) {
+					Minz_Log::debug($nb . ' old entries cleaned in feed [' .
+					                $feed->url() . ']');
 				}
-				$flux_update++;
-				if ($feed->url() !== $url) {	//URL has changed (auto-discovery)
-					$feedDAO->updateFeed($feed->id(), array('url' => $feed->url()));
+			}
+
+			$feedDAO->updateLastUpdate($feed->id(), false, $entryDAO->inTransaction(), $mtime);
+			if ($entryDAO->inTransaction()) {
+				$entryDAO->commit();
+			}
+
+			if ($feed->hubUrl() && $feed->selfUrl()) {	//selfUrl has priority for PubSubHubbub
+				if ($feed->selfUrl() !== $url) {	//https://code.google.com/p/pubsubhubbub/wiki/MovingFeedsOrChangingHubs
+					$selfUrl = checkUrl($feed->selfUrl());
+					if ($selfUrl) {
+						Minz_Log::debug('PubSubHubbub unsubscribe ' . $feed->url());
+						if (!$feed->pubSubHubbubSubscribe(false)) {	//Unsubscribe
+							Minz_Log::warning('Error while PubSubHubbub unsubscribing from ' . $feed->url());
+						}
+						$feed->_url($selfUrl, false);
+						Minz_Log::notice('Feed ' . $url . ' canonical address moved to ' . $feed->url());
+						$feedDAO->updateFeed($feed->id(), array('url' => $feed->url()));
+					}
 				}
-			} catch (FreshRSS_Feed_Exception $e) {
-				Minz_Log::record ($e->getMessage (), Minz_Log::NOTICE);
-				$feedDAO->updateLastUpdate ($feed->id (), 1);
+			}
+			elseif ($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()));
 			}
 
 			$feed->faviconPrepare();
+			if ($pubsubhubbubEnabledGeneral && $feed->pubSubHubbubPrepare()) {
+				Minz_Log::notice('PubSubHubbub subscribe ' . $feed->url());
+				if (!$feed->pubSubHubbubSubscribe(true)) {	//Subscribe
+					Minz_Log::warning('Error while PubSubHubbub subscribing to ' . $feed->url());
+				}
+			}
 			$feed->unlock();
+			$updated_feeds++;
 			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) {
+			// No more than 10 feeds unless $force is true to avoid overloading
+			// the server.
+			if ($updated_feeds >= 10 && !$force) {
 				break;
 			}
 		}
+		return array($updated_feeds, reset($feeds));
+	}
 
-		$url = array ();
-		if ($flux_update === 1) {
-			// on a mis un seul flux à jour
-			$feed = reset ($feeds);
-			$notif = array (
-				'type' => 'good',
-				'content' => Minz_Translate::t ('feed_actualized', $feed->name ())
-			);
-		} elseif ($flux_update > 1) {
-			// plusieurs flux on été mis à jour
-			$notif = array (
-				'type' => 'good',
-				'content' => Minz_Translate::t ('n_feeds_actualized', $flux_update)
-			);
-		} else {
-			// aucun flux n'a été mis à jour, oups
-			$notif = array (
-				'type' => 'good',
-				'content' => Minz_Translate::t ('no_feed_to_refresh')
-			);
-		}
+	/**
+	 * This action actualizes entries from one or several feeds.
+	 *
+	 * Parameters are:
+	 *   - id (default: false): Feed ID
+	 *   - url (default: false): Feed URL
+	 *   - force (default: false)
+	 * If id and url are not specified, all the feeds are actualized. But if force is
+	 * false, process stops at 10 feeds to avoid time execution problem.
+	 */
+	public function actualizeAction() {
+		Minz_Session::_param('actualize_feeds', false);
+		$id = Minz_Request::param('id');
+		$url = Minz_Request::param('url');
+		$force = Minz_Request::param('force');
 
-		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 ());
-		}
+		list($updated_feeds, $feed) = self::actualizeFeed($id, $url, $force);
 
-		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 (
+		if (Minz_Request::param('ajax')) {
+			// Most of the time, ajax request is for only one feed. But since
+			// there are several parallel requests, we should return that there
+			// are several updated feeds.
+			$notif = array(
 				'type' => 'good',
-				'content' => Minz_Translate::t ('feeds_actualized')
+				'content' => _t('feedback.sub.feed.actualizeds')
 			);
-			Minz_Session::_param ('notification', $notif);
-			// et on désactive le layout car ne sert à rien
-			$this->view->_useLayout (false);
+			Minz_Session::_param('notification', $notif);
+			// No layout in ajax request.
+			$this->view->_useLayout(false);
+		} else {
+			// Redirect to the main page with correct notification.
+			if ($updated_feeds === 1) {
+				Minz_Request::good(_t('feedback.sub.feed.actualized', $feed->name()), array(
+					'params' => array('get' => 'f_' . $feed->id())
+				));
+			} elseif ($updated_feeds > 1) {
+				Minz_Request::good(_t('feedback.sub.feed.n_actualized', $updated_feeds), array());
+			} else {
+				Minz_Request::good(_t('feedback.sub.feed.no_refresh'), array());
+			}
 		}
+		return $updated_feeds;
 	}
 
-	public function massiveImportAction () {
-		@set_time_limit(300);
-
-		$this->catDAO = new FreshRSS_CategoryDAO ();
-		$this->catDAO->checkDefault ();
-
-		$entryDAO = new FreshRSS_EntryDAO ();
-		$feedDAO = new FreshRSS_FeedDAO ();
+	public static function renameFeed($feed_id, $feed_name) {
+		if ($feed_id <= 0 || $feed_name == '') {
+			return false;
+		}
+		FreshRSS_UserDAO::touch();
+		$feedDAO = FreshRSS_Factory::createFeedDao();
+		return $feedDAO->updateFeed($feed_id, array('name' => $feed_name));
+	}
 
-		$categories = Minz_Request::param ('categories', array (), true);
-		$feeds = Minz_Request::param ('feeds', array (), true);
+	public static function moveFeed($feed_id, $cat_id, $new_cat_name = '') {
+		if ($feed_id <= 0 || ($cat_id <= 0 && $new_cat_name == '')) {
+			return false;
+		}
+		FreshRSS_UserDAO::touch();
 
-		// on ajoute les catégories en masse dans une fonction à part
-		$this->addCategories ($categories);
+		$catDAO = new FreshRSS_CategoryDAO();
+		if ($cat_id > 0) {
+			$cat = $catDAO->searchById($cat_id);
+			$cat_id = $cat == null ? 0 : $cat->id();
+		}
+		if ($cat_id <= 1 && $new_cat_name != '') {
+			$cat_id = $catDAO->addCategory(array('name' => $new_cat_name));
+		}
+		if ($cat_id <= 1) {
+			$catDAO->checkDefault();
+			$cat_id = FreshRSS_CategoryDAO::defaultCategoryId;
+		}
 
-		// 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);
+		$feedDAO = FreshRSS_Factory::createFeedDao();
+		return $feedDAO->updateFeed($feed_id, array('category' => $cat_id));
+	}
 
-		// la variable $error permet de savoir si une erreur est survenue
-		// Le but est de ne pas arrêter l'import même en cas d'erreur
-		// L'utilisateur sera mis au courant s'il y a eu des erreurs, mais
-		// ne connaîtra pas les détails. Ceux-ci seront toutefois logguées
-		$error = false;
-		$i = 0;
-		foreach ($feeds as $feed) {
-			try {
-				$values = array (
-					'id' => $feed->id (),
-					'url' => $feed->url (),
-					'category' => $feed->category (),
-					'name' => $feed->name (),
-					'website' => $feed->website (),
-					'description' => $feed->description (),
-					'lastUpdate' => 0,
-					'httpAuth' => $feed->httpAuth ()
-				);
-
-				// ajout du flux que s'il n'est pas déjà en BDD
-				if (!$feedDAO->searchByUrl ($values['url'])) {
-					$id = $feedDAO->addFeed ($values);
-					if ($id) {
-						$feed->_id ($id);
-						$feed->faviconPrepare();
-					} else {
-						$error = true;
-					}
-				}
-			} catch (FreshRSS_Feed_Exception $e) {
-				$error = true;
-				Minz_Log::record ($e->getMessage (), Minz_Log::WARNING);
-			}
+	/**
+	 * This action changes the category of a feed.
+	 *
+	 * This page must be reached by a POST request.
+	 *
+	 * Parameters are:
+	 *   - f_id (default: false)
+	 *   - c_id (default: false)
+	 * If c_id is false, default category is used.
+	 *
+	 * @todo should handle order of the feed inside the category.
+	 */
+	public function moveAction() {
+		if (!Minz_Request::isPost()) {
+			Minz_Request::forward(array('c' => 'subscription'), true);
 		}
 
-		if ($error) {
-			$res = Minz_Translate::t ('feeds_imported_with_errors');
+		$feed_id = Minz_Request::param('f_id');
+		$cat_id = Minz_Request::param('c_id');
+
+		if (self::moveFeed($feed_id, $cat_id)) {
+			// TODO: return something useful
 		} else {
-			$res = Minz_Translate::t ('feeds_imported');
+			Minz_Log::warning('Cannot move feed `' . $feed_id . '` ' .
+			                  'in the category `' . $cat_id . '`');
+			Minz_Error::error(404);
 		}
-
-		$notif = array (
-			'type' => 'good',
-			'content' => $res
-		);
-		Minz_Session::_param ('notification', $notif);
-		Minz_Session::_param ('actualize_feeds', true);
-
-		// et on redirige vers la page d'accueil
-		Minz_Request::forward (array (
-			'c' => 'index',
-			'a' => 'index'
-		), true);
 	}
 
-	public function deleteAction () {
-		if (Minz_Request::isPost ()) {
-			$type = Minz_Request::param ('type', 'feed');
-			$id = Minz_Request::param ('id');
-
-			$feedDAO = new FreshRSS_FeedDAO ();
-			if ($type == 'category') {
-				if ($feedDAO->deleteFeedByCategory ($id)) {
-					$notif = array (
-						'type' => 'good',
-						'content' => Minz_Translate::t ('category_emptied')
-					);
-					//TODO: Delete old favicons
-				} else {
-					$notif = array (
-						'type' => 'bad',
-						'content' => Minz_Translate::t ('error_occured')
-					);
-				}
-			} else {
-				if ($feedDAO->deleteFeed ($id)) {
-					$notif = array (
-						'type' => 'good',
-						'content' => Minz_Translate::t ('feed_deleted')
-					);
-					//TODO: Delete old favicon
-				} else {
-					$notif = array (
-						'type' => 'bad',
-						'content' => Minz_Translate::t ('error_occured')
-					);
-				}
-			}
+	public static function deleteFeed($feed_id) {
+		FreshRSS_UserDAO::touch();
+		$feedDAO = FreshRSS_Factory::createFeedDao();
+		if ($feedDAO->deleteFeed($feed_id)) {
+			// TODO: Delete old favicon
 
-			Minz_Session::_param ('notification', $notif);
+			// Remove related queries
+			FreshRSS_Context::$user_conf->queries = remove_query_by_get(
+				'f_' . $feed_id, FreshRSS_Context::$user_conf->queries);
+			FreshRSS_Context::$user_conf->save();
 
-			if ($type == 'category') {
-				Minz_Request::forward (array ('c' => 'configure', 'a' => 'categorize'), true);
-			} else {
-				Minz_Request::forward (array ('c' => 'configure', 'a' => 'feed'), true);
-			}
+			return true;
 		}
+		return false;
 	}
 
-	private function addCategories ($categories) {
-		foreach ($categories as $cat) {
-			if (!$this->catDAO->searchByName ($cat->name ())) {
-				$values = array (
-					'id' => $cat->id (),
-					'name' => $cat->name (),
-				);
-				$catDAO->addCategory ($values);
-			}
+	/**
+	 * This action deletes a feed.
+	 *
+	 * This page must be reached by a POST request.
+	 * If there are related queries, they are deleted too.
+	 *
+	 * Parameters are:
+	 *   - id (default: false)
+	 *   - r (default: false)
+	 * r permits to redirect to a given page at the end of this action.
+	 *
+	 * @todo handle "r" redirection in Minz_Request::forward()?
+	 */
+	public function deleteAction() {
+		$redirect_url = Minz_Request::param('r', false, true);
+		if (!$redirect_url) {
+			$redirect_url = array('c' => 'subscription', 'a' => 'index');
+		}
+		if (!Minz_Request::isPost()) {
+			Minz_Request::forward($redirect_url, true);
+		}
+
+		$id = Minz_Request::param('id');
+
+		if (self::deleteFeed($id)) {
+			Minz_Request::good(_t('feedback.sub.feed.deleted'), $redirect_url);
+		} else {
+			Minz_Request::bad(_t('feedback.sub.feed.error'), $redirect_url);
 		}
 	}
 }
diff --git a/app/Controllers/importExportController.php b/app/Controllers/importExportController.php
new file mode 100644
index 000000000..6ae89defb
--- /dev/null
+++ b/app/Controllers/importExportController.php
@@ -0,0 +1,716 @@
+<?php
+
+/**
+ * Controller to handle every import and export actions.
+ */
+class FreshRSS_importExport_Controller extends Minz_ActionController {
+	/**
+	 * This action is called before every other action in that class. It is
+	 * the common boiler plate for every action. It is triggered by the
+	 * underlying framework.
+	 */
+	public function firstAction() {
+		if (!FreshRSS_Auth::hasAccess()) {
+			Minz_Error::error(403);
+		}
+
+		require_once(LIB_PATH . '/lib_opml.php');
+
+		$this->catDAO = new FreshRSS_CategoryDAO();
+		$this->entryDAO = FreshRSS_Factory::createEntryDao();
+		$this->feedDAO = FreshRSS_Factory::createFeedDao();
+	}
+
+	/**
+	 * This action displays the main page for import / export system.
+	 */
+	public function indexAction() {
+		$this->view->feeds = $this->feedDAO->listFeeds();
+		Minz_View::prependTitle(_t('sub.import_export.title') . ' · ');
+	}
+
+	public function importFile($name, $path, $username = null) {
+		require_once(LIB_PATH . '/lib_opml.php');
+
+		$this->catDAO = new FreshRSS_CategoryDAO($username);
+		$this->entryDAO = FreshRSS_Factory::createEntryDao($username);
+		$this->feedDAO = FreshRSS_Factory::createFeedDao($username);
+
+		$type_file = self::guessFileType($name);
+
+		$list_files = array(
+			'opml' => array(),
+			'json_starred' => array(),
+			'json_feed' => array()
+		);
+
+		// We try to list all files according to their type
+		$list = array();
+		if ($type_file === 'zip' && extension_loaded('zip')) {
+			$zip = zip_open($path);
+			if (!is_resource($zip)) {
+				// zip_open cannot open file: something is wrong
+				throw new FreshRSS_Zip_Exception($zip);
+			}
+			while (($zipfile = zip_read($zip)) !== false) {
+				if (!is_resource($zipfile)) {
+					// zip_entry() can also return an error code!
+					throw new FreshRSS_Zip_Exception($zipfile);
+				} else {
+					$type_zipfile = self::guessFileType(zip_entry_name($zipfile));
+					if ($type_file !== 'unknown') {
+						$list_files[$type_zipfile][] = zip_entry_read(
+							$zipfile,
+							zip_entry_filesize($zipfile)
+						);
+					}
+				}
+			}
+			zip_close($zip);
+		} elseif ($type_file === 'zip') {
+			// ZIP extension is not loaded
+			throw new FreshRSS_ZipMissing_Exception();
+		} elseif ($type_file !== 'unknown') {
+			$list_files[$type_file][] = file_get_contents($path);
+		}
+
+		// Import file contents.
+		// OPML first(so categories and feeds are imported)
+		// Starred articles then so the "favourite" status is already set
+		// And finally all other files.
+		$ok = true;
+		foreach ($list_files['opml'] as $opml_file) {
+			if (!$this->importOpml($opml_file)) {
+				$ok = false;
+				if (FreshRSS_Context::$isCli) {
+					fwrite(STDERR, 'FreshRSS error during OPML import' . "\n");
+				} else {
+					Minz_Log::warning('Error during OPML import');
+				}
+			}
+		}
+		foreach ($list_files['json_starred'] as $article_file) {
+			if (!$this->importJson($article_file, true)) {
+				$ok = false;
+				if (FreshRSS_Context::$isCli) {
+					fwrite(STDERR, 'FreshRSS error during JSON stars import' . "\n");
+				} else {
+					Minz_Log::warning('Error during JSON stars import');
+				}
+			}
+		}
+		foreach ($list_files['json_feed'] as $article_file) {
+			if (!$this->importJson($article_file)) {
+				$ok = false;
+				if (FreshRSS_Context::$isCli) {
+					fwrite(STDERR, 'FreshRSS error during JSON feeds import' . "\n");
+				} else {
+					Minz_Log::warning('Error during JSON feeds import');
+				}
+			}
+		}
+
+		return $ok;
+	}
+
+	/**
+	 * This action handles import action.
+	 *
+	 * It must be reached by a POST request.
+	 *
+	 * Parameter is:
+	 *   - file (default: nothing!)
+	 * Available file types are: zip, json or xml.
+	 */
+	public function importAction() {
+		if (!Minz_Request::isPost()) {
+			Minz_Request::forward(array('c' => 'importExport', 'a' => 'index'), true);
+		}
+
+		$file = $_FILES['file'];
+		$status_file = $file['error'];
+
+		if ($status_file !== 0) {
+			Minz_Log::warning('File cannot be uploaded. Error code: ' . $status_file);
+			Minz_Request::bad(_t('feedback.import_export.file_cannot_be_uploaded'),
+			                  array('c' => 'importExport', 'a' => 'index'));
+		}
+
+		@set_time_limit(300);
+
+		$error = false;
+		try {
+			$error = !$this->importFile($file['name'], $file['tmp_name']);
+		} catch (FreshRSS_ZipMissing_Exception $zme) {
+			Minz_Request::bad(_t('feedback.import_export.no_zip_extension'),
+				array('c' => 'importExport', 'a' => 'index'));
+		} catch (FreshRSS_Zip_Exception $ze) {
+			Minz_Log::warning('ZIP archive cannot be imported. Error code: ' . $ze->zipErrorCode());
+			Minz_Request::bad(_t('feedback.import_export.zip_error'),
+				array('c' => 'importExport', 'a' => 'index'));
+		}
+
+		// And finally, we get import status and redirect to the home page
+		Minz_Session::_param('actualize_feeds', true);
+		$content_notif = $error === true ? _t('feedback.import_export.feeds_imported_with_errors') :
+		                                   _t('feedback.import_export.feeds_imported');
+		Minz_Request::good($content_notif);
+	}
+
+	/**
+	 * This method tries to guess the file type based on its name.
+	 *
+	 * Itis a *very* basic guess file type function. Only based on filename.
+	 * That's could be improved but should be enough for what we have to do.
+	 */
+	private static function guessFileType($filename) {
+		if (substr_compare($filename, '.zip', -4) === 0) {
+			return 'zip';
+		} elseif (substr_compare($filename, '.opml', -5) === 0 ||
+		          substr_compare($filename, '.xml', -4) === 0) {
+			return 'opml';
+		} elseif (substr_compare($filename, '.json', -5) === 0 &&
+		          strpos($filename, 'starred') !== false) {
+			return 'json_starred';
+		} elseif (substr_compare($filename, '.json', -5) === 0) {
+			return 'json_feed';
+		} else {
+			return 'unknown';
+		}
+	}
+
+	/**
+	 * This method parses and imports an OPML file.
+	 *
+	 * @param string $opml_file the OPML file content.
+	 * @return boolean false if an error occured, true otherwise.
+	 */
+	private function importOpml($opml_file) {
+		$opml_array = array();
+		try {
+			$opml_array = libopml_parse_string($opml_file, false);
+		} catch (LibOPML_Exception $e) {
+			if (FreshRSS_Context::$isCli) {
+				fwrite(STDERR, 'FreshRSS error during OPML parsing: ' . $e->getMessage() . "\n");
+			} else {
+				Minz_Log::warning($e->getMessage());
+			}
+			return false;
+		}
+
+		$this->catDAO->checkDefault();
+
+		return $this->addOpmlElements($opml_array['body']);
+	}
+
+	/**
+	 * This method imports an OPML file based on its body.
+	 *
+	 * @param array $opml_elements an OPML element (body or outline).
+	 * @param string $parent_cat the name of the parent category.
+	 * @return boolean false if an error occured, true otherwise.
+	 */
+	private function addOpmlElements($opml_elements, $parent_cat = null) {
+		$ok = true;
+
+		$nb_feeds = count($this->feedDAO->listFeeds());
+		$nb_cats = count($this->catDAO->listCategories(false));
+		$limits = FreshRSS_Context::$system_conf->limits;
+
+		foreach ($opml_elements as $elt) {
+			if (isset($elt['xmlUrl'])) {
+				// If xmlUrl exists, it means it is a feed
+				if (FreshRSS_Context::$isCli && $nb_feeds >= $limits['max_feeds']) {
+					Minz_Log::warning(_t('feedback.sub.feed.over_max',
+									  $limits['max_feeds']));
+					$ok = false;
+					continue;
+				}
+
+				if ($this->addFeedOpml($elt, $parent_cat)) {
+					$nb_feeds++;
+				} else {
+					$ok = false;
+				}
+			} else {
+				// No xmlUrl? It should be a category!
+				$limit_reached = ($nb_cats >= $limits['max_categories']);
+				if (!FreshRSS_Context::$isCli && $limit_reached) {
+					Minz_Log::warning(_t('feedback.sub.category.over_max',
+									  $limits['max_categories']));
+					$ok = false;
+					continue;
+				}
+
+				if ($this->addCategoryOpml($elt, $parent_cat, $limit_reached)) {
+					$nb_cats++;
+				} else {
+					$ok = false;
+				}
+			}
+		}
+
+		return $ok;
+	}
+
+	/**
+	 * This method imports an OPML feed element.
+	 *
+	 * @param array $feed_elt an OPML element (must be a feed element).
+	 * @param string $parent_cat the name of the parent category.
+	 * @return boolean false if an error occured, true otherwise.
+	 */
+	private function addFeedOpml($feed_elt, $parent_cat) {
+		if ($parent_cat == null) {
+			// This feed has no parent category so we get the default one
+			$this->catDAO->checkDefault();
+			$default_cat = $this->catDAO->getDefault();
+			$parent_cat = $default_cat->name();
+		}
+
+		$cat = $this->catDAO->searchByName($parent_cat);
+		if ($cat == null) {
+			// If there is not $cat, it means parent category does not exist in
+			// database.
+			// If it happens, take the default category.
+			$this->catDAO->checkDefault();
+			$cat = $this->catDAO->getDefault();
+		}
+
+		// We get different useful information
+		$url = Minz_Helper::htmlspecialchars_utf8($feed_elt['xmlUrl']);
+		$name = Minz_Helper::htmlspecialchars_utf8($feed_elt['text']);
+		$website = '';
+		if (isset($feed_elt['htmlUrl'])) {
+			$website = Minz_Helper::htmlspecialchars_utf8($feed_elt['htmlUrl']);
+		}
+		$description = '';
+		if (isset($feed_elt['description'])) {
+			$description = Minz_Helper::htmlspecialchars_utf8($feed_elt['description']);
+		}
+
+		$error = false;
+		try {
+			// Create a Feed object and add it in DB
+			$feed = new FreshRSS_Feed($url);
+			$feed->_category($cat->id());
+			$feed->_name($name);
+			$feed->_website($website);
+			$feed->_description($description);
+
+			// Call the extension hook
+			$feed = Minz_ExtensionManager::callHook('feed_before_insert', $feed);
+			if ($feed != null) {
+				// addFeedObject checks if feed is already in DB so nothing else to
+				// check here
+				$id = $this->feedDAO->addFeedObject($feed);
+				$error = ($id === false);
+			} else {
+				$error = true;
+			}
+		} catch (FreshRSS_Feed_Exception $e) {
+			if (FreshRSS_Context::$isCli) {
+				fwrite(STDERR, 'FreshRSS error during OPML feed import: ' . $e->getMessage() . "\n");
+			} else {
+				Minz_Log::warning($e->getMessage());
+			}
+			$error = true;
+		}
+
+		if ($error) {
+			if (FreshRSS_Context::$isCli) {
+				fwrite(STDERR, 'FreshRSS error during OPML feed import from URL: ' . $url . ' in category ' . $cat->id() . "\n");
+			} else {
+				Minz_Log::warning('Error during OPML feed import from URL: ' . $url . ' in category ' . $cat->id());
+			}
+		}
+
+		return !$error;
+	}
+
+	/**
+	 * This method imports an OPML category element.
+	 *
+	 * @param array $cat_elt an OPML element (must be a category element).
+	 * @param string $parent_cat the name of the parent category.
+	 * @param boolean $cat_limit_reached indicates if category limit has been reached.
+	 *                if yes, category is not added (but we try for feeds!)
+	 * @return boolean false if an error occured, true otherwise.
+	 */
+	private function addCategoryOpml($cat_elt, $parent_cat, $cat_limit_reached) {
+		// Create a new Category object
+		$catName = Minz_Helper::htmlspecialchars_utf8($cat_elt['text']);
+		$cat = new FreshRSS_Category($catName);
+
+		$error = true;
+		if (FreshRSS_Context::$isCli || !$cat_limit_reached) {
+			$id = $this->catDAO->addCategoryObject($cat);
+			$error = ($id === false);
+		}
+		if ($error) {
+			if (FreshRSS_Context::$isCli) {
+				fwrite(STDERR, 'FreshRSS error during OPML category import from URL: ' . $catName . "\n");
+			} else {
+				Minz_Log::warning('Error during OPML category import from URL: ' . $catName);
+			}
+		}
+
+		if (isset($cat_elt['@outlines'])) {
+			// Our cat_elt contains more categories or more feeds, so we
+			// add them recursively.
+			// Note: FreshRSS does not support yet category arborescence
+			$error &= !$this->addOpmlElements($cat_elt['@outlines'], $catName);
+		}
+
+		return !$error;
+	}
+
+	/**
+	 * This method import a JSON-based file (Google Reader format).
+	 *
+	 * @param string $article_file the JSON file content.
+	 * @param boolean $starred true if articles from the file must be starred.
+	 * @return boolean false if an error occured, true otherwise.
+	 */
+	private function importJson($article_file, $starred = false) {
+		$article_object = json_decode($article_file, true);
+		if ($article_object == null) {
+			if (FreshRSS_Context::$isCli) {
+				fwrite(STDERR, 'FreshRSS error trying to import a non-JSON file' . "\n");
+			} else {
+				Minz_Log::warning('Try to import a non-JSON file');
+			}
+			return false;
+		}
+
+		$is_read = FreshRSS_Context::$user_conf->mark_when['reception'] ? 1 : 0;
+
+		$google_compliant = strpos($article_object['id'], 'com.google') !== false;
+
+		$error = false;
+		$article_to_feed = array();
+
+		$nb_feeds = count($this->feedDAO->listFeeds());
+		$limits = FreshRSS_Context::$system_conf->limits;
+
+		// First, we check feeds of articles are in DB (and add them if needed).
+		foreach ($article_object['items'] as $item) {
+			$key = $google_compliant ? 'htmlUrl' : 'feedUrl';
+			$feed = new FreshRSS_Feed($item['origin'][$key]);
+			$feed = $this->feedDAO->searchByUrl($feed->url());
+
+			if ($feed == null) {
+				// Feed does not exist in DB,we should to try to add it.
+				if ((!FreshRSS_Context::$isCli) && ($nb_feeds >= $limits['max_feeds'])) {
+					// Oops, no more place!
+					Minz_Log::warning(_t('feedback.sub.feed.over_max', $limits['max_feeds']));
+				} else {
+					$feed = $this->addFeedJson($item['origin'], $google_compliant);
+				}
+
+				if ($feed == null) {
+					// Still null? It means something went wrong.
+					$error = true;
+				} else {
+					$nb_feeds++;
+				}
+			}
+
+			if ($feed != null) {
+				$article_to_feed[$item['id']] = $feed->id();
+			}
+		}
+
+		$newGuids = array();
+		foreach ($article_object['items'] as $item) {
+			$newGuids[] = safe_ascii($item['id']);
+		}
+		// For this feed, check existing GUIDs already in database.
+		$existingHashForGuids = $this->entryDAO->listHashForFeedGuids($feed->id(), $newGuids);
+		unset($newGuids);
+
+		// Then, articles are imported.
+		$this->entryDAO->beginTransaction();
+		foreach ($article_object['items'] as $item) {
+			if (!isset($article_to_feed[$item['id']])) {
+				// Related feed does not exist for this entry, do nothing.
+				continue;
+			}
+
+			$feed_id = $article_to_feed[$item['id']];
+			$author = isset($item['author']) ? $item['author'] : '';
+			$key_content = ($google_compliant && !isset($item['content'])) ?
+			               'summary' : 'content';
+			$tags = $item['categories'];
+			if ($google_compliant) {
+				// Remove tags containing "/state/com.google" which are useless.
+				$tags = array_filter($tags, function($var) {
+					return strpos($var, '/state/com.google') !== false;
+				});
+			}
+
+			$entry = new FreshRSS_Entry(
+				$feed_id, $item['id'], $item['title'], $author,
+				$item[$key_content]['content'], $item['alternate'][0]['href'],
+				$item['published'], $is_read, $starred
+			);
+			$entry->_id(min(time(), $entry->date(true)) . uSecString());
+			$entry->_tags($tags);
+
+			$entry = Minz_ExtensionManager::callHook('entry_before_insert', $entry);
+			if ($entry == null) {
+				// An extension has returned a null value, there is nothing to insert.
+				continue;
+			}
+
+			$values = $entry->toArray();
+			if (isset($existingHashForGuids[$entry->guid()])) {
+				$id = $this->entryDAO->updateEntry($values);
+			} else {
+				$id = $this->entryDAO->addEntry($values);
+			}
+
+			if (!$error && ($id === false)) {
+				$error = true;
+			}
+		}
+		$this->entryDAO->commit();
+
+		return !$error;
+	}
+
+	/**
+	 * This method import a JSON-based feed (Google Reader format).
+	 *
+	 * @param array $origin represents a feed.
+	 * @param boolean $google_compliant takes care of some specific values if true.
+	 * @return FreshRSS_Feed if feed is in database at the end of the process,
+	 *         else null.
+	 */
+	private function addFeedJson($origin, $google_compliant) {
+		$return = null;
+		$key = $google_compliant ? 'htmlUrl' : 'feedUrl';
+		$url = $origin[$key];
+		$name = $origin['title'];
+		$website = $origin['htmlUrl'];
+
+		try {
+			// Create a Feed object and add it in database.
+			$feed = new FreshRSS_Feed($url);
+			$feed->_category(FreshRSS_CategoryDAO::defaultCategoryId);
+			$feed->_name($name);
+			$feed->_website($website);
+
+			// Call the extension hook
+			$feed = Minz_ExtensionManager::callHook('feed_before_insert', $feed);
+			if ($feed != null) {
+				// addFeedObject checks if feed is already in DB so nothing else to
+				// check here.
+				$id = $this->feedDAO->addFeedObject($feed);
+
+				if ($id !== false) {
+					$feed->_id($id);
+					$return = $feed;
+				}
+			}
+		} catch (FreshRSS_Feed_Exception $e) {
+			if (FreshRSS_Context::$isCli) {
+				fwrite(STDERR, 'FreshRSS error during JSON feed import: ' . $e->getMessage() . "\n");
+			} else {
+				Minz_Log::warning($e->getMessage());
+			}
+		}
+
+		return $return;
+	}
+
+	public function exportFile($export_opml = true, $export_starred = false, $export_feeds = array(), $maxFeedEntries = 50, $username = null) {
+		require_once(LIB_PATH . '/lib_opml.php');
+
+		$this->catDAO = new FreshRSS_CategoryDAO($username);
+		$this->entryDAO = FreshRSS_Factory::createEntryDao($username);
+		$this->feedDAO = FreshRSS_Factory::createFeedDao($username);
+
+		$this->entryDAO->disableBuffering();
+
+		if ($export_feeds === true) {
+			//All feeds
+			$export_feeds = $this->feedDAO->listFeedsIds();
+		}
+		if (!is_array($export_feeds)) {
+			$export_feeds = array();
+		}
+
+		$day = date('Y-m-d');
+
+		$export_files = array();
+		if ($export_opml) {
+			$export_files["feeds_${day}.opml.xml"] = $this->generateOpml();
+		}
+
+		if ($export_starred) {
+			$export_files["starred_${day}.json"] = $this->generateEntries('starred');
+		}
+
+		foreach ($export_feeds as $feed_id) {
+			$feed = $this->feedDAO->searchById($feed_id);
+			if ($feed) {
+				$filename = "feed_${day}_" . $feed->category() . '_'
+				          . $feed->id() . '.json';
+				$export_files[$filename] = $this->generateEntries('feed', $feed, $maxFeedEntries);
+			}
+		}
+
+		$nb_files = count($export_files);
+		if ($nb_files > 1) {
+			// If there are more than 1 file to export, we need a ZIP archive.
+			try {
+				$this->sendZip($export_files);
+			} catch (Exception $e) {
+				throw new FreshRSS_ZipMissing_Exception($e);
+			}
+		} elseif ($nb_files === 1) {
+			// Only one file? Guess its type and export it.
+			$filename = key($export_files);
+			$type = self::guessFileType($filename);
+			$this->sendFile('freshrss_' . $filename, $export_files[$filename], $type);
+		}
+		return $nb_files;
+	}
+
+	/**
+	 * This action handles export action.
+	 *
+	 * This action must be reached by a POST request.
+	 *
+	 * Parameters are:
+	 *   - export_opml (default: false)
+	 *   - export_starred (default: false)
+	 *   - export_feeds (default: array()) a list of feed ids
+	 */
+	public function exportAction() {
+		if (!Minz_Request::isPost()) {
+			Minz_Request::forward(array('c' => 'importExport', 'a' => 'index'), true);
+		}
+		$this->view->_useLayout(false);
+
+		$nb_files = 0;
+		try {
+			$nb_files = $this->exportFile(
+					Minz_Request::param('export_opml', false),
+					Minz_Request::param('export_starred', false),
+					Minz_Request::param('export_feeds', array())
+				);
+		} catch (FreshRSS_ZipMissing_Exception $zme) {
+			# Oops, there is no ZIP extension!
+			Minz_Request::bad(_t('feedback.import_export.export_no_zip_extension'),
+			                  array('c' => 'importExport', 'a' => 'index'));
+		}
+
+		if ($nb_files < 1) {
+			// Nothing to do...
+			Minz_Request::forward(array('c' => 'importExport', 'a' => 'index'), true);
+		}
+	}
+
+	/**
+	 * This method returns the OPML file based on user subscriptions.
+	 *
+	 * @return string the OPML file content.
+	 */
+	private function generateOpml() {
+		$list = array();
+		foreach ($this->catDAO->listCategories() as $key => $cat) {
+			$list[$key]['name'] = $cat->name();
+			$list[$key]['feeds'] = $this->feedDAO->listByCategory($cat->id());
+		}
+
+		$this->view->categories = $list;
+		return $this->view->helperToString('export/opml');
+	}
+
+	/**
+	 * This method returns a JSON file content.
+	 *
+	 * @param string $type must be "starred" or "feed"
+	 * @param FreshRSS_Feed $feed feed of which we want to get entries.
+	 * @return string the JSON file content.
+	 */
+	private function generateEntries($type, $feed = NULL, $maxFeedEntries = 50) {
+		$this->view->categories = $this->catDAO->listCategories();
+
+		if ($type == 'starred') {
+			$this->view->list_title = _t('sub.import_export.starred_list');
+			$this->view->type = 'starred';
+			$unread_fav = $this->entryDAO->countUnreadReadFavorites();
+			$this->view->entriesRaw = $this->entryDAO->listWhereRaw(
+				's', '', FreshRSS_Entry::STATE_ALL, 'ASC', $unread_fav['all']
+			);
+		} elseif ($type === 'feed' && $feed != null) {
+			$this->view->list_title = _t('sub.import_export.feed_list', $feed->name());
+			$this->view->type = 'feed/' . $feed->id();
+			$this->view->entriesRaw = $this->entryDAO->listWhereRaw(
+				'f', $feed->id(), FreshRSS_Entry::STATE_ALL, 'ASC',
+				$maxFeedEntries
+			);
+			$this->view->feed = $feed;
+		}
+
+		return $this->view->helperToString('export/articles');
+	}
+
+	/**
+	 * This method zips a list of files and returns it by HTTP.
+	 *
+	 * @param array $files list of files where key is filename and value the content.
+	 * @throws Exception if Zip extension is not loaded.
+	 */
+	private function sendZip($files) {
+		if (!extension_loaded('zip')) {
+			throw new Exception();
+		}
+
+		// From https://stackoverflow.com/questions/1061710/php-zip-files-on-the-fly
+		$zip_file = tempnam('tmp', 'zip');
+		$zip = new ZipArchive();
+		$zip->open($zip_file, ZipArchive::OVERWRITE);
+
+		foreach ($files as $filename => $content) {
+			$zip->addFromString($filename, $content);
+		}
+
+		// Close and send to user
+		$zip->close();
+		header('Content-Type: application/zip');
+		header('Content-Length: ' . filesize($zip_file));
+		$day = date('Y-m-d');
+		header('Content-Disposition: attachment; filename="freshrss_' . $day . '_export.zip"');
+		readfile($zip_file);
+		unlink($zip_file);
+	}
+
+	/**
+	 * This method returns a single file (OPML or JSON) by HTTP.
+	 *
+	 * @param string $filename
+	 * @param string $content
+	 * @param string $type the file type (opml, json_feed or json_starred).
+	 *                     If equals to unknown, nothing happens.
+	 */
+	private function sendFile($filename, $content, $type) {
+		if ($type === 'unknown') {
+			return;
+		}
+
+		$content_type = '';
+		if ($type === 'opml') {
+			$content_type = 'application/xml';
+		} elseif ($type === 'json_feed' || $type === 'json_starred') {
+			$content_type = 'application/json';
+		}
+
+		header('Content-Type: ' . $content_type . '; charset=utf-8');
+		header('Content-disposition: attachment; filename=' . $filename);
+		print($content);
+	}
+}
diff --git a/app/Controllers/indexController.php b/app/Controllers/indexController.php
index 38f4c0e7c..5ca147ff3 100755
--- a/app/Controllers/indexController.php
+++ b/app/Controllers/indexController.php
@@ -1,371 +1,272 @@
 <?php
 
+/**
+ * This class handles main actions of FreshRSS.
+ */
 class FreshRSS_index_Controller extends Minz_ActionController {
-	private $nb_not_read_cat = 0;
-
-	public function indexAction () {
-		$output = Minz_Request::param ('output');
-		$token = $this->view->conf->token;
-
-		// check if user is logged in
-		if (!$this->view->loginOk && !Minz_Configuration::allowAnonymous()) {
-			$token_param = Minz_Request::param ('token', '');
-			$token_is_ok = ($token != '' && $token === $token_param);
-			if ($output === 'rss' && !$token_is_ok) {
-				Minz_Error::error (
-					403,
-					array ('error' => array (Minz_Translate::t ('access_denied')))
-				);
-				return;
-			} elseif ($output !== 'rss') {
-				// "hard" redirection is not required, just ask dispatcher to
-				// forward to the login form without 302 redirection
-				Minz_Request::forward(array('c' => 'index', 'a' => 'formLogin'));
-				return;
-			}
-		}
 
-		// construction of RSS url of this feed
-		$params = Minz_Request::params ();
-		$params['output'] = 'rss';
-		if (isset ($params['search'])) {
-			$params['search'] = urlencode ($params['search']);
-		}
-		if (!Minz_Configuration::allowAnonymous()) {
-			$params['token'] = $token;
-		}
-		$this->view->rss_url = array (
+	/**
+	 * This action only redirect on the default view mode (normal or global)
+	 */
+	public function indexAction() {
+		$prefered_output = FreshRSS_Context::$user_conf->view_mode;
+		Minz_Request::forward(array(
 			'c' => 'index',
-			'a' => 'index',
-			'params' => $params
-		);
-
-		if ($output === 'rss') {
-			// no layout for RSS output
-			$this->view->_useLayout (false);
-			header('Content-Type: application/rss+xml; charset=utf-8');
-		} elseif ($output === 'global') {
-			Minz_View::appendScript (Minz_Url::display ('/scripts/global_view.js?' . @filemtime(PUBLIC_PATH . '/scripts/global_view.js')));
-		}
+			'a' => $prefered_output
+		));
+	}
 
-		$catDAO = new FreshRSS_CategoryDAO();
-		$entryDAO = new FreshRSS_EntryDAO();
-
-		$this->view->cat_aside = $catDAO->listCategories ();
-		$this->view->nb_favorites = $entryDAO->countUnreadReadFavorites ();
-		$this->view->nb_not_read = FreshRSS_CategoryDAO::CountUnreads($this->view->cat_aside, 1);
-		$this->view->currentName = '';
-
-		$this->view->get_c = '';
-		$this->view->get_f = '';
-
-		$get = Minz_Request::param ('get', 'a');
-		$getType = $get[0];
-		$getId = substr ($get, 2);
-		if (!$this->checkAndProcessType ($getType, $getId)) {
-			Minz_Log::record ('Not found [' . $getType . '][' . $getId . ']', Minz_Log::DEBUG);
-			Minz_Error::error (
-				404,
-				array ('error' => array (Minz_Translate::t ('page_not_found')))
-			);
+	/**
+	 * This action displays the normal view of FreshRSS.
+	 */
+	public function normalAction() {
+		$allow_anonymous = FreshRSS_Context::$system_conf->allow_anonymous;
+		if (!FreshRSS_Auth::hasAccess() && !$allow_anonymous) {
+			Minz_Request::forward(array('c' => 'auth', 'a' => 'login'));
 			return;
 		}
 
-		// mise à jour des titres
-		$this->view->rss_title = $this->view->currentName . ' | ' . Minz_View::title();
-		if ($this->view->nb_not_read > 0) {
-			Minz_View::appendTitle (' (' . formatNumber($this->view->nb_not_read) . ')');
+		try {
+			$this->updateContext();
+		} catch (FreshRSS_Context_Exception $e) {
+			Minz_Error::error(404);
 		}
-		Minz_View::prependTitle (
-			$this->view->currentName .
-			($this->nb_not_read_cat > 0 ? ' (' . formatNumber($this->nb_not_read_cat) . ')' : '') .
-			' · '
-		);
 
-		// On récupère les différents éléments de filtrage
-		$this->view->state = $state = Minz_Request::param ('state', $this->view->conf->default_view);
-		$filter = Minz_Request::param ('search', '');
-		if (!empty($filter)) {
-			$state = 'all';	//Search always in read and unread articles
-		}
-		$this->view->order = $order = Minz_Request::param ('order', $this->view->conf->sort_order);
-		$nb = Minz_Request::param ('nb', $this->view->conf->posts_per_page);
-		$first = Minz_Request::param ('next', '');
-
-		if ($state === 'not_read') {	//Any unread article in this category at all?
-			switch ($getType) {
-				case 'a':
-					$hasUnread = $this->view->nb_not_read > 0;
-					break;
-				case 's':
-					$hasUnread = $this->view->nb_favorites['unread'] > 0;
-					break;
-				case 'c':
-					$hasUnread = (!isset($this->view->cat_aside[$getId])) || ($this->view->cat_aside[$getId]->nbNotRead() > 0);
-					break;
-				case 'f':
-					$myFeed = FreshRSS_CategoryDAO::findFeed($this->view->cat_aside, $getId);
-					$hasUnread = ($myFeed === null) || ($myFeed->nbNotRead() > 0);
-					break;
-				default:
-					$hasUnread = true;
-					break;
+		$this->view->callbackBeforeContent = function($view) {
+			try {
+				FreshRSS_Context::$number++;	//+1 for pagination
+				$entries = FreshRSS_index_Controller::listEntriesByContext();
+				FreshRSS_Context::$number--;
+
+				$nb_entries = count($entries);
+				if ($nb_entries > FreshRSS_Context::$number) {
+					// We have more elements for pagination
+					$last_entry = array_pop($entries);
+					FreshRSS_Context::$next_id = $last_entry->id();
+				}
+
+				$first_entry = $nb_entries > 0 ? $entries[0] : null;
+				FreshRSS_Context::$id_max = $first_entry === null ?
+											(time() - 1) . '000000' :
+											$first_entry->id();
+				if (FreshRSS_Context::$order === 'ASC') {
+					// In this case we do not know but we guess id_max
+					$id_max = (time() - 1) . '000000';
+					if (strcmp($id_max, FreshRSS_Context::$id_max) > 0) {
+						FreshRSS_Context::$id_max = $id_max;
+					}
+				}
+
+				$view->entries = $entries;
+			} catch (FreshRSS_EntriesGetter_Exception $e) {
+				Minz_Log::notice($e->getMessage());
+				Minz_Error::error(404);
 			}
-			if (!$hasUnread) {
-				$this->view->state = $state = 'all';
+
+			$view->categories = FreshRSS_Context::$categories;
+
+			$view->rss_title = FreshRSS_Context::$name . ' | ' . Minz_View::title();
+			$title = FreshRSS_Context::$name;
+			if (FreshRSS_Context::$get_unread > 0) {
+				$title = '(' . FreshRSS_Context::$get_unread . ') ' . $title;
 			}
-		}
+			Minz_View::prependTitle($title . ' · ');
+		};
+	}
 
-		$today = @strtotime('today');
-		$this->view->today = $today;
+	/**
+	 * This action displays the reader view of FreshRSS.
+	 *
+	 * @todo: change this view into specific CSS rules?
+	 */
+	public function readerAction() {
+		$this->normalAction();
+	}
+
+	/**
+	 * This action displays the global view of FreshRSS.
+	 */
+	public function globalAction() {
+		$allow_anonymous = FreshRSS_Context::$system_conf->allow_anonymous;
+		if (!FreshRSS_Auth::hasAccess() && !$allow_anonymous) {
+			Minz_Request::forward(array('c' => 'auth', 'a' => 'login'));
+			return;
+		}
 
-		// on calcule la date des articles les plus anciens qu'on affiche
-		$nb_month_old = $this->view->conf->old_entries;
-		$date_min = $today - (3600 * 24 * 30 * $nb_month_old);	//Do not use a fast changing value such as time() to allow SQL caching
-		$keepHistoryDefault = $this->view->conf->keep_history_default;
+		Minz_View::appendScript(Minz_Url::display('/scripts/global_view.js?' . @filemtime(PUBLIC_PATH . '/scripts/global_view.js')));
 
 		try {
-			$entries = $entryDAO->listWhere($getType, $getId, $state, $order, $nb + 1, $first, $filter, $date_min, $keepHistoryDefault);
-
-			// Si on a récupéré aucun article "non lus"
-			// on essaye de récupérer tous les articles
-			if ($state === 'not_read' && empty($entries)) {
-				Minz_Log::record ('Conflicting information about nbNotRead!', Minz_Log::DEBUG);
-				$this->view->state = 'all';
-				$entries = $entryDAO->listWhere($getType, $getId, 'all', $order, $nb, $first, $filter, $date_min, $keepHistoryDefault);
-			}
+			$this->updateContext();
+		} catch (FreshRSS_Context_Exception $e) {
+			Minz_Error::error(404);
+		}
 
-			if (count($entries) <= $nb) {
-				$this->view->nextId  = '';
-			} else {	//We have more elements for pagination
-				$lastEntry = array_pop($entries);
-				$this->view->nextId  = $lastEntry->id();
-			}
+		$this->view->categories = FreshRSS_Context::$categories;
 
-			$this->view->entries = $entries;
-		} catch (FreshRSS_EntriesGetter_Exception $e) {
-			Minz_Log::record ($e->getMessage (), Minz_Log::NOTICE);
-			Minz_Error::error (
-				404,
-				array ('error' => array (Minz_Translate::t ('page_not_found')))
-			);
+		$this->view->rss_title = FreshRSS_Context::$name . ' | ' . Minz_View::title();
+		$title = _t('index.feed.title_global');
+		if (FreshRSS_Context::$get_unread > 0) {
+			$title = '(' . FreshRSS_Context::$get_unread . ') ' . $title;
 		}
+		Minz_View::prependTitle($title . ' · ');
 	}
 
-	/*
-	 * Vérifie que la catégorie / flux sélectionné existe
-	 * + Initialise correctement les variables de vue get_c et get_f
-	 * + Met à jour la variable $this->nb_not_read_cat
+	/**
+	 * This action displays the RSS feed of FreshRSS.
 	 */
-	private function checkAndProcessType ($getType, $getId) {
-		switch ($getType) {
-			case 'a':
-				$this->view->currentName = Minz_Translate::t ('your_rss_feeds');
-				$this->nb_not_read_cat = $this->view->nb_not_read;
-				$this->view->get_c = $getType;
-				return true;
-			case 's':
-				$this->view->currentName = Minz_Translate::t ('your_favorites');
-				$this->nb_not_read_cat = $this->view->nb_favorites['unread'];
-				$this->view->get_c = $getType;
-				return true;
-			case 'c':
-				$cat = isset($this->view->cat_aside[$getId]) ? $this->view->cat_aside[$getId] : null;
-				if ($cat === null) {
-					$catDAO = new FreshRSS_CategoryDAO();
-					$cat = $catDAO->searchById($getId);
-				}
-				if ($cat) {
-					$this->view->currentName = $cat->name ();
-					$this->nb_not_read_cat = $cat->nbNotRead ();
-					$this->view->get_c = $getId;
-					return true;
-				} else {
-					return false;
-				}
-			case 'f':
-				$feed = FreshRSS_CategoryDAO::findFeed($this->view->cat_aside, $getId);
-				if (empty($feed)) {
-					$feedDAO = new FreshRSS_FeedDAO();
-					$feed = $feedDAO->searchById($getId);
-				}
-				if ($feed) {
-					$this->view->currentName = $feed->name ();
-					$this->nb_not_read_cat = $feed->nbNotRead ();
-					$this->view->get_f = $getId;
-					$this->view->get_c = $feed->category ();
-					return true;
-				} else {
-					return false;
-				}
-			default:
-				return false;
+	public function rssAction() {
+		$allow_anonymous = FreshRSS_Context::$system_conf->allow_anonymous;
+		$token = FreshRSS_Context::$user_conf->token;
+		$token_param = Minz_Request::param('token', '');
+		$token_is_ok = ($token != '' && $token === $token_param);
+
+		// Check if user has access.
+		if (!FreshRSS_Auth::hasAccess() &&
+				!$allow_anonymous &&
+				!$token_is_ok) {
+			Minz_Error::error(403);
 		}
-	}
-	
-	public function statsAction () {
-		if (!$this->view->loginOk) {
-			Minz_Error::error (
-				403,
-				array ('error' => array (Minz_Translate::t ('access_denied')))
-			);
+
+		try {
+			$this->updateContext();
+		} catch (FreshRSS_Context_Exception $e) {
+			Minz_Error::error(404);
 		}
 
-		Minz_View::prependTitle (Minz_Translate::t ('stats') . ' · ');
+		try {
+			$this->view->entries = FreshRSS_index_Controller::listEntriesByContext();
+		} catch (FreshRSS_EntriesGetter_Exception $e) {
+			Minz_Log::notice($e->getMessage());
+			Minz_Error::error(404);
+		}
 
-		$statsDAO = new FreshRSS_StatsDAO ();
-		Minz_View::appendScript (Minz_Url::display ('/scripts/flotr2.min.js?' . @filemtime(PUBLIC_PATH . '/scripts/flotr2.min.js')));
-		$this->view->repartition = $statsDAO->calculateEntryRepartition();
-		$this->view->count = ($statsDAO->calculateEntryCount());
-		$this->view->feedByCategory = $statsDAO->calculateFeedByCategory();
-		$this->view->entryByCategory = $statsDAO->calculateEntryByCategory();
-		$this->view->topFeed = $statsDAO->calculateTopFeed();
+		// No layout for RSS output.
+		$this->view->url = empty($_SERVER['QUERY_STRING']) ? '' : '?' . $_SERVER['QUERY_STRING'];
+		$this->view->rss_title = FreshRSS_Context::$name . ' | ' . Minz_View::title();
+		$this->view->_useLayout(false);
+		header('Content-Type: application/rss+xml; charset=utf-8');
 	}
 
-	public function aboutAction () {
-		Minz_View::prependTitle (Minz_Translate::t ('about') . ' · ');
-	}
+	/**
+	 * This action updates the Context object by using request parameters.
+	 *
+	 * Parameters are:
+	 *   - state (default: conf->default_view)
+	 *   - search (default: empty string)
+	 *   - order (default: conf->sort_order)
+	 *   - nb (default: conf->posts_per_page)
+	 *   - next (default: empty string)
+	 *   - hours (default: 0)
+	 */
+	private function updateContext() {
+		if (empty(FreshRSS_Context::$categories)) {
+			$catDAO = new FreshRSS_CategoryDAO();
+			FreshRSS_Context::$categories = $catDAO->listCategories();
+		}
 
-	public function logsAction () {
-		if (!$this->view->loginOk) {
-			Minz_Error::error (
-				403,
-				array ('error' => array (Minz_Translate::t ('access_denied')))
-			);
+		// Update number of read / unread variables.
+		$entryDAO = FreshRSS_Factory::createEntryDao();
+		FreshRSS_Context::$total_starred = $entryDAO->countUnreadReadFavorites();
+		FreshRSS_Context::$total_unread = FreshRSS_CategoryDAO::CountUnreads(
+			FreshRSS_Context::$categories, 1
+		);
+
+		FreshRSS_Context::_get(Minz_Request::param('get', 'a'));
+
+		FreshRSS_Context::$state = Minz_Request::param(
+			'state', FreshRSS_Context::$user_conf->default_state
+		);
+		$state_forced_by_user = Minz_Request::param('state', false) !== false;
+		if (FreshRSS_Context::$user_conf->default_view === 'adaptive' &&
+				FreshRSS_Context::$get_unread <= 0 &&
+				!FreshRSS_Context::isStateEnabled(FreshRSS_Entry::STATE_READ) &&
+				!$state_forced_by_user) {
+			FreshRSS_Context::$state |= FreshRSS_Entry::STATE_READ;
 		}
 
-		Minz_View::prependTitle (Minz_Translate::t ('logs') . ' · ');
+		FreshRSS_Context::$search = new FreshRSS_Search(Minz_Request::param('search', ''));
+		FreshRSS_Context::$order = Minz_Request::param(
+			'order', FreshRSS_Context::$user_conf->sort_order
+		);
+		FreshRSS_Context::$number = intval(Minz_Request::param('nb', FreshRSS_Context::$user_conf->posts_per_page));
+		if (FreshRSS_Context::$number > FreshRSS_Context::$user_conf->max_posts_per_rss) {
+			FreshRSS_Context::$number = max(
+				FreshRSS_Context::$user_conf->max_posts_per_rss,
+				FreshRSS_Context::$user_conf->posts_per_page);
+		}
+		FreshRSS_Context::$first_id = Minz_Request::param('next', '');
+		FreshRSS_Context::$sinceHours = intval(Minz_Request::param('hours', 0));
+	}
 
-		if (Minz_Request::isPost ()) {
-			FreshRSS_LogDAO::truncate();
+	/**
+	 * This method returns a list of entries based on the Context object.
+	 */
+	public static function listEntriesByContext() {
+		$entryDAO = FreshRSS_Factory::createEntryDao();
+
+		$get = FreshRSS_Context::currentGet(true);
+		if (count($get) > 1) {
+			$type = $get[0];
+			$id = $get[1];
+		} else {
+			$type = $get;
+			$id = '';
 		}
 
-		$logs = FreshRSS_LogDAO::lines();	//TODO: ask only the necessary lines
+		$limit = FreshRSS_Context::$number;
 
-		//gestion pagination
-		$page = Minz_Request::param ('page', 1);
-		$this->view->logsPaginator = new Minz_Paginator ($logs);
-		$this->view->logsPaginator->_nbItemsPerPage (50);
-		$this->view->logsPaginator->_currentPage ($page);
-	}
+		$date_min = 0;
+		if (FreshRSS_Context::$sinceHours) {
+			$date_min = time() - (FreshRSS_Context::$sinceHours * 3600);
+			$limit = FreshRSS_Context::$user_conf->max_posts_per_rss;
+		}
 
-	public function loginAction () {
-		$this->view->_useLayout (false);
-
-		$url = 'https://verifier.login.persona.org/verify';
-		$assert = Minz_Request::param ('assertion');
-		$params = 'assertion=' . $assert . '&audience=' .
-			  urlencode (Minz_Url::display (null, 'php', true));
-		$ch = curl_init ();
-		$options = array (
-			CURLOPT_URL => $url,
-			CURLOPT_RETURNTRANSFER => TRUE,
-			CURLOPT_POST => 2,
-			CURLOPT_POSTFIELDS => $params
+		$entries = $entryDAO->listWhere(
+			$type, $id, FreshRSS_Context::$state, FreshRSS_Context::$order,
+			$limit, FreshRSS_Context::$first_id,
+			FreshRSS_Context::$search, $date_min
 		);
-		curl_setopt_array ($ch, $options);
-		$result = curl_exec ($ch);
-		curl_close ($ch);
-
-		$res = json_decode ($result, true);
-
-		$loginOk = false;
-		$reason = '';
-		if ($res['status'] === 'okay') {
-			$email = filter_var($res['email'], FILTER_VALIDATE_EMAIL);
-			if ($email != '') {
-				$personaFile = DATA_PATH . '/persona/' . $email . '.txt';
-				if (($currentUser = @file_get_contents($personaFile)) !== false) {
-					$currentUser = trim($currentUser);
-					if (ctype_alnum($currentUser)) {
-						try {
-							$this->conf = new FreshRSS_Configuration($currentUser);
-							$loginOk = strcasecmp($email, $this->conf->mail_login) === 0;
-						} catch (Minz_Exception $e) {
-							$reason = 'Invalid configuration for user [' . $currentUser . ']! ' . $e->getMessage();	//Permission denied or conf file does not exist
-						}
-					} else {
-						$reason = 'Invalid username format [' . $currentUser . ']!';
-					}
-				}
-			} else {
-				$reason = 'Invalid email format [' . $res['email'] . ']!';
-			}
-		}
-		if ($loginOk) {
-			Minz_Session::_param('currentUser', $currentUser);
-			Minz_Session::_param ('mail', $email);
-			$this->view->loginOk = true;
-			invalidateHttpCache();
-		} else {
-			$res = array ();
-			$res['status'] = 'failure';
-			$res['reason'] = $reason == '' ? Minz_Translate::t ('invalid_login') : $reason;
-			Minz_Log::record ('Persona: ' . $res['reason'], Minz_Log::WARNING);
+
+		if (FreshRSS_Context::$sinceHours && (count($entries) < FreshRSS_Context::$user_conf->min_posts_per_rss)) {
+			$date_min = 0;
+			$limit = FreshRSS_Context::$user_conf->min_posts_per_rss;
+			$entries = $entryDAO->listWhere(
+				$type, $id, FreshRSS_Context::$state, FreshRSS_Context::$order,
+				$limit, FreshRSS_Context::$first_id,
+				FreshRSS_Context::$search, $date_min
+			);
 		}
 
-		header('Content-Type: application/json; charset=UTF-8');
-		$this->view->res = json_encode ($res);
+		return $entries;
 	}
 
-	public function logoutAction () {
-		$this->view->_useLayout(false);
-		invalidateHttpCache();
-		Minz_Session::_param('currentUser');
-		Minz_Session::_param('mail');
-		Minz_Session::_param('passwordHash');
+	/**
+	 * This action displays the about page of FreshRSS.
+	 */
+	public function aboutAction() {
+		Minz_View::prependTitle(_t('index.about.title') . ' · ');
 	}
 
-	public function formLoginAction () {
+	/**
+	 * This action displays logs of FreshRSS for the current user.
+	 */
+	public function logsAction() {
+		if (!FreshRSS_Auth::hasAccess()) {
+			Minz_Error::error(403);
+		}
+
+		Minz_View::prependTitle(_t('index.log.title') . ' · ');
+
 		if (Minz_Request::isPost()) {
-			$ok = false;
-			$nonce = Minz_Session::param('nonce');
-			$username = Minz_Request::param('username', '');
-			$c = Minz_Request::param('challenge', '');
-			if (ctype_alnum($username) && ctype_graph($c) && ctype_alnum($nonce)) {
-				if (!function_exists('password_verify')) {
-					include_once(LIB_PATH . '/password_compat.php');
-				}
-				try {
-					$conf = new FreshRSS_Configuration($username);
-					$s = $conf->passwordHash;
-					$ok = password_verify($nonce . $s, $c);
-					if ($ok) {
-						Minz_Session::_param('currentUser', $username);
-						Minz_Session::_param('passwordHash', $s);
-					} else {
-						Minz_Log::record('Password mismatch for user ' . $username . ', nonce=' . $nonce . ', c=' . $c, Minz_Log::WARNING);
-					}
-				} catch (Minz_Exception $me) {
-					Minz_Log::record('Login failure: ' . $me->getMessage(), Minz_Log::WARNING);
-				}
-			} else {
-				Minz_Log::record('Invalid credential parameters: user=' . $username . ' challenge=' . $c . ' nonce=' . $nonce, Minz_Log::DEBUG);
-			}
-			if (!$ok) {
-				$notif = array(
-					'type' => 'bad',
-					'content' => Minz_Translate::t('invalid_login')
-				);
-				Minz_Session::_param('notification', $notif);
-			}
-			$this->view->_useLayout(false);
-			Minz_Request::forward(array('c' => 'index', 'a' => 'index'), true);
-		} elseif (!Minz_Configuration::canLogIn()) {
-			Minz_Error::error (
-				403,
-				array ('error' => array (Minz_Translate::t ('access_denied')))
-			);
+			FreshRSS_LogDAO::truncate();
 		}
-		invalidateHttpCache();
-	}
 
-	public function formLogoutAction () {
-		$this->view->_useLayout(false);
-		invalidateHttpCache();
-		Minz_Session::_param('currentUser');
-		Minz_Session::_param('mail');
-		Minz_Session::_param('passwordHash');
-		Minz_Request::forward(array('c' => 'index', 'a' => 'index'), true);
+		$logs = FreshRSS_LogDAO::lines();	//TODO: ask only the necessary lines
+
+		//gestion pagination
+		$page = Minz_Request::param('page', 1);
+		$this->view->logsPaginator = new Minz_Paginator($logs);
+		$this->view->logsPaginator->_nbItemsPerPage(50);
+		$this->view->logsPaginator->_currentPage($page);
 	}
 }
diff --git a/app/Controllers/javascriptController.php b/app/Controllers/javascriptController.php
index 3d741e298..00a7b5c38 100755
--- a/app/Controllers/javascriptController.php
+++ b/app/Controllers/javascriptController.php
@@ -1,14 +1,14 @@
 <?php
 
 class FreshRSS_javascript_Controller extends Minz_ActionController {
-	public function firstAction () {
-		$this->view->_useLayout (false);
+	public function firstAction() {
+		$this->view->_useLayout(false);
 	}
 
-	public function actualizeAction () {
-		header('Content-Type: text/javascript; charset=UTF-8');
-		$feedDAO = new FreshRSS_FeedDAO ();
-		$this->view->feeds = $feedDAO->listFeedsOrderUpdate();
+	public function actualizeAction() {
+		header('Content-Type: application/json; charset=UTF-8');
+		$feedDAO = FreshRSS_Factory::createFeedDao();
+		$this->view->feeds = $feedDAO->listFeedsOrderUpdate(FreshRSS_Context::$user_conf->ttl_default);
 	}
 
 	public function nbUnreadsPerFeedAction() {
@@ -28,19 +28,27 @@ class FreshRSS_javascript_Controller extends Minz_ActionController {
 		$user = isset($_GET['user']) ? $_GET['user'] : '';
 		if (ctype_alnum($user)) {
 			try {
-				$conf = new FreshRSS_Configuration($user);
+				$salt = FreshRSS_Context::$system_conf->salt;
+				$conf = get_user_configuration($user);
 				$s = $conf->passwordHash;
 				if (strlen($s) >= 60) {
 					$this->view->salt1 = substr($s, 0, 29);	//CRYPT_BLOWFISH Salt: "$2a$", a two digit cost parameter, "$", and 22 characters from the alphabet "./0-9A-Za-z".
-					$this->view->nonce = sha1(Minz_Configuration::salt() . uniqid(mt_rand(), true));
+					$this->view->nonce = sha1($salt . uniqid(mt_rand(), true));
 					Minz_Session::_param('nonce', $this->view->nonce);
 					return;	//Success
 				}
 			} catch (Minz_Exception $me) {
-				Minz_Log::record('Nonce failure: ' . $me->getMessage(), Minz_Log::WARNING);
+				Minz_Log::warning('Nonce failure: ' . $me->getMessage());
 			}
+		} else {
+			Minz_Log::notice('Nonce failure due to invalid username!');
+		}
+		//Failure: Return random data.
+		$this->view->salt1 = sprintf('$2a$%02d$', FreshRSS_user_Controller::BCRYPT_COST);
+		$alphabet = './ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+		for ($i = 22; $i > 0; $i--) {
+			$this->view->salt1 .= $alphabet[rand(0, 63)];
 		}
-		$this->view->nonce = '';	//Failure
-		$this->view->salt1 = '';
+		$this->view->nonce = sha1(rand());
 	}
 }
diff --git a/app/Controllers/statsController.php b/app/Controllers/statsController.php
new file mode 100644
index 000000000..5d1dee72c
--- /dev/null
+++ b/app/Controllers/statsController.php
@@ -0,0 +1,150 @@
+<?php
+
+/**
+ * Controller to handle application statistics.
+ */
+class FreshRSS_stats_Controller extends Minz_ActionController {
+
+	/**
+	 * This action is called before every other action in that class. It is
+	 * the common boiler plate for every action. It is triggered by the
+	 * underlying framework.
+	 */
+	public function firstAction() {
+		if (!FreshRSS_Auth::hasAccess()) {
+			Minz_Error::error(403);
+		}
+
+		Minz_View::prependTitle(_t('admin.stats.title') . ' · ');
+	}
+
+	private function convertToSerie($data) {
+		$serie = array();
+
+		foreach ($data as $key => $value) {
+			$serie[] = array($key, $value);
+		}
+
+		return $serie;
+	}
+
+	private function convertToPieSerie($data) {
+		$serie = array();
+
+		foreach ($data as $value) {
+			$value['data'] = array(array(0, (int) $value['data']));
+			$serie[] = $value;
+		}
+
+		return $serie;
+	}
+
+	/**
+	 * This action handles the statistic main page.
+	 *
+	 * It displays the statistic main page.
+	 * The values computed to display the page are:
+	 *   - repartition of read/unread/favorite/not favorite
+	 *   - number of article per day
+	 *   - number of feed by category
+	 *   - number of article by category
+	 *   - list of most prolific feed
+	 */
+	public function indexAction() {
+		$statsDAO = FreshRSS_Factory::createStatsDAO();
+		Minz_View::appendScript(Minz_Url::display('/scripts/flotr2.min.js?' . @filemtime(PUBLIC_PATH . '/scripts/flotr2.min.js')));
+		$this->view->repartition = $statsDAO->calculateEntryRepartition();
+		$entryCount = $statsDAO->calculateEntryCount();
+		$this->view->count = $this->convertToSerie($entryCount);
+		$this->view->average = round(array_sum(array_values($entryCount)) / count($entryCount), 2);
+		$this->view->feedByCategory = $this->convertToPieSerie($statsDAO->calculateFeedByCategory());
+		$this->view->entryByCategory = $this->convertToPieSerie($statsDAO->calculateEntryByCategory());
+		$this->view->topFeed = $statsDAO->calculateTopFeed();
+	}
+
+	/**
+	 * This action handles the idle feed statistic page.
+	 *
+	 * It displays the list of idle feed for different period. The supported
+	 * periods are:
+	 *   - last year
+	 *   - last 6 months
+	 *   - last 3 months
+	 *   - last month
+	 *   - last week
+	 */
+	public function idleAction() {
+		$statsDAO = FreshRSS_Factory::createStatsDAO();
+		$feeds = $statsDAO->calculateFeedLastDate();
+		$idleFeeds = array(
+			'last_year' => array(),
+			'last_6_month' => array(),
+			'last_3_month' => array(),
+			'last_month' => array(),
+			'last_week' => array(),
+		);
+		$now = new \DateTime();
+		$feedDate = clone $now;
+		$lastWeek = clone $now;
+		$lastWeek->modify('-1 week');
+		$lastMonth = clone $now;
+		$lastMonth->modify('-1 month');
+		$last3Month = clone $now;
+		$last3Month->modify('-3 month');
+		$last6Month = clone $now;
+		$last6Month->modify('-6 month');
+		$lastYear = clone $now;
+		$lastYear->modify('-1 year');
+
+		foreach ($feeds as $feed) {
+			$feedDate->setTimestamp($feed['last_date']);
+			if ($feedDate >= $lastWeek) {
+				continue;
+			}
+			if ($feedDate < $lastYear) {
+				$idleFeeds['last_year'][] = $feed;
+			} elseif ($feedDate < $last6Month) {
+				$idleFeeds['last_6_month'][] = $feed;
+			} elseif ($feedDate < $last3Month) {
+				$idleFeeds['last_3_month'][] = $feed;
+			} elseif ($feedDate < $lastMonth) {
+				$idleFeeds['last_month'][] = $feed;
+			} elseif ($feedDate < $lastWeek) {
+				$idleFeeds['last_week'][] = $feed;
+			}
+		}
+
+		$this->view->idleFeeds = $idleFeeds;
+	}
+
+	/**
+	 * This action handles the article repartition statistic page.
+	 *
+	 * It displays the number of article and the average of article for the
+	 * following periods:
+	 *   - hour of the day
+	 *   - day of the week
+	 *   - month
+	 *
+	 * @todo verify that the metrics used here make some sense. Especially
+	 *       for the average.
+	 */
+	public function repartitionAction() {
+		$statsDAO = FreshRSS_Factory::createStatsDAO();
+		$categoryDAO = new FreshRSS_CategoryDAO();
+		$feedDAO = FreshRSS_Factory::createFeedDao();
+		Minz_View::appendScript(Minz_Url::display('/scripts/flotr2.min.js?' . @filemtime(PUBLIC_PATH . '/scripts/flotr2.min.js')));
+		$id = Minz_Request::param('id', null);
+		$this->view->categories = $categoryDAO->listCategories();
+		$this->view->feed = $feedDAO->searchById($id);
+		$this->view->days = $statsDAO->getDays();
+		$this->view->months = $statsDAO->getMonths();
+		$this->view->repartition = $statsDAO->calculateEntryRepartitionPerFeed($id);
+		$this->view->repartitionHour = $this->convertToSerie($statsDAO->calculateEntryRepartitionPerFeedPerHour($id));
+		$this->view->averageHour = $statsDAO->calculateEntryAveragePerFeedPerHour($id);
+		$this->view->repartitionDayOfWeek = $this->convertToSerie($statsDAO->calculateEntryRepartitionPerFeedPerDayOfWeek($id));
+		$this->view->averageDayOfWeek = $statsDAO->calculateEntryAveragePerFeedPerDayOfWeek($id);
+		$this->view->repartitionMonth = $this->convertToSerie($statsDAO->calculateEntryRepartitionPerFeedPerMonth($id));
+		$this->view->averageMonth = $statsDAO->calculateEntryAveragePerFeedPerMonth($id);
+	}
+}
diff --git a/app/Controllers/subscriptionController.php b/app/Controllers/subscriptionController.php
new file mode 100644
index 000000000..03d3ee15e
--- /dev/null
+++ b/app/Controllers/subscriptionController.php
@@ -0,0 +1,116 @@
+<?php
+
+/**
+ * Controller to handle subscription actions.
+ */
+class FreshRSS_subscription_Controller extends Minz_ActionController {
+	/**
+	 * This action is called before every other action in that class. It is
+	 * the common boiler plate for every action. It is triggered by the
+	 * underlying framework.
+	 */
+	public function firstAction() {
+		if (!FreshRSS_Auth::hasAccess()) {
+			Minz_Error::error(403);
+		}
+
+		$catDAO = new FreshRSS_CategoryDAO();
+
+		$catDAO->checkDefault();
+		$this->view->categories = $catDAO->listCategories(false);
+		$this->view->default_category = $catDAO->getDefault();
+	}
+
+	/**
+	 * This action handles the main subscription page
+	 *
+	 * It displays categories and associated feeds.
+	 */
+	public function indexAction() {
+		Minz_View::appendScript(Minz_Url::display('/scripts/category.js?' .
+		                        @filemtime(PUBLIC_PATH . '/scripts/category.js')));
+		Minz_View::prependTitle(_t('sub.title') . ' · ');
+
+		$id = Minz_Request::param('id');
+		if ($id !== false) {
+			$feedDAO = FreshRSS_Factory::createFeedDao();
+			$this->view->feed = $feedDAO->searchById($id);
+		}
+	}
+
+	/**
+	 * This action handles the feed configuration page.
+	 *
+	 * It displays the feed configuration page.
+	 * If this action is reached through a POST request, it stores all new
+	 * configuraiton values then sends a notification to the user.
+	 *
+	 * The options available on the page are:
+	 *   - name
+	 *   - description
+	 *   - website URL
+	 *   - feed URL
+	 *   - category id (default: default category id)
+	 *   - CSS path to article on website
+	 *   - display in main stream (default: 0)
+	 *   - HTTP authentication
+	 *   - number of article to retain (default: -2)
+	 *   - refresh frequency (default: -2)
+	 * Default values are empty strings unless specified.
+	 */
+	public function feedAction() {
+		if (Minz_Request::param('ajax')) {
+			$this->view->_useLayout(false);
+		}
+
+		$feedDAO = FreshRSS_Factory::createFeedDao();
+		$this->view->feeds = $feedDAO->listFeeds();
+
+		$id = Minz_Request::param('id');
+		if ($id === false || !isset($this->view->feeds[$id])) {
+			Minz_Error::error(404);
+			return;
+		}
+
+		$this->view->feed = $this->view->feeds[$id];
+
+		Minz_View::prependTitle(_t('sub.title.feed_management') . ' · ' . $this->view->feed->name() . ' · ');
+
+		if (Minz_Request::isPost()) {
+			$user = trim(Minz_Request::param('http_user_feed' . $id, ''));
+			$pass = Minz_Request::param('http_pass_feed' . $id, '');
+
+			$httpAuth = '';
+			if ($user != '' && $pass != '') {	//TODO: Sanitize
+				$httpAuth = $user . ':' . $pass;
+			}
+
+			$cat = intval(Minz_Request::param('category', 0));
+
+			$values = array(
+				'name' => Minz_Request::param('name', ''),
+				'description' => sanitizeHTML(Minz_Request::param('description', '', true)),
+				'website' => Minz_Request::param('website', ''),
+				'url' => Minz_Request::param('url', ''),
+				'category' => $cat,
+				'pathEntries' => Minz_Request::param('path_entries', ''),
+				'priority' => intval(Minz_Request::param('priority', 0)),
+				'httpAuth' => $httpAuth,
+				'keep_history' => intval(Minz_Request::param('keep_history', -2)),
+				'ttl' => intval(Minz_Request::param('ttl', -2)),
+			);
+
+			invalidateHttpCache();
+
+			$url_redirect = array('c' => 'subscription', 'params' => array('id' => $id));
+			if ($feedDAO->updateFeed($id, $values) !== false) {
+				$this->view->feed->_category($cat);
+				$this->view->feed->faviconPrepare();
+
+				Minz_Request::good(_t('feedback.sub.feed.updated'), $url_redirect);
+			} else {
+				Minz_Request::bad(_t('feedback.sub.feed.error'), $url_redirect);
+			}
+		}
+	}
+}
diff --git a/app/Controllers/updateController.php b/app/Controllers/updateController.php
new file mode 100644
index 000000000..8f939dbdb
--- /dev/null
+++ b/app/Controllers/updateController.php
@@ -0,0 +1,226 @@
+<?php
+
+class FreshRSS_update_Controller extends Minz_ActionController {
+
+	public static function isGit() {
+		return is_dir(FRESHRSS_PATH . '/.git/');
+	}
+
+	public static function hasGitUpdate() {
+		$cwd = getcwd();
+		chdir(FRESHRSS_PATH);
+		$output = array();
+		try {
+			exec('git fetch', $output, $return);
+			if ($return == 0) {
+				exec('git status -sb --porcelain remote', $output, $return);
+			} else {
+				$line = is_array($output) ? implode('; ', $output) : '' . $output;
+				Minz_Log::warning('git fetch warning:' . $line);
+			}
+		} catch (Exception $e) {
+			Minz_Log::warning('git fetch error:' . $e->getMessage());
+		}
+		chdir($cwd);
+		$line = is_array($output) ? implode('; ', $output) : '' . $output;
+		return strpos($line, '[behind') !== false;
+	}
+
+	public static function gitPull() {
+		$cwd = getcwd();
+		chdir(FRESHRSS_PATH);
+		$output = array();
+		$return = 1;
+		try {
+			exec('git pull --ff-only', $output, $return);
+		} catch (Exception $e) {
+			Minz_Log::warning('git pull error:' . $e->getMessage());
+		}
+		chdir($cwd);
+		$line = is_array($output) ? implode('; ', $output) : '' . $output;
+		return $return == 0 ? true : 'Git error: ' . $line;
+	}
+
+	public function firstAction() {
+		if (!FreshRSS_Auth::hasAccess('admin')) {
+			Minz_Error::error(403);
+		}
+
+		invalidateHttpCache();
+
+		$this->view->update_to_apply = false;
+		$this->view->last_update_time = 'unknown';
+		$timestamp = @filemtime(join_path(DATA_PATH, 'last_update.txt'));
+		if ($timestamp !== false) {
+			$this->view->last_update_time = timestamptodate($timestamp);
+		}
+	}
+
+	public function indexAction() {
+		Minz_View::prependTitle(_t('admin.update.title') . ' · ');
+
+		if (!is_writable(FRESHRSS_PATH)) {
+			$this->view->message = array(
+				'status' => 'bad',
+				'title' => _t('gen.short.damn'),
+				'body' => _t('feedback.update.file_is_nok', FRESHRSS_PATH)
+			);
+		} elseif (file_exists(UPDATE_FILENAME)) {
+			// There is an update file to apply!
+			$version = @file_get_contents(join_path(DATA_PATH, 'last_update.txt'));
+			if (empty($version)) {
+				$version = 'unknown';
+			}
+			$this->view->update_to_apply = true;
+			$this->view->message = array(
+				'status' => 'good',
+				'title' => _t('gen.short.ok'),
+				'body' => _t('feedback.update.can_apply', $version)
+			);
+		}
+	}
+
+	public function checkAction() {
+		$this->view->change_view('update', 'index');
+
+		if (file_exists(UPDATE_FILENAME)) {
+			// There is already an update file to apply: we don't need to check
+			// the webserver!
+			// Or if already check during the last hour, do nothing.
+			Minz_Request::forward(array('c' => 'update'), true);
+
+			return;
+		}
+
+		$script = '';
+		$version = '';
+
+		if (self::isGit()) {
+			if (self::hasGitUpdate()) {
+				$version = 'git';
+			} else {
+				$this->view->message = array(
+					'status' => 'bad',
+					'title' => _t('gen.short.damn'),
+					'body' => _t('feedback.update.none')
+				);
+				@touch(join_path(DATA_PATH, 'last_update.txt'));
+				return;
+			}
+		} else {
+			$auto_update_url = FreshRSS_Context::$system_conf->auto_update_url . '?v=' . FRESHRSS_VERSION;
+			Minz_Log::debug('HTTP GET ' . $auto_update_url);
+			$c = curl_init($auto_update_url);
+			curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
+			curl_setopt($c, CURLOPT_SSL_VERIFYPEER, true);
+			curl_setopt($c, CURLOPT_SSL_VERIFYHOST, 2);
+			$result = curl_exec($c);
+			$c_status = curl_getinfo($c, CURLINFO_HTTP_CODE);
+			$c_error = curl_error($c);
+			curl_close($c);
+
+			if ($c_status !== 200) {
+				Minz_Log::warning(
+					'Error during update (HTTP code ' . $c_status . '): ' . $c_error
+				);
+
+				$this->view->message = array(
+					'status' => 'bad',
+					'title' => _t('gen.short.damn'),
+					'body' => _t('feedback.update.server_not_found', $auto_update_url)
+				);
+				return;
+			}
+
+			$res_array = explode("\n", $result, 2);
+			$status = $res_array[0];
+			if (strpos($status, 'UPDATE') !== 0) {
+				$this->view->message = array(
+					'status' => 'bad',
+					'title' => _t('gen.short.damn'),
+					'body' => _t('feedback.update.none')
+				);
+				@touch(join_path(DATA_PATH, 'last_update.txt'));
+				return;
+			}
+
+			$script = $res_array[1];
+			$version = explode(' ', $status, 2);
+			$version = $version[1];
+		}
+
+		if (file_put_contents(UPDATE_FILENAME, $script) !== false) {
+			@file_put_contents(join_path(DATA_PATH, 'last_update.txt'), $version);
+			Minz_Request::forward(array('c' => 'update'), true);
+		} else {
+			$this->view->message = array(
+				'status' => 'bad',
+				'title' => _t('gen.short.damn'),
+				'body' => _t('feedback.update.error', 'Cannot save the update script')
+			);
+		}
+	}
+
+	public function applyAction() {
+		if (!file_exists(UPDATE_FILENAME) || !is_writable(FRESHRSS_PATH)) {
+			Minz_Request::forward(array('c' => 'update'), true);
+		}
+
+		if (Minz_Request::param('post_conf', false)) {
+			if (self::isGit()) {
+				$res = !self::hasGitUpdate();
+			} else {
+				require(UPDATE_FILENAME);
+				$res = do_post_update();
+			}
+
+			Minz_ExtensionManager::callHook('post_update');
+
+			if ($res === true) {
+				@unlink(UPDATE_FILENAME);
+				@file_put_contents(join_path(DATA_PATH, 'last_update.txt'), '');
+				Minz_Request::good(_t('feedback.update.finished'));
+			} else {
+				Minz_Request::bad(_t('feedback.update.error', $res),
+				                  array('c' => 'update', 'a' => 'index'));
+			}
+		} else {
+			$res = false;
+
+			if (self::isGit()) {
+				$res = self::gitPull();
+			} else {
+				if (Minz_Request::isPost()) {
+					save_info_update();
+				}
+				if (!need_info_update()) {
+					$res = apply_update();
+				} else {
+					return;
+				}
+			}
+
+			if ($res === true) {
+				Minz_Request::forward(array(
+					'c' => 'update',
+					'a' => 'apply',
+					'params' => array('post_conf' => true)
+				), true);
+			} else {
+				Minz_Request::bad(_t('feedback.update.error', $res),
+				                  array('c' => 'update', 'a' => 'index'));
+			}
+		}
+	}
+
+	/**
+	 * This action displays information about installation.
+	 */
+	public function checkInstallAction() {
+		Minz_View::prependTitle(_t('admin.check_install.title') . ' · ');
+
+		$this->view->status_php = check_install_php();
+		$this->view->status_files = check_install_files();
+		$this->view->status_database = check_install_database();
+	}
+}
diff --git a/app/Controllers/userController.php b/app/Controllers/userController.php
new file mode 100644
index 000000000..9d6ae18e6
--- /dev/null
+++ b/app/Controllers/userController.php
@@ -0,0 +1,257 @@
+<?php
+
+/**
+ * Controller to handle user actions.
+ */
+class FreshRSS_user_Controller extends Minz_ActionController {
+	// Will also have to be computed client side on mobile devices,
+	// so do not use a too high cost
+	const BCRYPT_COST = 9;
+
+	/**
+	 * This action is called before every other action in that class. It is
+	 * the common boiler plate for every action. It is triggered by the
+	 * underlying framework.
+	 *
+	 * @todo clean up the access condition.
+	 */
+	public function firstAction() {
+		if (!FreshRSS_Auth::hasAccess() && !(
+				Minz_Request::actionName() === 'create' &&
+				!max_registrations_reached()
+		)) {
+			Minz_Error::error(403);
+		}
+	}
+
+	public static function hashPassword($passwordPlain) {
+		if (!function_exists('password_hash')) {
+			include_once(LIB_PATH . '/password_compat.php');
+		}
+		$passwordHash = password_hash($passwordPlain, PASSWORD_BCRYPT, array('cost' => self::BCRYPT_COST));
+		$passwordPlain = '';
+		$passwordHash = preg_replace('/^\$2[xy]\$/', '\$2a\$', $passwordHash);	//Compatibility with bcrypt.js
+		return $passwordHash == '' ? '' : $passwordHash;
+	}
+
+	/**
+	 * This action displays the user profile page.
+	 */
+	public function profileAction() {
+		Minz_View::prependTitle(_t('conf.profile.title') . ' · ');
+
+		Minz_View::appendScript(Minz_Url::display(
+			'/scripts/bcrypt.min.js?' . @filemtime(PUBLIC_PATH . '/scripts/bcrypt.min.js')
+		));
+
+		if (Minz_Request::isPost()) {
+			$ok = true;
+
+			$passwordPlain = Minz_Request::param('newPasswordPlain', '', true);
+			if ($passwordPlain != '') {
+				Minz_Request::_param('newPasswordPlain');	//Discard plain-text password ASAP
+				$_POST['newPasswordPlain'] = '';
+				$passwordHash = self::hashPassword($passwordPlain);
+				$ok &= ($passwordHash != '');
+				FreshRSS_Context::$user_conf->passwordHash = $passwordHash;
+			}
+			Minz_Session::_param('passwordHash', FreshRSS_Context::$user_conf->passwordHash);
+
+			$passwordPlain = Minz_Request::param('apiPasswordPlain', '', true);
+			if ($passwordPlain != '') {
+				$passwordHash = self::hashPassword($passwordPlain);
+				$ok &= ($passwordHash != '');
+				FreshRSS_Context::$user_conf->apiPasswordHash = $passwordHash;
+			}
+
+			$ok &= FreshRSS_Context::$user_conf->save();
+
+			if ($ok) {
+				Minz_Request::good(_t('feedback.profile.updated'),
+				                   array('c' => 'user', 'a' => 'profile'));
+			} else {
+				Minz_Request::bad(_t('feedback.profile.error'),
+				                  array('c' => 'user', 'a' => 'profile'));
+			}
+		}
+	}
+
+	/**
+	 * This action displays the user management page.
+	 */
+	public function manageAction() {
+		if (!FreshRSS_Auth::hasAccess('admin')) {
+			Minz_Error::error(403);
+		}
+
+		Minz_View::prependTitle(_t('admin.user.title') . ' · ');
+
+		// Get the correct current user.
+		$username = Minz_Request::param('u', Minz_Session::param('currentUser'));
+		if (!FreshRSS_UserDAO::exist($username)) {
+			$username = Minz_Session::param('currentUser');
+		}
+		$this->view->current_user = $username;
+
+		// Get information about the current user.
+		$entryDAO = FreshRSS_Factory::createEntryDao($this->view->current_user);
+		$this->view->nb_articles = $entryDAO->count();
+		$this->view->size_user = $entryDAO->size();
+	}
+
+	public static function createUser($new_user_name, $passwordPlain, $apiPasswordPlain, $userConfig = array(), $insertDefaultFeeds = true) {
+		if (!is_array($userConfig)) {
+			$userConfig = array();
+		}
+
+		$ok = ($new_user_name != '') && ctype_alnum($new_user_name);
+
+		if ($ok) {
+			$languages = Minz_Translate::availableLanguages();
+			if (empty($userConfig['language']) || !in_array($userConfig['language'], $languages)) {
+				$userConfig['language'] = 'en';
+			}
+
+			$ok &= !in_array(strtoupper($new_user_name), array_map('strtoupper', listUsers()));	//Not an existing user, case-insensitive
+
+			$configPath = join_path(DATA_PATH, 'users', $new_user_name, 'config.php');
+			$ok &= !file_exists($configPath);
+		}
+		if ($ok) {
+			$passwordHash = '';
+			if ($passwordPlain != '') {
+				$passwordHash = self::hashPassword($passwordPlain);
+				$ok &= ($passwordHash != '');
+			}
+
+			$apiPasswordHash = '';
+			if ($apiPasswordPlain != '') {
+				$apiPasswordHash = self::hashPassword($apiPasswordPlain);
+				$ok &= ($apiPasswordHash != '');
+			}
+		}
+		if ($ok) {
+			mkdir(join_path(DATA_PATH, 'users', $new_user_name));
+			$userConfig['passwordHash'] = $passwordHash;
+			$userConfig['apiPasswordHash'] = $apiPasswordHash;
+			$ok &= (file_put_contents($configPath, "<?php\n return " . var_export($userConfig, true) . ';') !== false);
+		}
+		if ($ok) {
+			$userDAO = new FreshRSS_UserDAO();
+			$ok &= $userDAO->createUser($new_user_name, $userConfig['language'], $insertDefaultFeeds);
+		}
+		return $ok;
+	}
+
+	/**
+	 * This action creates a new user.
+	 *
+	 * Request parameters are:
+	 *   - new_user_language
+	 *   - new_user_name
+	 *   - new_user_passwordPlain
+	 *   - r (i.e. a redirection url, optional)
+	 *
+	 * @todo clean up this method. Idea: write a method to init a user with basic information.
+	 * @todo handle r redirection in Minz_Request::forward directly?
+	 */
+	public function createAction() {
+		if (Minz_Request::isPost() && (
+				FreshRSS_Auth::hasAccess('admin') ||
+				!max_registrations_reached()
+		)) {
+			$new_user_name = Minz_Request::param('new_user_name');
+			$passwordPlain = Minz_Request::param('new_user_passwordPlain', '', true);
+			$new_user_language = Minz_Request::param('new_user_language', FreshRSS_Context::$user_conf->language);
+
+			$ok = self::createUser($new_user_name, $passwordPlain, '', array('language' => $new_user_language));
+			Minz_Request::_param('new_user_passwordPlain');	//Discard plain-text password ASAP
+			$_POST['new_user_passwordPlain'] = '';
+			invalidateHttpCache();
+
+			$notif = array(
+				'type' => $ok ? 'good' : 'bad',
+				'content' => _t('feedback.user.created' . (!$ok ? '.error' : ''), $new_user_name)
+			);
+			Minz_Session::_param('notification', $notif);
+		}
+
+		$redirect_url = urldecode(Minz_Request::param('r', false, true));
+		if (!$redirect_url) {
+			$redirect_url = array('c' => 'user', 'a' => 'manage');
+		}
+		Minz_Request::forward($redirect_url, true);
+	}
+
+	public static function deleteUser($username) {
+		$db = FreshRSS_Context::$system_conf->db;
+		require_once(APP_PATH . '/SQL/install.sql.' . $db['type'] . '.php');
+
+		$ok = ctype_alnum($username);
+		if ($ok) {
+			$default_user = FreshRSS_Context::$system_conf->default_user;
+			$ok &= (strcasecmp($username, $default_user) !== 0);	//It is forbidden to delete the default user
+		}
+		$user_data = join_path(DATA_PATH, 'users', $username);
+		if ($ok) {
+			$ok &= is_dir($user_data);
+		}
+		if ($ok) {
+			$userDAO = new FreshRSS_UserDAO();
+			$ok &= $userDAO->deleteUser($username);
+			$ok &= recursive_unlink($user_data);
+		}
+		return $ok;
+	}
+
+	/**
+	 * This action delete an existing user.
+	 *
+	 * Request parameter is:
+	 *   - username
+	 *
+	 * @todo clean up this method. Idea: create a User->clean() method.
+	 */
+	public function deleteAction() {
+		$username = Minz_Request::param('username');
+		$redirect_url = urldecode(Minz_Request::param('r', false, true));
+		if (!$redirect_url) {
+			$redirect_url = array('c' => 'user', 'a' => 'manage');
+		}
+
+		$self_deletion = Minz_Session::param('currentUser', '_') === $username;
+
+		if (Minz_Request::isPost() && (
+				FreshRSS_Auth::hasAccess('admin') ||
+				$self_deletion
+		)) {
+			$ok = true;
+			if ($ok && $self_deletion) {
+				// We check the password if it's a self-destruction
+				$nonce = Minz_Session::param('nonce');
+				$challenge = Minz_Request::param('challenge', '');
+
+				$ok &= FreshRSS_FormAuth::checkCredentials(
+					$username, FreshRSS_Context::$user_conf->passwordHash,
+					$nonce, $challenge
+				);
+			}
+			if ($ok) {
+				$ok &= self::deleteUser($username);
+			}
+			if ($ok && $self_deletion) {
+				FreshRSS_Auth::removeAccess();
+				$redirect_url = array('c' => 'index', 'a' => 'index');
+			}
+			invalidateHttpCache();
+
+			$notif = array(
+				'type' => $ok ? 'good' : 'bad',
+				'content' => _t('feedback.user.deleted' . (!$ok ? '.error' : ''), $username)
+			);
+			Minz_Session::_param('notification', $notif);
+		}
+
+		Minz_Request::forward($redirect_url, true);
+	}
+}
diff --git a/app/Controllers/usersController.php b/app/Controllers/usersController.php
deleted file mode 100644
index bb4f34c5e..000000000
--- a/app/Controllers/usersController.php
+++ /dev/null
@@ -1,183 +0,0 @@
-<?php
-
-class FreshRSS_users_Controller extends Minz_ActionController {
-
-	const BCRYPT_COST = 9;	//Will also have to be computed client side on mobile devices, so do not use a too high cost
-
-	public function firstAction() {
-		if (!$this->view->loginOk) {
-			Minz_Error::error(
-				403,
-				array('error' => array(Minz_Translate::t('access_denied')))
-			);
-		}
-	}
-
-	public function authAction() {
-		if (Minz_Request::isPost()) {
-			$ok = true;
-
-			$passwordPlain = Minz_Request::param('passwordPlain', false);
-			if ($passwordPlain != '') {
-				Minz_Request::_param('passwordPlain');	//Discard plain-text password ASAP
-				$_POST['passwordPlain'] = '';
-				if (!function_exists('password_hash')) {
-					include_once(LIB_PATH . '/password_compat.php');
-				}
-				$passwordHash = password_hash($passwordPlain, PASSWORD_BCRYPT, array('cost' => self::BCRYPT_COST));
-				$passwordPlain = '';
-				$passwordHash = preg_replace('/^\$2[xy]\$/', '\$2a\$', $passwordHash);	//Compatibility with bcrypt.js
-				$ok &= ($passwordHash != '');
-				$this->view->conf->_passwordHash($passwordHash);
-			}
-			Minz_Session::_param('passwordHash', $this->view->conf->passwordHash);
-
-			if (Minz_Configuration::isAdmin(Minz_Session::param('currentUser', '_'))) {
-				$this->view->conf->_mail_login(Minz_Request::param('mail_login', false));
-			}
-			$email = $this->view->conf->mail_login;
-			Minz_Session::_param('mail', $email);
-
-			$ok &= $this->view->conf->save();
-
-			if ($email != '') {
-				$personaFile = DATA_PATH . '/persona/' . $email . '.txt';
-				@unlink($personaFile);
-				$ok &= (file_put_contents($personaFile, Minz_Session::param('currentUser', '_')) !== false);
-			}
-
-			if (Minz_Configuration::isAdmin(Minz_Session::param('currentUser', '_'))) {
-				$current_token = $this->view->conf->token;
-				$token = Minz_Request::param('token', $current_token);
-				$this->view->conf->_token($token);
-				$ok &= $this->view->conf->save();
-
-				$anon = Minz_Request::param('anon_access', false);
-				$anon = ((bool)$anon) && ($anon !== 'no');
-				$anon_refresh = Minz_Request::param('anon_refresh', false);
-				$anon_refresh = ((bool)$anon_refresh) && ($anon_refresh !== 'no');
-				$auth_type = Minz_Request::param('auth_type', 'none');
-				if ($anon != Minz_Configuration::allowAnonymous() ||
-					$auth_type != Minz_Configuration::authType() ||
-					$anon_refresh != Minz_Configuration::allowAnonymousRefresh()) {
-
-					Minz_Configuration::_authType($auth_type);
-					Minz_Configuration::_allowAnonymous($anon);
-					Minz_Configuration::_allowAnonymousRefresh($anon_refresh);
-					$ok &= Minz_Configuration::writeFile();
-				}
-			}
-
-			invalidateHttpCache();
-
-			$notif = array(
-				'type' => $ok ? 'good' : 'bad',
-				'content' => Minz_Translate::t($ok ? 'configuration_updated' : 'error_occurred')
-			);
-			Minz_Session::_param('notification', $notif);
-		}
-		Minz_Request::forward(array('c' => 'configure', 'a' => 'users'), true);
-	}
-
-	public function createAction() {
-		if (Minz_Request::isPost() && Minz_Configuration::isAdmin(Minz_Session::param('currentUser', '_'))) {
-			require_once(APP_PATH . '/sql.php');
-
-			$new_user_language = Minz_Request::param('new_user_language', $this->view->conf->language);
-			if (!in_array($new_user_language, $this->view->conf->availableLanguages())) {
-				$new_user_language = $this->view->conf->language;
-			}
-
-			$new_user_name = Minz_Request::param('new_user_name');
-			$ok = ($new_user_name != '') && ctype_alnum($new_user_name);
-
-			if ($ok) {
-				$ok &= (strcasecmp($new_user_name, Minz_Configuration::defaultUser()) !== 0);	//It is forbidden to alter the default user
-
-				$ok &= !in_array(strtoupper($new_user_name), array_map('strtoupper', listUsers()));	//Not an existing user, case-insensitive
-
-				$configPath = DATA_PATH . '/' . $new_user_name . '_user.php';
-				$ok &= !file_exists($configPath);
-			}
-			if ($ok) {
-			
-				$passwordPlain = Minz_Request::param('new_user_passwordPlain', false);
-				$passwordHash = '';
-				if ($passwordPlain != '') {
-					Minz_Request::_param('new_user_passwordPlain');	//Discard plain-text password ASAP
-					$_POST['new_user_passwordPlain'] = '';
-					if (!function_exists('password_hash')) {
-						include_once(LIB_PATH . '/password_compat.php');
-					}
-					$passwordHash = password_hash($passwordPlain, PASSWORD_BCRYPT, array('cost' => self::BCRYPT_COST));
-					$passwordPlain = '';
-					$passwordHash = preg_replace('/^\$2[xy]\$/', '\$2a\$', $passwordHash);	//Compatibility with bcrypt.js
-					$ok &= ($passwordHash != '');
-				}
-				if (empty($passwordHash)) {
-					$passwordHash = '';
-				}
-
-				$new_user_email = filter_var($_POST['new_user_email'], FILTER_VALIDATE_EMAIL);
-				if (empty($new_user_email)) {
-					$new_user_email = '';
-				} else {
-					$personaFile = DATA_PATH . '/persona/' . $new_user_email . '.txt';
-					@unlink($personaFile);
-					$ok &= (file_put_contents($personaFile, $new_user_name) !== false);
-				}
-			}
-			if ($ok) {
-				$config_array = array(
-					'language' => $new_user_language,
-					'passwordHash' => $passwordHash,
-					'mail_login' => $new_user_email,
-				);
-				$ok &= (file_put_contents($configPath, "<?php\n return " . var_export($config_array, true) . ';') !== false);
-			}
-			if ($ok) {
-				$userDAO = new FreshRSS_UserDAO();
-				$ok &= $userDAO->createUser($new_user_name);
-			}
-			invalidateHttpCache();
-
-			$notif = array(
-				'type' => $ok ? 'good' : 'bad',
-				'content' => Minz_Translate::t($ok ? 'user_created' : 'error_occurred', $new_user_name)
-			);
-			Minz_Session::_param('notification', $notif);
-		}
-		Minz_Request::forward(array('c' => 'configure', 'a' => 'users'), true);
-	}
-
-	public function deleteAction() {
-		if (Minz_Request::isPost() && Minz_Configuration::isAdmin(Minz_Session::param('currentUser', '_'))) {
-			require_once(APP_PATH . '/sql.php');
-
-			$username = Minz_Request::param('username');
-			$ok = ctype_alnum($username);
-
-			if ($ok) {
-				$ok &= (strcasecmp($username, Minz_Configuration::defaultUser()) !== 0);	//It is forbidden to delete the default user
-			}
-			if ($ok) {
-				$configPath = DATA_PATH . '/' . $username . '_user.php';
-				$ok &= file_exists($configPath);
-			}
-			if ($ok) {
-				$userDAO = new FreshRSS_UserDAO();
-				$ok &= $userDAO->deleteUser($username);
-				$ok &= unlink($configPath);
-				//TODO: delete Persona file
-			}
-			invalidateHttpCache();
-
-			$notif = array(
-				'type' => $ok ? 'good' : 'bad',
-				'content' => Minz_Translate::t($ok ? 'user_deleted' : 'error_occurred', $username)
-			);
-			Minz_Session::_param('notification', $notif);
-		}
-		Minz_Request::forward(array('c' => 'configure', 'a' => 'users'), true);
-	}
-}