new functions

src/db.rs

@@ -382,14 +382,42 @@ pub async fn list_pad_revisions(
     .await
 }
 
-#[derive(Debug, Clone, Serialize, FromRow)]
+#[derive(Debug, Clone, Serialize)]
 pub struct PublishedPage {
     pub token: String,
+    pub pad_id: Option<i64>,
+    pub note_id: Option<i64>,
+    pub allow_task_updates: bool,
     pub title: String,
     pub content: String,
     pub updated_at: String,
 }
 
+#[derive(Debug, Clone, FromRow)]
+struct PublishedPageRow {
+    token: String,
+    pad_id: Option<i64>,
+    note_id: Option<i64>,
+    allow_task_updates: i64,
+    title: String,
+    content: String,
+    updated_at: String,
+}
+
+impl From<PublishedPageRow> for PublishedPage {
+    fn from(value: PublishedPageRow) -> Self {
+        Self {
+            token: value.token,
+            pad_id: value.pad_id,
+            note_id: value.note_id,
+            allow_task_updates: value.allow_task_updates != 0,
+            title: value.title,
+            content: value.content,
+            updated_at: value.updated_at,
+        }
+    }
+}
+
 pub async fn publish_pad(pool: &Database, pad_id: i64) -> Result<String, sqlx::Error> {
     if let Some(token) = sqlx::query_scalar::<_, String>(queries::get(pool.kind(), queries::Q017))
         .bind(pad_id)
@@ -425,10 +453,63 @@ pub async fn publish_note(pool: &Database, note_id: i64) -> Result<String, sqlx:
 }
 
 pub async fn find_published_page(pool: &Database, token: &str) -> Result<Option<PublishedPage>, sqlx::Error> {
-    sqlx::query_as::<_, PublishedPage>(queries::get(pool.kind(), queries::Q021))
-    .bind(token)
-    .fetch_optional(pool.pool())
-    .await
+    Ok(sqlx::query_as::<_, PublishedPageRow>(queries::get(pool.kind(), queries::Q021))
+        .bind(token)
+        .fetch_optional(pool.pool())
+        .await?
+        .map(Into::into))
+}
+
+pub async fn pad_public_task_updates(pool: &Database, pad_id: i64) -> Result<bool, sqlx::Error> {
+    let value = sqlx::query_scalar::<_, i64>(queries::get(pool.kind(), queries::Q044))
+        .bind(pad_id)
+        .fetch_optional(pool.pool())
+        .await?
+        .unwrap_or(0);
+    Ok(value != 0)
+}
+
+pub async fn note_public_task_updates(pool: &Database, note_id: i64) -> Result<bool, sqlx::Error> {
+    let value = sqlx::query_scalar::<_, i64>(queries::get(pool.kind(), queries::Q045))
+        .bind(note_id)
+        .fetch_optional(pool.pool())
+        .await?
+        .unwrap_or(0);
+    Ok(value != 0)
+}
+
+pub async fn set_pad_public_task_updates(pool: &Database, pad_id: i64, allow: bool) -> Result<(), sqlx::Error> {
+    publish_pad(pool, pad_id).await?;
+    sqlx::query(queries::get(pool.kind(), queries::Q040)).bind(if allow { 1i64 } else { 0i64 }).bind(pad_id).execute(pool.pool()).await?;
+    Ok(())
+}
+
+pub async fn set_note_public_task_updates(pool: &Database, note_id: i64, allow: bool) -> Result<(), sqlx::Error> {
+    publish_note(pool, note_id).await?;
+    sqlx::query(queries::get(pool.kind(), queries::Q041)).bind(if allow { 1i64 } else { 0i64 }).bind(note_id).execute(pool.pool()).await?;
+    Ok(())
+}
+
+pub async fn update_public_task(pool: &Database, token: &str, source_line: usize, checked: bool) -> Result<Option<PublishedPage>, sqlx::Error> {
+    let Some(mut page) = find_published_page(pool, token).await? else { return Ok(None); };
+    if !page.allow_task_updates || source_line == 0 { return Ok(Some(page)); }
+    let mut lines: Vec<String> = page.content.split('\n').map(str::to_owned).collect();
+    let Some(line) = lines.get_mut(source_line - 1) else { return Ok(Some(page)); };
+    let bytes = line.as_bytes();
+    let mut i = 0usize;
+    while i < bytes.len() && bytes[i].is_ascii_whitespace() { i += 1; }
+    if i >= bytes.len() || !matches!(bytes[i], b'-' | b'*' | b'+') { return Ok(Some(page)); }
+    i += 1;
+    while i < bytes.len() && bytes[i].is_ascii_whitespace() { i += 1; }
+    if i + 2 >= bytes.len() || bytes[i] != b'[' || !matches!(bytes[i + 1], b' ' | b'x' | b'X') || bytes[i + 2] != b']' { return Ok(Some(page)); }
+    line.replace_range(i + 1..i + 2, if checked { "x" } else { " " });
+    page.content = lines.join("\n");
+    if let Some(id) = page.pad_id {
+        sqlx::query(queries::get(pool.kind(), queries::Q042)).bind(&page.content).bind(id).execute(pool.pool()).await?;
+    } else if let Some(id) = page.note_id {
+        sqlx::query(queries::get(pool.kind(), queries::Q043)).bind(&page.content).bind(id).execute(pool.pool()).await?;
+    }
+    find_published_page(pool, token).await
 }
 
 pub async fn pad_file_token(pool: &Database, pad_id: i64) -> Result<String, sqlx::Error> {