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
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175

use eventful::{DefaultWithPersistenceId, Effect, EntityName, EntityWrapperTrait, EventName, EventSourcedEntity, EventWrapperTrait, NamedEntity};
use serde::{Deserialize, Serialize};
use strum::IntoStaticStr;

#[derive(Clone, Serialize, Deserialize, Debug, Eq, PartialEq, IntoStaticStr)]
pub enum FrogEvent {
    Hopped { distance_mm: u32 },
    Swam { distance_mm: u32 },
    Ate,
}

#[derive(Clone, Serialize, Deserialize, Debug, Eq, PartialEq, IntoStaticStr)]
pub enum CatEvent {
    Created,
    Ran { distance_mm: u32 },
    Ate,
    Purred,
}

#[derive(Clone, Serialize, Deserialize, Debug, Eq, PartialEq)]
pub enum AnimalEvents {
    FrogEvents(FrogEvent),
    CatEvents(CatEvent),
}

impl From<CatEvent> for AnimalEvents {
    fn from(value: CatEvent) -> Self {
        AnimalEvents::CatEvents(value)
    }
}

impl From<AnimalEvents> for Option<CatEvent> {
    fn from(value: AnimalEvents) -> Self {
        match value {
            AnimalEvents::CatEvents(e) => Some(e),
            _ => None,
        }
    }
}

impl EventName for AnimalEvents {
    fn event_name(&self) -> &'static str {
        match self {
            AnimalEvents::FrogEvents(e) => e.into(),
            AnimalEvents::CatEvents(e) => e.into(),
        }
    }
}

impl EntityName for AnimalEvents {
    fn entity_name(&self) -> &'static str {
        match self {
            AnimalEvents::FrogEvents(_) => "frog",
            AnimalEvents::CatEvents(_) => "cat",
        }
    }
}

impl EventWrapperTrait for AnimalEvents {}

#[derive(Clone, Debug)]
pub struct FrogModel {
    pub name: String,
    pub hopped_distance_mm: u32,
    pub swam_distance_mm: u32,
    pub eat_count: u32,
}

impl NamedEntity for FrogModel {
    fn entity_name() -> &'static str {
        "FrogModel"
    }
}

#[derive(Debug)]
pub enum CatCommand {
    Create,
    Run { distance_mm: u32 },
}

#[derive(Clone, Debug, PartialEq)]
pub struct CatModel {
    pub name: String,
    pub ran_distance_mm: u32,
    pub eat_count: u32,
    pub purr_count: u32,
}

impl DefaultWithPersistenceId for CatModel {
    fn default_with_persistence_id(persistence_id: &str) -> Self {
        Self {
            name: persistence_id.to_string(),
            ran_distance_mm: 0,
            eat_count: 0,
            purr_count: 0,
        }
    }
}

impl EventSourcedEntity for CatModel {
    type Command = CatCommand;
    type Event = CatEvent;

    fn persistence_id(&self) -> String {
        self.name.clone()
    }

    fn process_command(&self, command: Self::Command) -> Effect<Self::Event> {
        match command {
            CatCommand::Create => {
                let events = vec![];
                Effect::StoreEvents(events)
            }
            CatCommand::Run { distance_mm: _ } => {
                let events = vec![];
                Effect::StoreEvents(events)
            }
        }
    }

    fn consume_event(&mut self, event: Self::Event) {
        match event {
            CatEvent::Created => {
                self.name = self.persistence_id();
            }
            CatEvent::Ran { distance_mm } => {
                self.ran_distance_mm += distance_mm;
            }
            CatEvent::Ate => {
                self.eat_count += 1;
            }
            CatEvent::Purred => {
                self.purr_count += 1;
            }
        }
    }
}

impl From<AnimalEntityWrapper> for Option<CatModel> {
    fn from(value: AnimalEntityWrapper) -> Self {
        match value {
            AnimalEntityWrapper::Cat(v) => Some(v),
            _ => None,
        }
    }
}

impl From<CatModel> for AnimalEntityWrapper {
    fn from(value: CatModel) -> Self {
        AnimalEntityWrapper::Cat(value)
    }
}

impl NamedEntity for CatModel {
    fn entity_name() -> &'static str {
        "CatModel"
    }
}

#[derive(Clone, Debug)]
pub enum AnimalEntityWrapper {
    Frog(FrogModel),
    Cat(CatModel),
}

impl EntityName for AnimalEntityWrapper {
    fn entity_name(&self) -> &'static str {
        match self {
            AnimalEntityWrapper::Cat(_) => CatModel::entity_name(),
            AnimalEntityWrapper::Frog(_) => FrogModel::entity_name(),
        }
    }
}

impl EntityWrapperTrait for AnimalEntityWrapper {}