aven 0.1.13

Local-first task manager CLI and sync server
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

use std::path::Path;

use anyhow::Result;
use aven_core::db::Database;

use crate::attachments::export::{LeasedImageExport, lease_image_export};
use crate::operations::TaskAttachmentAddInput;

use super::TuiStore;

#[derive(Clone)]
pub(crate) struct AttachmentWorkerContext {
    database: Database,
    workspace: crate::workspaces::Workspace,
}

impl AttachmentWorkerContext {
    pub(crate) async fn add_ordered_attachment(
        &self,
        blob_dir: &Path,
        lifecycle_policy: crate::attachments::lifecycle::LifecyclePolicy,
        task_id: &crate::ids::TaskId,
        created_at: String,
        input: TaskAttachmentAddInput,
    ) -> Result<bool> {
        Ok(self
            .database
            .add_ordered_task_attachment(
                &self.workspace,
                blob_dir,
                lifecycle_policy,
                task_id,
                created_at,
                input,
            )
            .await?
            .created)
    }
}

impl TuiStore {
    pub(crate) fn attachment_worker_context(&self) -> AttachmentWorkerContext {
        AttachmentWorkerContext {
            database: self.database.clone(),
            workspace: self.active_workspace.clone(),
        }
    }

    pub(crate) async fn delete_attachment(&self, attachment_id: &str) -> Result<()> {
        self.database
            .delete_task_attachment(&self.active_workspace, attachment_id)
            .await?;
        Ok(())
    }

    pub(crate) async fn lease_image_export(
        &self,
        blob_dir: &Path,
        attachment_id: &str,
    ) -> Result<LeasedImageExport> {
        lease_image_export(
            &self.database,
            &self.active_workspace,
            blob_dir,
            attachment_id,
        )
        .await
    }

    pub(crate) async fn release_image_export(&self, export: &mut LeasedImageExport) -> Result<()> {
        export.release().await
    }
}