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::fmt;

use crate::commons::api::{
    PublishDelta, PublisherHandle, RepositoryHandle, StorableRepositoryCommand,
};
use crate::commons::eventsourcing::CommandDetails;
use crate::commons::eventsourcing::SentCommand;
use crate::commons::remote::rfc8183;
use crate::pubd::Evt;

//------------ Cmd ---------------------------------------------------------
pub type Cmd = SentCommand<CmdDet>;

//------------ CmdDet ------------------------------------------------------
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[allow(clippy::large_enum_variant)]
#[serde(rename_all = "snake_case")]
pub enum CmdDet {
    AddPublisher(rfc8183::PublisherRequest),
    RemovePublisher(PublisherHandle),
    Publish(PublisherHandle, PublishDelta),
}

impl CommandDetails for CmdDet {
    type Event = Evt;
    type StorableDetails = StorableRepositoryCommand;

    fn store(&self) -> Self::StorableDetails {
        self.clone().into()
    }
}

impl CmdDet {
    pub fn add_publisher(handle: &RepositoryHandle, request: rfc8183::PublisherRequest) -> Cmd {
        SentCommand::new(handle, None, CmdDet::AddPublisher(request))
    }

    pub fn remove_publisher(handle: &RepositoryHandle, publisher: PublisherHandle) -> Cmd {
        SentCommand::new(handle, None, CmdDet::RemovePublisher(publisher))
    }

    pub fn publish(
        handle: &RepositoryHandle,
        publisher: PublisherHandle,
        delta: PublishDelta,
    ) -> Cmd {
        SentCommand::new(handle, None, CmdDet::Publish(publisher, delta))
    }
}

impl fmt::Display for CmdDet {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        StorableRepositoryCommand::from(self.clone()).fmt(f)
    }
}

impl From<CmdDet> for StorableRepositoryCommand {
    fn from(d: CmdDet) -> Self {
        match d {
            CmdDet::AddPublisher(req) => {
                let (_, pbl, id) = req.unpack();
                StorableRepositoryCommand::AddPublisher(pbl, id.ski_hex())
            }
            CmdDet::RemovePublisher(pbl) => StorableRepositoryCommand::RemovePublisher(pbl),
            CmdDet::Publish(pbl, delta) => StorableRepositoryCommand::Publish(
                pbl,
                delta.publishes().len(),
                delta.updates().len(),
                delta.withdraws().len(),
            ),
        }
    }
}