Use a different request for starred items when option is to true

app/src/main/java/com/readrops/app/itemslist/MainViewModel.java

@@ -6,6 +6,7 @@ import androidx.lifecycle.MediatorLiveData;
 import androidx.lifecycle.ViewModel;
 import androidx.paging.LivePagedListBuilder;
 import androidx.paging.PagedList;
+import androidx.sqlite.db.SupportSQLiteQuery;
 
 import com.readrops.app.repositories.ARepository;
 import com.readrops.app.utils.SharedPreferencesManager;
@@ -67,8 +68,16 @@ public class MainViewModel extends ViewModel {
             itemsWithFeed.removeSource(lastFetch);
         }
 
+        SupportSQLiteQuery query;
+
+        if (queryFilters.getFilterType() == FilterType.STARS_FILTER && currentAccount.getAccountType().getAccountConfig().isUseStarredItems()) {
+            query = ItemsQueryBuilder.buildStarredItemsQuery(queryFilters);
+        } else {
+            query = ItemsQueryBuilder.buildItemsQuery(queryFilters);
+        }
+
         lastFetch = new LivePagedListBuilder<>(new RoomFactoryWrapper<>(database.itemDao()
-                .selectAll(ItemsQueryBuilder.buildQuery(queryFilters))),
+                .selectAll(query)),
                 new PagedList.Config.Builder()
                         .setPageSize(100)
                         .setPrefetchDistance(150)

db/src/main/java/com/readrops/db/ItemsQueryBuilder.kt

@@ -7,36 +7,44 @@ import com.readrops.db.filters.ListSortType
 
 object ItemsQueryBuilder {
 
-    private val COLUMNS = arrayOf("Item.id", "title", "clean_description", "image_link", "pub_date", "read",
+    private val COLUMNS = arrayOf("title", "clean_description", "image_link", "pub_date", "read",
-            "read_changed", "read_it_later", "Feed.name", "text_color", "background_color", "icon_url", "read_time", "Item.remoteId",
+            "read_changed", "read_it_later", "Feed.name", "text_color", "background_color", "icon_url", "read_time",
             "Feed.id as feedId", "Feed.account_id", "Folder.id as folder_id", "Folder.name as folder_name")
 
+    private val ITEM_COLUMNS = arrayOf(".id", ".remoteId")
+
     private const val SELECT_ALL_JOIN = "Item INNER JOIN Feed on Item.feed_id = Feed.id " +
             "LEFT JOIN Folder on Feed.folder_id = Folder.id"
 
-    private const val ORDER_BY_ASC = "Item.id DESC"
+    private const val ORDER_BY_ASC = ".id DESC"
 
     private const val ORDER_BY_DESC = "pub_date ASC"
 
+    @JvmStatic
+    fun buildItemsQuery(queryFilters: QueryFilters): SupportSQLiteQuery =
+            buildQuery(queryFilters, false)
 
     @JvmStatic
-    fun buildQuery(queryFilters: QueryFilters): SupportSQLiteQuery {
+    fun buildStarredItemsQuery(queryFilters: QueryFilters): SupportSQLiteQuery =
-        if (queryFilters.accountId == 0)
+            buildQuery(queryFilters, true)
+
+    private fun buildQuery(queryFilters: QueryFilters, starQuery: Boolean): SupportSQLiteQuery = with(queryFilters) {
+        if (accountId == 0)
             throw IllegalArgumentException("AccountId must be greater than 0")
 
-        if (queryFilters.filterType == FilterType.FEED_FILTER && queryFilters.filterFeedId == 0)
+        if (filterType == FilterType.FEED_FILTER && filterFeedId == 0)
             throw IllegalArgumentException("FeedId must be greater than 0 if current filter is FEED_FILTER")
 
-        return SupportSQLiteQueryBuilder.builder(SELECT_ALL_JOIN).run {
+        SupportSQLiteQueryBuilder.builder(if (starQuery) SELECT_ALL_JOIN.replace("Item", "StarredItem") else SELECT_ALL_JOIN).run {
-            columns(COLUMNS)
+            columns(COLUMNS.plus(buildItemColumns(starQuery)))
-            selection(buildWhereClause(queryFilters), null)
+            selection(buildWhereClause(this@with), null)
-            orderBy(if (queryFilters.sortType == ListSortType.NEWEST_TO_OLDEST) ORDER_BY_ASC else ORDER_BY_DESC)
+            orderBy(if (sortType == ListSortType.NEWEST_TO_OLDEST) buildOrderByAsc(starQuery) else ORDER_BY_DESC)
 
             create()
         }
     }
 
-    private fun buildWhereClause(queryFilters: QueryFilters): String? {
+    private fun buildWhereClause(queryFilters: QueryFilters): String {
         return StringBuilder(500).run {
             append("Feed.account_id = ${queryFilters.accountId} And ")
 
@@ -51,8 +59,21 @@ object ItemsQueryBuilder {
 
             toString()
         }
-
     }
+
+    private fun buildItemColumns(starQuery: Boolean): Array<String> {
+        val columns = arrayListOf<String>()
+
+        for (column in ITEM_COLUMNS) {
+            columns += if (starQuery) "StarredItem$column" else "Item$column"
+        }
+
+        return columns.toTypedArray()
+    }
+
+    private fun buildOrderByAsc(starQuery: Boolean): String =
+            if (starQuery) "StarredItem$ORDER_BY_ASC" else "Item$ORDER_BY_ASC"
+
 }
 
 class QueryFilters(var showReadItems: Boolean = true,

db/src/main/java/com/readrops/db/entities/account/AccountConfig.java

@@ -6,18 +6,21 @@ public class AccountConfig {
             .setFeedUrlEditable(true)
             .setFolderCreation(true)
             .setNoFolderCase(false)
+            .setUseStarredItems(false)
             .build();
 
     public static final AccountConfig NEXTNEWS = new AccountConfigBuilder()
             .setFeedUrlEditable(false)
             .setFolderCreation(true)
             .setNoFolderCase(false)
+            .setUseStarredItems(false)
             .build();
 
     public static final AccountConfig FRESHRSS = new AccountConfigBuilder()
             .setFeedUrlEditable(false)
             .setFolderCreation(false)
             .setNoFolderCase(true)
+            .setUseStarredItems(true)
             .build();
 
     private boolean feedUrlEditable;
@@ -26,6 +29,8 @@ public class AccountConfig {
 
     private boolean noFolderCase;
 
+    private boolean useStarredItems;
+
     public boolean isFeedUrlEditable() {
         return feedUrlEditable;
     }
@@ -38,16 +43,22 @@ public class AccountConfig {
         return noFolderCase;
     }
 
+    public boolean isUseStarredItems() {
+        return useStarredItems;
+    }
+
     public AccountConfig(AccountConfigBuilder builder) {
         this.feedUrlEditable = builder.feedUrlEditable;
         this.folderCreation = builder.folderCreation;
         this.noFolderCase = builder.noFolderCase;
+        this.useStarredItems = builder.useStarredItems;
     }
 
     public static class AccountConfigBuilder {
         private boolean feedUrlEditable;
         private boolean folderCreation;
         private boolean noFolderCase;
+        private boolean useStarredItems;
 
         public AccountConfigBuilder setFeedUrlEditable(boolean feedUrlEditable) {
             this.feedUrlEditable = feedUrlEditable;
@@ -64,6 +75,11 @@ public class AccountConfig {
             return this;
         }
 
+        public AccountConfigBuilder setUseStarredItems(boolean useStarredItems) {
+            this.useStarredItems = useStarredItems;
+            return this;
+        }
+
         public AccountConfig build() {
             return new AccountConfig(this);
         }

db/src/test/java/com/readrops/db/ItemsQueryBuilderTest.kt

@@ -12,7 +12,7 @@ class ItemsQueryBuilderTest {
     fun noFilterDefaultSortCaseTest() {
         val queryFilters = QueryFilters(accountId = 1)
 
-        val query = ItemsQueryBuilder.buildQuery(queryFilters).sql
+        val query = ItemsQueryBuilder.buildItemsQuery(queryFilters).sql
 
         assertTrue(query.contains("Feed.account_id = 1"))
         assertTrue(query.contains("read_it_later = 0"))
@@ -26,7 +26,7 @@ class ItemsQueryBuilderTest {
         val queryFilters = QueryFilters(accountId = 1, filterType = FilterType.FEED_FILTER,
                 filterFeedId = 15)
 
-        val query = ItemsQueryBuilder.buildQuery(queryFilters).sql
+        val query = ItemsQueryBuilder.buildItemsQuery(queryFilters).sql
 
         assertTrue(query.contains("feed_id = 15 And read_it_later = 0"))
     }
@@ -35,7 +35,7 @@ class ItemsQueryBuilderTest {
     fun readLaterFilterCaseTest() {
         val queryFilters = QueryFilters(accountId = 1, filterType = FilterType.READ_IT_LATER_FILTER)
 
-        val query = ItemsQueryBuilder.buildQuery(queryFilters).sql
+        val query = ItemsQueryBuilder.buildItemsQuery(queryFilters).sql
         assertTrue(query.contains("read_it_later = 1"))
     }
 
@@ -43,7 +43,7 @@ class ItemsQueryBuilderTest {
     fun starsFilterCaseTest() {
         val queryFilters = QueryFilters(accountId = 1, filterType = FilterType.STARS_FILTER)
 
-        val query = ItemsQueryBuilder.buildQuery(queryFilters).sql
+        val query = ItemsQueryBuilder.buildItemsQuery(queryFilters).sql
         assertTrue(query.contains("starred = 1 And read_it_later = 0"))
     }
 
@@ -52,7 +52,7 @@ class ItemsQueryBuilderTest {
         val queryFilters = QueryFilters(accountId = 1, sortType = ListSortType.OLDEST_TO_NEWEST,
                 showReadItems = false)
 
-        val query = ItemsQueryBuilder.buildQuery(queryFilters).sql
+        val query = ItemsQueryBuilder.buildItemsQuery(queryFilters).sql
 
         assertTrue(query.contains("read = 0 And "))
         assertTrue(query.contains("pub_date ASC"))
@@ -62,12 +62,12 @@ class ItemsQueryBuilderTest {
     fun accountIdExceptionTest() {
         val queryFilters = QueryFilters()
 
-        ItemsQueryBuilder.buildQuery(queryFilters)
+        ItemsQueryBuilder.buildItemsQuery(queryFilters)
     }
 
     @Test(expected = IllegalArgumentException::class)
     fun filterFeedIdExceptionTest() {
         val queryFilters = QueryFilters(accountId = 1, filterType = FilterType.FEED_FILTER)
-        ItemsQueryBuilder.buildQuery(queryFilters)
+        ItemsQueryBuilder.buildItemsQuery(queryFilters)
     }
 }