Load filtered home activity streams

crates/app/src/api.rs

@@ -355,8 +355,12 @@ pub async fn load_pull_diff(
     Ok(diff::parse_file(&diff, path))
 }
 
-pub async fn load_home(server: &Server, page: i32) -> Result<HomeData, String> {
-    client(server)?.home(page).await.map_err(message)
+pub async fn load_home(
+    server: &Server,
+    page: i32,
+    filter: gotcha_gitea::ActivityFilter,
+) -> Result<HomeData, String> {
+    client(server)?.home(page, filter).await.map_err(message)
 }
 
 fn client(server: &Server) -> Result<Client, String> {

crates/app/src/lib.rs

@@ -171,12 +171,16 @@ impl GotchaCore {
         save_preferences(&state.preferences).map_err(Into::into)
     }
 
-    pub async fn home(&self, page: u32) -> Result<HomePage, GotchaError> {
+    pub async fn home(
+        &self,
+        page: u32,
+        filter: HomeActivityFilter,
+    ) -> Result<HomePage, GotchaError> {
         let server = self.server()?;
         let name = server.name.clone();
         Ok(home_page(
             name,
-            load_home(&server, valid_page(page)?).await?,
+            load_home(&server, valid_page(page)?, filter.into()).await?,
         ))
     }
 

crates/app/src/presentation.rs

@@ -245,6 +245,23 @@ pub struct ActivityRow {
     pub sha: String,
 }
 
+#[derive(Clone, Copy, Debug, uniffi::Enum)]
+pub enum HomeActivityFilter {
+    All,
+    Issues,
+    PullRequests,
+}
+
+impl From<HomeActivityFilter> for gotcha_gitea::ActivityFilter {
+    fn from(filter: HomeActivityFilter) -> Self {
+        match filter {
+            HomeActivityFilter::All => Self::All,
+            HomeActivityFilter::Issues => Self::Issues,
+            HomeActivityFilter::PullRequests => Self::PullRequests,
+        }
+    }
+}
+
 #[derive(Clone, uniffi::Record)]
 pub struct HeatCell {
     pub level: u32,
@@ -255,11 +272,9 @@ pub struct HeatCell {
 pub struct HomePage {
     pub server_name: String,
     pub activities: Vec<ActivityRow>,
-    pub issue_activities: Vec<ActivityRow>,
-    pub pull_activities: Vec<ActivityRow>,
     pub heat_cells: Vec<HeatCell>,
     pub contribution_count: i64,
-    pub has_more: bool,
+    pub next_page: Option<u32>,
 }
 
 pub fn repository_rows(
@@ -776,52 +791,13 @@ pub fn home_page(server_name: String, home: HomeData) -> HomePage {
     let (heat_cells, contribution_count) = heat_cells(&home.heatmap);
     HomePage {
         server_name,
-        issue_activities: home
-            .activities
-            .iter()
-            .filter(|activity| is_issue_activity(activity))
-            .map(activity_row)
-            .collect(),
-        pull_activities: home
-            .activities
-            .iter()
-            .filter(|activity| is_pull_activity(activity))
-            .map(activity_row)
-            .collect(),
         activities: home.activities.iter().map(activity_row).collect(),
         heat_cells,
         contribution_count,
-        has_more: home.has_more,
+        next_page: home.next_page.map(|page| page as u32),
     }
 }
 
-fn is_issue_activity(activity: &models::Activity) -> bool {
-    use models::activity::OpType;
-
-    matches!(
-        activity.op_type,
-        Some(OpType::CreateIssue | OpType::CloseIssue | OpType::ReopenIssue | OpType::CommentIssue)
-    )
-}
-
-fn is_pull_activity(activity: &models::Activity) -> bool {
-    use models::activity::OpType;
-
-    matches!(
-        activity.op_type,
-        Some(
-            OpType::CreatePullRequest
-                | OpType::MergePullRequest
-                | OpType::AutoMergePullRequest
-                | OpType::ClosePullRequest
-                | OpType::ReopenPullRequest
-                | OpType::CommentPull
-                | OpType::ApprovePullRequest
-                | OpType::RejectPullRequest
-        )
-    )
-}
-
 fn activity_row(activity: &models::Activity) -> ActivityRow {
     use models::activity::OpType;
 
@@ -1263,31 +1239,26 @@ mod tests {
     }
 
     #[test]
-    fn categorizes_home_activity_before_crossing_the_bridge() {
+    fn presents_filtered_home_activity_and_continuation() {
         use models::activity::OpType;
 
         let page = home_page(
             "Gitea".into(),
             HomeData {
-                activities: [
-                    OpType::CreateIssue,
-                    OpType::CreatePullRequest,
-                    OpType::CreateRepo,
-                ]
-                .into_iter()
-                .map(|op_type| models::Activity {
-                    op_type: Some(op_type),
-                    ..Default::default()
-                })
-                .collect(),
+                activities: [OpType::CreatePullRequest, OpType::ClosePullRequest]
+                    .into_iter()
+                    .map(|op_type| models::Activity {
+                        op_type: Some(op_type),
+                        ..Default::default()
+                    })
+                    .collect(),
                 heatmap: Vec::new(),
-                has_more: false,
+                next_page: Some(4),
             },
         );
 
-        assert_eq!(page.activities.len(), 3);
-        assert_eq!(page.issue_activities.len(), 1);
-        assert_eq!(page.pull_activities.len(), 1);
+        assert_eq!(page.activities.len(), 2);
+        assert_eq!(page.next_page, Some(4));
     }
 
     #[test]