first commit

src/db.rs

@@ -871,6 +871,38 @@ impl Db {
         Ok(out)
     }
 
+    /// Subscribers per feed, for the whole catalogue in one query -- the feed list would
+    /// otherwise ask once per feed.
+    pub fn subscriber_counts(&self) -> Result<std::collections::HashMap<String, i64>> {
+        let conn = self.conn.lock().unwrap();
+        let mut stmt =
+            conn.prepare("SELECT feed_id, count(*) FROM subscriptions GROUP BY feed_id")?;
+        let out = stmt
+            .query_map([], |r| Ok((r.get::<_, String>(0)?, r.get::<_, i64>(1)?)))?
+            .collect::<rusqlite::Result<std::collections::HashMap<_, _>>>()?;
+        Ok(out)
+    }
+
+    /// Who else would miss this file: subscribers other than `user_id` who have starred
+    /// the item or have not read it yet. Deleting is deleting their copy too.
+    pub fn others_wanting(&self, enclosure_id: i64, user_id: i64) -> Result<(i64, i64)> {
+        let conn = self.conn.lock().unwrap();
+        let mut stmt = conn.prepare(
+            "SELECT
+                sum(CASE WHEN coalesce(st.flagged, 0) = 1 THEN 1 ELSE 0 END),
+                sum(CASE WHEN coalesce(st.read, 0) = 0 THEN 1 ELSE 0 END)
+             FROM enclosures e
+             JOIN subscriptions s ON s.feed_id = e.feed_id AND s.user_id != ?2
+             LEFT JOIN entry_state st
+                    ON st.user_id = s.user_id AND st.feed_id = e.feed_id AND st.guid = e.guid
+             WHERE e.id = ?1",
+        )?;
+        let (starred, unread) = stmt.query_row(params![enclosure_id, user_id], |r| {
+            Ok((r.get::<_, Option<i64>>(0)?.unwrap_or(0), r.get::<_, Option<i64>>(1)?.unwrap_or(0)))
+        })?;
+        Ok((starred, unread))
+    }
+
     pub fn subscribe(&self, user_id: i64, feed_id: &str) -> Result<()> {
         let conn = self.conn.lock().unwrap();
         conn.execute(
@@ -1274,6 +1306,32 @@ pub fn now() -> i64 {
 mod tests {
     use super::*;
 
+    #[test]
+    fn deleting_a_shared_file_asks_about_everyone_else() {
+        let db = Db::memory().unwrap();
+        db.exec_for_test(
+            "INSERT INTO users (id, name, is_admin, created) VALUES (1,'ray',1,0),(2,'sam',0,0),(3,'kit',0,0);
+             INSERT INTO subscriptions (user_id, feed_id, created) VALUES (1,'f',0),(2,'f',0),(3,'f',0);
+             INSERT INTO entries (feed_id, guid, first_seen) VALUES ('f','a',0);
+             INSERT INTO enclosures (id, feed_id, guid, url, path, state) VALUES
+                (1,'f','a','u1','/tmp/a','done');",
+        )
+        .unwrap();
+
+        // Nobody has touched it: both others still have it unplayed.
+        assert_eq!(db.others_wanting(1, 1).unwrap(), (0, 2));
+
+        // Sam reads it, Kit stars it.
+        db.set_entry_flag(2, "f", "a", EntryFlag::Read, true).unwrap();
+        db.set_entry_flag(3, "f", "a", EntryFlag::Flagged, true).unwrap();
+        assert_eq!(db.others_wanting(1, 1).unwrap(), (1, 1), "one starred it, one has not played it");
+
+        // Asking as Kit, only Ray and Sam count -- and Kit's own star is not a reason to
+        // warn Kit.
+        db.set_entry_flag(1, "f", "a", EntryFlag::Read, true).unwrap();
+        assert_eq!(db.others_wanting(1, 3).unwrap(), (0, 0));
+    }
+
     #[test]
     fn read_state_belongs_to_one_person() {
         let db = Db::memory().unwrap();

src/web.rs

@@ -346,6 +346,8 @@ struct FeedRow {
     entries: i64,
     downloaded: i64,
     unread: i64,
+    /// Including you. More than one means every file here is shared.
+    subscribers: i64,
 }
 
 async fn feeds(
@@ -363,6 +365,7 @@ async fn feeds(
         .into_iter()
         .map(|s| (s.feed_id.clone(), s))
         .collect();
+    let counts = state.ctx.db.subscriber_counts()?;
     let mut out = Vec::with_capacity(mine.len());
     for sub in &subs {
         let (id, feed) = (&sub.id, &sub.cfg);
@@ -400,6 +403,7 @@ async fn feeds(
             entries: s.entries,
             downloaded: s.downloaded,
             unread: state.ctx.db.unread_count(user.id, id)?,
+            subscribers: counts.get(id).copied().unwrap_or(0),
         });
     }
     Ok(Json(out))
@@ -822,15 +826,46 @@ async fn download_now(
     Ok(StatusCode::ACCEPTED)
 }
 
+#[derive(Deserialize)]
+struct Force {
+    #[serde(default)]
+    force: bool,
+}
+
 async fn delete_file(
     State(state): State<WebState>,
     Path(id): Path<i64>,
+    user: crate::db::User,
+    Query(q): Query<Force>,
 ) -> Result<StatusCode, ApiError> {
     let enc = state
         .ctx
         .db
         .enclosure(id)?
         .ok_or_else(|| anyhow::anyhow!("no enclosure {id}"))?;
+
+    // There is one copy of the file: deleting it deletes everyone's. Say so before doing
+    // it, once, and let them decide.
+    if !q.force {
+        let (starred, unread) = state.ctx.db.others_wanting(id, user.id)?;
+        let people = |n: i64| if n == 1 { "person".to_string() } else { format!("{n} people") };
+        let complaint = match (starred, unread) {
+            (0, 0) => None,
+            (0, u) => Some(format!("{} subscribed to this feed {} not played it yet", people(u), if u == 1 { "has" } else { "have" })),
+            (st, 0) => Some(format!("another {} starred it to keep", people(st))),
+            (st, u) => Some(format!(
+                "another {} starred it to keep, and {} not played it yet",
+                people(st),
+                if u == 1 { "one person has".to_string() } else { format!("{u} have") }
+            )),
+        };
+        if let Some(why) = complaint {
+            return Err(ApiError {
+                error: anyhow::Error::msg(format!("There is one copy of this file and {why}.")),
+                status: StatusCode::CONFLICT,
+            });
+        }
+    }
     if let Some(path) = &enc.path
         && let Err(e) = std::fs::remove_file(path)
         && e.kind() != std::io::ErrorKind::NotFound