datam 0.2.0

A terminal tool to manager your files.
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

use sha2::{Digest, Sha256};

use crate::handler::{Context, Handler};
use crate::handler_ipfs::IpfsHandler;
use crate::handler_local::LocalHandler;

pub struct ComposedHandler {
    local: LocalHandler,
    remote: Vec<Box<dyn Handler>>,
}

impl ComposedHandler {
    pub fn new() -> Self {
        Self {
            local: LocalHandler::new(),
            remote: vec![Box::new(IpfsHandler::new())],
        }
    }
}

impl ComposedHandler {
    pub async fn add(&mut self, ctx: Context) -> Context {
        let mut ctx = ctx;
        for handler in self.remote.iter_mut() {
            ctx = handler.add(ctx).await;
        }
        self.local.add(ctx).await
    }

    pub async fn get(&self, ctx: Context) -> Option<Context> {
        let ctx = self.local.get(ctx).await;
        if let Some(mut ctx) = ctx {
            for handler in self.remote.iter() {
                ctx = handler.get(ctx.clone()).await.unwrap_or(ctx);
                if !ctx.get_content().is_empty() {
                    let mut hasher = Sha256::new();
                    hasher.update(ctx.get_content());
                    let sha256 = hasher.finalize().to_vec();
                    if sha256 == *ctx.get_sha256() {
                        return Some(ctx);
                    } else {
                        log::warn!(
                            "Unexpected sha256 with `{}` in remote `{}`",
                            ctx.get_id(),
                            handler.name()
                        );
                    }
                }
            }
            Some(ctx)
        } else {
            None
        }
    }

    pub async fn remove(&mut self, ctx: Context) -> Option<Context> {
        let ctx = self.local.remove(ctx).await;
        if let Some(mut ctx) = ctx {
            for handler in self.remote.iter_mut() {
                ctx = handler.remove(ctx.clone()).await.unwrap_or(ctx);
            }
            Some(ctx)
        } else {
            None
        }
    }

    pub async fn list(&self) -> String {
        self.local.list().await
    }
}