Move to new directory structure

9 files changed, 0 insertions, 1118 deletions

diff --git a/service/feedservice.php b/service/feedservice.php
deleted file mode 100644
index 2d9bc6728..000000000
--- a/service/feedservice.php
+++ /dev/null
@@ -1,454 +0,0 @@
-<?php
-/**
- * ownCloud - News
- *
- * This file is licensed under the Affero General Public License version 3 or
- * later. See the COPYING file.
- *
- * @author Alessandro Cosentino <cosenal@gmail.com>
- * @author Bernhard Posselt <dev@bernhard-posselt.com>
- * @copyright Alessandro Cosentino 2012
- * @copyright Bernhard Posselt 2012, 2014
- */
-
-namespace OCA\News\Service;
-
-use HTMLPurifier;
-
-use OCP\ILogger;
-use OCP\IL10N;
-use OCP\AppFramework\Db\DoesNotExistException;
-
-use OCA\News\Db\Feed;
-use OCA\News\Db\Item;
-use OCA\News\Db\FeedMapper;
-use OCA\News\Db\ItemMapper;
-use OCA\News\Fetcher\Fetcher;
-use OCA\News\Fetcher\FetcherException;
-use OCA\News\Config\Config;
-use OCA\News\Utility\Time;
-
-
-class FeedService extends Service {
-
-    private $feedFetcher;
-    private $itemMapper;
-    private $feedMapper;
-    private $logger;
-    private $l10n;
-    private $timeFactory;
-    private $autoPurgeMinimumInterval;
-    private $purifier;
-    private $loggerParams;
-
-    public function __construct(FeedMapper $feedMapper,
-                                Fetcher $feedFetcher,
-                                ItemMapper $itemMapper,
-                                ILogger $logger,
-                                IL10N $l10n,
-                                Time $timeFactory,
-                                Config $config,
-                                HTMLPurifier $purifier,
-                                $LoggerParameters){
-        parent::__construct($feedMapper);
-        $this->feedFetcher = $feedFetcher;
-        $this->itemMapper = $itemMapper;
-        $this->logger = $logger;
-        $this->l10n = $l10n;
-        $this->timeFactory = $timeFactory;
-        $this->autoPurgeMinimumInterval =
-            $config->getAutoPurgeMinimumInterval();
-        $this->purifier = $purifier;
-        $this->feedMapper = $feedMapper;
-        $this->loggerParams = $LoggerParameters;
-    }
-
-    /**
-     * Finds all feeds of a user
-     * @param string $userId the name of the user
-     * @return Feed[]
-     */
-    public function findAll($userId){
-        return $this->feedMapper->findAllFromUser($userId);
-    }
-
-
-    /**
-     * Finds all feeds from all users
-     * @return array of feeds
-     */
-    public function findAllFromAllUsers() {
-        return $this->feedMapper->findAll();
-    }
-
-
-    /**
-     * Creates a new feed
-     * @param string $feedUrl the url to the feed
-     * @param int $folderId the folder where it should be put into, 0 for root
-     * folder
-     * @param string $userId for which user the feed should be created
-     * @param string $title if given, this is used for the opml feed title
-     * @param string $basicAuthUser if given, basic auth is set for this feed
-     * @param string $basicAuthPassword if given, basic auth is set for this
-     * feed. Ignored if user is null or an empty string
-     * @throws ServiceConflictException if the feed exists already
-     * @throws ServiceNotFoundException if the url points to an invalid feed
-     * @return Feed the newly created feed
-     */
-    public function create($feedUrl, $folderId, $userId, $title=null,
-                           $basicAuthUser=null, $basicAuthPassword=null){
-        // first try if the feed exists already
-        try {
-            list($feed, $items) = $this->feedFetcher->fetch($feedUrl, true,
-                                  null, null, false, $basicAuthUser,
-                                  $basicAuthPassword);
-
-            // try again if feed exists depending on the reported link
-            try {
-                $this->feedMapper->findByUrlHash($feed->getUrlHash(), $userId);
-                throw new ServiceConflictException(
-                    $this->l10n->t('Can not add feed: Exists already'));
-
-            // If no matching feed was found everything was ok
-            } catch(DoesNotExistException $ex){}
-
-            // insert feed
-            $itemCount = count($items);
-            $feed->setBasicAuthUser($basicAuthUser);
-            $feed->setBasicAuthPassword($basicAuthPassword);
-            $feed->setFolderId($folderId);
-            $feed->setUserId($userId);
-            $feed->setArticlesPerUpdate($itemCount);
-
-            if ($title !== null && $title !== '') {
-                $feed->setTitle($title);
-            }
-
-            $feed = $this->feedMapper->insert($feed);
-
-            // insert items in reverse order because the first one is usually
-            // the newest item
-            $unreadCount = 0;
-            for($i=$itemCount-1; $i>=0; $i--){
-                $item = $items[$i];
-                $item->setFeedId($feed->getId());
-
-                // check if item exists (guidhash is the same)
-                // and ignore it if it does
-                try {
-                    $this->itemMapper->findByGuidHash(
-                        $item->getGuidHash(), $item->getFeedId(), $userId);
-                    continue;
-                } catch(DoesNotExistException $ex){
-                    $unreadCount += 1;
-                    $item->setBody($this->purifier->purify($item->getBody()));
-                    $this->itemMapper->insert($item);
-                }
-            }
-
-            // set unread count
-            $feed->setUnreadCount($unreadCount);
-
-            return $feed;
-        } catch(FetcherException $ex){
-            $this->logger->debug($ex->getMessage(), $this->loggerParams);
-            throw new ServiceNotFoundException($ex->getMessage());
-        }
-    }
-
-
-    /**
-     * Runs all the feed updates
-     */
-    public function updateAll(){
-        // TODO: this method is not covered by any tests
-        $feeds = $this->feedMapper->findAll();
-        foreach($feeds as $feed){
-            try {
-                $this->update($feed->getId(), $feed->getUserId());
-            } catch(\Exception $ex){
-                // something is really wrong here, log it
-                $this->logger->error(
-                    'Unexpected error when updating feed ' . $ex->getMessage(),
-                    $this->loggerParams
-                );
-            }
-        }
-    }
-
-
-    /**
-     * Updates a single feed
-     * @param int $feedId the id of the feed that should be updated
-     * @param string $userId the id of the user
-     * @param bool $forceUpdate update even if the article exists already
-     * @throws ServiceNotFoundException if the feed does not exist
-     * @return Feed the updated feed entity
-     */
-    public function update($feedId, $userId, $forceUpdate=false){
-        $existingFeed = $this->find($feedId, $userId);
-
-        if($existingFeed->getPreventUpdate() === true) {
-            return $existingFeed;
-        }
-
-        // for backwards compability it can be that the location is not set
-        // yet, if so use the url
-        $location = $existingFeed->getLocation();
-        if (!$location) {
-            $location = $existingFeed->getUrl();
-        }
-
-        try {
-            list($fetchedFeed, $items) = $this->feedFetcher->fetch(
-                $location,
-                false,
-                $existingFeed->getHttpLastModified(),
-                $existingFeed->getHttpEtag(),
-                $existingFeed->getFullTextEnabled(),
-                $existingFeed->getBasicAuthUser(),
-                $existingFeed->getBasicAuthPassword()
-            );
-
-            // if there is no feed it means that no update took place
-            if (!$fetchedFeed) {
-                return $existingFeed;
-            }
-
-            // update number of articles on every feed update
-            $itemCount = count($items);
-
-            // this is needed to adjust to updates that add more items
-            // than when the feed was created. You can't update the count
-            // if it's lower because it may be due to the caching headers
-            // that were sent as the request and it might cause unwanted
-            // deletion and reappearing of feeds
-            if ($itemCount > $existingFeed->getArticlesPerUpdate()) {
-                $existingFeed->setArticlesPerUpdate($itemCount);
-            }
-
-            $existingFeed->setHttpLastModified(
-                $fetchedFeed->getHttpLastModified());
-            $existingFeed->setHttpEtag($fetchedFeed->getHttpEtag());
-            $existingFeed->setLocation($fetchedFeed->getLocation());
-
-            // insert items in reverse order because the first one is
-            // usually the newest item
-            for($i=$itemCount-1; $i>=0; $i--){
-                $item = $items[$i];
-                $item->setFeedId($existingFeed->getId());
-
-                try {
-                    $dbItem = $this->itemMapper->findByGuidHash(
-                        $item->getGuidHash(), $feedId, $userId
-                    );
-
-                    // in case of update
-                    if ($forceUpdate ||
-                        $item->getPubDate() > $dbItem->getPubDate()) {
-
-                        $dbItem->setTitle($item->getTitle());
-                        $dbItem->setUrl($item->getUrl());
-                        $dbItem->setAuthor($item->getAuthor());
-                        $dbItem->setSearchIndex($item->getSearchIndex());
-                        $dbItem->setRtl($item->getRtl());
-                        $dbItem->setLastModified($item->getLastModified());
-                        $dbItem->setPubDate($item->getPubDate());
-                        $dbItem->setEnclosureMime($item->getEnclosureMime());
-                        $dbItem->setEnclosureLink($item->getEnclosureLink());
-                        $dbItem->setBody(
-                            $this->purifier->purify($item->getBody())
-                        );
-
-                        // update modes: 0 nothing, 1 set unread
-                        if ($existingFeed->getUpdateMode() === 1) {
-                            $dbItem->setUnread();
-                        }
-
-                        $this->itemMapper->update($dbItem);
-                    }
-                } catch(DoesNotExistException $ex){
-                    $item->setBody(
-                        $this->purifier->purify($item->getBody())
-                    );
-                    $this->itemMapper->insert($item);
-                }
-            }
-
-            // mark feed as successfully updated
-            $existingFeed->setUpdateErrorCount(0);
-            $existingFeed->setLastUpdateError('');
-
-        } catch(FetcherException $ex){
-            $existingFeed->setUpdateErrorCount(
-                $existingFeed->getUpdateErrorCount()+1
-            );
-            $existingFeed->setLastUpdateError($ex->getMessage());
-        }
-
-        $this->feedMapper->update($existingFeed);
-
-        return $this->find($feedId, $userId);
-    }
-
-    /**
-     * Import articles
-     * @param array $json the array with json
-     * @param string $userId the username
-     * @return Feed if one had to be created for nonexistent feeds
-     */
-    public function importArticles($json, $userId) {
-        $url = 'http://owncloud/nofeed';
-        $urlHash = md5($url);
-
-        // build assoc array for fast access
-        $feeds = $this->findAll($userId);
-        $feedsDict = [];
-        foreach($feeds as $feed) {
-            $feedsDict[$feed->getLink()] = $feed;
-        }
-
-        $createdFeed = false;
-
-        // loop over all items and get the corresponding feed
-        // if the feed does not exist, create a separate feed for them
-        foreach ($json as $entry) {
-            $item = Item::fromImport($entry);
-            $feedLink = $entry['feedLink'];  // this is not set on the item yet
-
-            if(array_key_exists($feedLink, $feedsDict)) {
-                $feed = $feedsDict[$feedLink];
-                $item->setFeedId($feed->getId());
-            } elseif(array_key_exists($url, $feedsDict)) {
-                $feed = $feedsDict[$url];
-                $item->setFeedId($feed->getId());
-            } else {
-                $createdFeed = true;
-                $feed = new Feed();
-                $feed->setUserId($userId);
-                $feed->setLink($url);
-                $feed->setUrl($url);
-                $feed->setTitle($this->l10n->t('Articles without feed'));
-                $feed->setAdded($this->timeFactory->getTime());
-                $feed->setFolderId(0);
-                $feed->setPreventUpdate(true);
-                $feed = $this->feedMapper->insert($feed);
-
-                $item->setFeedId($feed->getId());
-                $feedsDict[$feed->getLink()] = $feed;
-            }
-
-            try {
-                // if item exists, copy the status
-                $existingItem = $this->itemMapper->findByGuidHash(
-                    $item->getGuidHash(), $feed->getId(), $userId);
-                $existingItem->setStatus($item->getStatus());
-                $this->itemMapper->update($existingItem);
-            } catch(DoesNotExistException $ex){
-                $item->setBody($this->purifier->purify($item->getBody()));
-                $item->generateSearchIndex();
-                $this->itemMapper->insert($item);
-            }
-        }
-
-        if($createdFeed) {
-            return $this->feedMapper->findByUrlHash($urlHash, $userId);
-        }
-
-        return null;
-    }
-
-
-    /**
-     * Use this to mark a feed as deleted. That way it can be un-deleted
-     * @param int $feedId the id of the feed that should be deleted
-     * @param string $userId the name of the user for security reasons
-     * @throws ServiceNotFoundException when feed does not exist
-     */
-    public function markDeleted($feedId, $userId) {
-        $feed = $this->find($feedId, $userId);
-        $feed->setDeletedAt($this->timeFactory->getTime());
-        $this->feedMapper->update($feed);
-    }
-
-
-    /**
-     * Use this to undo a feed deletion
-     * @param int $feedId the id of the feed that should be restored
-     * @param string $userId the name of the user for security reasons
-     * @throws ServiceNotFoundException when feed does not exist
-     */
-    public function unmarkDeleted($feedId, $userId) {
-        $feed = $this->find($feedId, $userId);
-        $feed->setDeletedAt(0);
-        $this->feedMapper->update($feed);
-    }
-
-
-    /**
-     * Deletes all deleted feeds
-     * @param string $userId if given it purges only feeds of that user
-     * @param boolean $useInterval defaults to true, if true it only purges
-     * entries in a given interval to give the user a chance to undo the
-     * deletion
-     */
-    public function purgeDeleted($userId=null, $useInterval=true) {
-        $deleteOlderThan = null;
-
-        if ($useInterval) {
-            $now = $this->timeFactory->getTime();
-            $deleteOlderThan = $now - $this->autoPurgeMinimumInterval;
-        }
-
-        $toDelete = $this->feedMapper->getToDelete($deleteOlderThan, $userId);
-
-        foreach ($toDelete as $feed) {
-            $this->feedMapper->delete($feed);
-        }
-    }
-
-
-    /**
-     * Deletes all feeds of a user, delete items first since the user_id
-     * is not defined in there
-     * @param string $userId the name of the user
-     */
-    public function deleteUser($userId) {
-        $this->feedMapper->deleteUser($userId);
-    }
-
-    /**
-     * @param $feedId
-     * @param $userId
-     * @param $diff an array containing the fields to update, e.g.:
-     *  [
-     *      'ordering' => 1,
-     *      'fullTextEnabled' => true,
-     *      'pinned' => true,
-     *      'updateMode' => 0,
-     *      'title' => 'title'
-     * ]
-     * @throws ServiceNotFoundException if feed does not exist
-     */
-    public function patch($feedId, $userId, $diff=[]) {
-        $feed = $this->find($feedId, $userId);
-
-        foreach ($diff as $attribute => $value) {
-            $method = 'set' . ucfirst($attribute);
-            $feed->$method($value);
-        }
-
-        // special feed updates
-        if (array_key_exists('fullTextEnabled', $diff)) {
-            // disable caching for the next update
-            $feed->setHttpEtag('');
-            $feed->setHttpLastModified(0);
-            $this->feedMapper->update($feed);
-            return $this->update($feedId, $userId, true);
-        }
-
-        return $this->feedMapper->update($feed);
-    }
-
-}
diff --git a/service/folderservice.php b/service/folderservice.php
deleted file mode 100644
index e7daf836e..000000000
--- a/service/folderservice.php
+++ /dev/null
@@ -1,178 +0,0 @@
-<?php
-/**
- * ownCloud - News
- *
- * This file is licensed under the Affero General Public License version 3 or
- * later. See the COPYING file.
- *
- * @author Alessandro Cosentino <cosenal@gmail.com>
- * @author Bernhard Posselt <dev@bernhard-posselt.com>
- * @copyright Alessandro Cosentino 2012
- * @copyright Bernhard Posselt 2012, 2014
- */
-
-namespace OCA\News\Service;
-
-use OCP\IL10N;
-use OCA\News\Db\Folder;
-use OCA\News\Db\FolderMapper;
-use OCA\News\Config\Config;
-use OCA\News\Utility\Time;
-
-
-class FolderService extends Service {
-
-    private $l10n;
-    private $timeFactory;
-    private $autoPurgeMinimumInterval;
-    private $folderMapper;
-
-    public function __construct(FolderMapper $folderMapper,
-                                IL10N $l10n,
-                                Time $timeFactory,
-                                Config $config){
-        parent::__construct($folderMapper);
-        $this->l10n = $l10n;
-        $this->timeFactory = $timeFactory;
-        $this->autoPurgeMinimumInterval =
-            $config->getAutoPurgeMinimumInterval();
-        $this->folderMapper = $folderMapper;
-    }
-
-    /**
-     * Returns all folders of a user
-     * @param string $userId the name of the user
-     * @return array of folders
-     */
-    public function findAll($userId) {
-        return $this->folderMapper->findAllFromUser($userId);
-    }
-
-
-    private function validateFolder($folderName, $userId){
-        $existingFolders =
-            $this->folderMapper->findByName($folderName, $userId);
-        if(count($existingFolders) > 0){
-
-            throw new ServiceConflictException(
-                $this->l10n->t('Can not add folder: Exists already'));
-        }
-
-        if(mb_strlen($folderName) === 0) {
-            throw new ServiceValidationException(
-                'Folder name can not be empty'
-            );
-        }
-    }
-
-
-    /**
-     * Creates a new folder
-     * @param string $folderName the name of the folder
-     * @param string $userId the name of the user for whom it should be created
-     * @param int $parentId the parent folder id, deprecated we don't nest
-     * folders
-     * @throws ServiceConflictException if name exists already
-     * @throws ServiceValidationException if the folder has invalid parameters
-     * @return Folder the newly created folder
-     */
-    public function create($folderName, $userId, $parentId=0) {
-        $this->validateFolder($folderName, $userId);
-
-        $folder = new Folder();
-        $folder->setName($folderName);
-        $folder->setUserId($userId);
-        $folder->setParentId($parentId);
-        $folder->setOpened(true);
-        return $this->folderMapper->insert($folder);
-    }
-
-
-    /**
-     * @throws ServiceException if the folder does not exist
-     */
-    public function open($folderId, $opened, $userId){
-        $folder = $this->find($folderId, $userId);
-        $folder->setOpened($opened);
-        $this->folderMapper->update($folder);
-    }
-
-
-    /**
-     * Renames a folder
-     * @param int $folderId the id of the folder that should be deleted
-     * @param string $folderName the new name of the folder
-     * @param string $userId the name of the user for security reasons
-     * @throws ServiceConflictException if name exists already
-     * @throws ServiceValidationException if the folder has invalid parameters
-     * @throws ServiceNotFoundException if the folder does not exist
-     * @return Folder the updated folder
-     */
-    public function rename($folderId, $folderName, $userId){
-        $this->validateFolder($folderName, $userId);
-
-        $folder = $this->find($folderId, $userId);
-        $folder->setName($folderName);
-        return $this->folderMapper->update($folder);
-    }
-
-
-    /**
-     * Use this to mark a folder as deleted. That way it can be un-deleted
-     * @param int $folderId the id of the folder that should be deleted
-     * @param string $userId the name of the user for security reasons
-     * @throws ServiceNotFoundException when folder does not exist
-     */
-    public function markDeleted($folderId, $userId) {
-        $folder = $this->find($folderId, $userId);
-        $folder->setDeletedAt($this->timeFactory->getTime());
-        $this->folderMapper->update($folder);
-    }
-
-
-    /**
-     * Use this to restore a folder
-     * @param int $folderId the id of the folder that should be restored
-     * @param string $userId the name of the user for security reasons
-     * @throws ServiceNotFoundException when folder does not exist
-     */
-    public function unmarkDeleted($folderId, $userId) {
-        $folder = $this->find($folderId, $userId);
-        $folder->setDeletedAt(0);
-        $this->folderMapper->update($folder);
-    }
-
-
-    /**
-     * Deletes all deleted folders
-     * @param string $userId if given it purges only folders of that user
-     * @param boolean $useInterval defaults to true, if true it only purges
-     * entries in a given interval to give the user a chance to undo the
-     * deletion
-     */
-    public function purgeDeleted($userId=null, $useInterval=true) {
-        $deleteOlderThan = null;
-
-        if ($useInterval) {
-            $now = $this->timeFactory->getTime();
-            $deleteOlderThan = $now - $this->autoPurgeMinimumInterval;
-        }
-
-        $toDelete = $this->folderMapper->getToDelete($deleteOlderThan, $userId);
-
-        foreach ($toDelete as $folder) {
-            $this->folderMapper->delete($folder);
-        }
-    }
-
-
-    /**
-     * Deletes all folders of a user
-     * @param string $userId the name of the user
-     */
-    public function deleteUser($userId) {
-        $this->folderMapper->deleteUser($userId);
-    }
-
-
-}
diff --git a/service/itemservice.php b/service/itemservice.php
deleted file mode 100644
index 8bbb54d49..000000000
--- a/service/itemservice.php
+++ /dev/null
@@ -1,259 +0,0 @@
-<?php
-/**
- * ownCloud - News
- *
- * This file is licensed under the Affero General Public License version 3 or
- * later. See the COPYING file.
- *
- * @author Alessandro Cosentino <cosenal@gmail.com>
- * @author Bernhard Posselt <dev@bernhard-posselt.com>
- * @copyright Alessandro Cosentino 2012
- * @copyright Bernhard Posselt 2012, 2014
- */
-
-namespace OCA\News\Service;
-
-use OCP\IConfig;
-use OCP\AppFramework\Db\DoesNotExistException;
-
-use OCA\News\Db\ItemMapper;
-use OCA\News\Db\StatusFlag;
-use OCA\News\Db\FeedType;
-use OCA\News\Config\Config;
-use OCA\News\Utility\Time;
-
-
-class ItemService extends Service {
-
-    private $statusFlag;
-    private $config;
-    private $timeFactory;
-    private $itemMapper;
-    private $systemConfig;
-
-    public function __construct(ItemMapper $itemMapper,
-                                StatusFlag $statusFlag,
-                                Time $timeFactory,
-                                Config $config,
-                                IConfig $systemConfig){
-        parent::__construct($itemMapper);
-        $this->statusFlag = $statusFlag;
-        $this->config = $config;
-        $this->timeFactory = $timeFactory;
-        $this->itemMapper = $itemMapper;
-        $this->systemConfig = $systemConfig;
-    }
-
-
-    /**
-     * Returns all new items
-     * @param int $id the id of the feed, 0 for starred or all items
-     * @param int $type the type of the feed
-     * @param int $updatedSince a timestamp with the last modification date
-     * returns only items with a >= modified timestamp
-     * @param boolean $showAll if unread items should also be returned
-     * @param string $userId the name of the user
-     * @return array of items
-     */
-    public function findAllNew($id, $type, $updatedSince, $showAll, $userId){
-        $status = $this->statusFlag->typeToStatus($type, $showAll);
-
-        switch($type){
-            case FeedType::FEED:
-                return $this->itemMapper->findAllNewFeed(
-                    $id, $updatedSince, $status, $userId
-                );
-            case FeedType::FOLDER:
-                return $this->itemMapper->findAllNewFolder(
-                    $id, $updatedSince, $status, $userId
-                );
-            default:
-                return $this->itemMapper->findAllNew(
-                    $updatedSince, $status, $userId
-                );
-        }
-    }
-
-
-    /**
-     * Returns all items
-     * @param int $id the id of the feed, 0 for starred or all items
-     * @param int $type the type of the feed
-     * @param int $limit how many items should be returned
-     * @param int $offset the offset
-     * @param boolean $showAll if unread items should also be returned
-     * @param boolean $oldestFirst if it should be ordered by oldest first
-     * @param string $userId the name of the user
-     * @param string[] $search an array of keywords that the result should
-     * contain in either the author, title, link or body
-     * @return array of items
-     */
-    public function findAll($id, $type, $limit, $offset, $showAll, $oldestFirst,
-                            $userId, $search=[]){
-        $status = $this->statusFlag->typeToStatus($type, $showAll);
-
-        switch($type){
-            case FeedType::FEED:
-                return $this->itemMapper->findAllFeed(
-                    $id, $limit, $offset, $status, $oldestFirst, $userId,
-                    $search
-                );
-            case FeedType::FOLDER:
-                return $this->itemMapper->findAllFolder(
-                    $id, $limit, $offset, $status, $oldestFirst, $userId,
-                    $search
-                );
-            default:
-                return $this->itemMapper->findAll(
-                    $limit, $offset, $status, $oldestFirst, $userId, $search
-                );
-        }
-    }
-
-
-    /**
-     * Star or unstar an item
-     * @param int $feedId the id of the item's feed that should be starred
-     * @param string $guidHash the guidHash of the item that should be starred
-     * @param boolean $isStarred if true the item will be marked as starred,
-     * if false unstar
-     * @param string $userId the name of the user for security reasons
-     * @throws ServiceNotFoundException if the item does not exist
-     */
-    public function star($feedId, $guidHash, $isStarred, $userId){
-        try {
-            $item = $this->itemMapper->findByGuidHash(
-                $guidHash, $feedId, $userId
-            );
-
-            if($isStarred){
-                $item->setStarred();
-            } else {
-                $item->setUnstarred();
-            }
-            $this->itemMapper->update($item);
-        } catch(DoesNotExistException $ex) {
-            throw new ServiceNotFoundException($ex->getMessage());
-        }
-    }
-
-
-    /**
-     * Read or unread an item
-     * @param int $itemId the id of the item that should be read
-     * @param boolean $isRead if true the item will be marked as read,
-     * if false unread
-     * @param string $userId the name of the user for security reasons
-     * @throws ServiceNotFoundException if the item does not exist
-     */
-    public function read($itemId, $isRead, $userId){
-        $lastModified = $this->timeFactory->getMicroTime();
-        $this->itemMapper->readItem($itemId, $isRead, $lastModified, $userId);
-    }
-
-
-    /**
-     * Set all items read
-     * @param int $highestItemId all items below that are marked read. This is
-     * used to prevent marking items as read that the users hasn't seen yet
-     * @param string $userId the name of the user
-     */
-    public function readAll($highestItemId, $userId){
-        $time = $this->timeFactory->getMicroTime();
-        $this->itemMapper->readAll($highestItemId, $time, $userId);
-    }
-
-
-    /**
-     * Set a folder read
-     * @param int $folderId the id of the folder that should be marked read
-     * @param int $highestItemId all items below that are marked read. This is
-     * used to prevent marking items as read that the users hasn't seen yet
-     * @param string $userId the name of the user
-     */
-    public function readFolder($folderId, $highestItemId, $userId){
-        $time = $this->timeFactory->getMicroTime();
-        $this->itemMapper->readFolder(
-            $folderId, $highestItemId, $time, $userId
-        );
-    }
-
-
-    /**
-     * Set a feed read
-     * @param int $feedId the id of the feed that should be marked read
-     * @param int $highestItemId all items below that are marked read. This is
-     * used to prevent marking items as read that the users hasn't seen yet
-     * @param string $userId the name of the user
-     */
-    public function readFeed($feedId, $highestItemId, $userId){
-        $time = $this->timeFactory->getMicroTime();
-        $this->itemMapper->readFeed($feedId, $highestItemId, $time, $userId);
-    }
-
-
-    /**
-     * This method deletes all unread feeds that are not starred and over the
-     * count of $this->autoPurgeCount starting by the oldest. This is to clean
-     * up the database so that old entries don't spam your db. As criteria for
-     * old, the id is taken
-     */
-    public function autoPurgeOld(){
-        $count = $this->config->getAutoPurgeCount();
-        if ($count >= 0) {
-            $this->itemMapper->deleteReadOlderThanThreshold($count);
-        }
-    }
-
-
-    /**
-     * Returns the newest item id, use this for marking feeds read
-     * @param string $userId the name of the user
-     * @throws ServiceNotFoundException if there is no newest item
-     * @return int
-     */
-    public function getNewestItemId($userId) {
-        try {
-            return $this->itemMapper->getNewestItemId($userId);
-        } catch(DoesNotExistException $ex) {
-            throw new ServiceNotFoundException($ex->getMessage());
-        }
-    }
-
-
-    /**
-     * Returns the starred count
-     * @param string $userId the name of the user
-     * @return int the count
-     */
-    public function starredCount($userId){
-        return $this->itemMapper->starredCount($userId);
-    }
-
-
-    /**
-     * @param string $userId from which user the items should be taken
-     * @return array of items which are starred or unread
-     */
-    public function getUnreadOrStarred($userId) {
-        return $this->itemMapper->findAllUnreadOrStarred($userId);
-    }
-
-
-    /**
-     * Deletes all items of a user
-     * @param string $userId the name of the user
-     */
-    public function deleteUser($userId) {
-        $this->itemMapper->deleteUser($userId);
-    }
-
-
-    /**
-     * Regenerates the search index for all items
-     */
-    public function generateSearchIndices() {
-        $this->itemMapper->updateSearchIndices();
-    }
-
-}
diff --git a/service/service.php b/service/service.php
deleted file mode 100644
index e53468828..000000000
--- a/service/service.php
+++ /dev/null