evergreen/common/trigger/
event.rs

1use crate as eg;
2use eg::result::{EgError, EgResult};
3use eg::EgValue;
4use std::fmt;
5
6#[derive(Debug, Clone, Copy, PartialEq)]
7pub enum EventState {
8    Pending,
9    Collecting,
10    Collected,
11    Validating,
12    Valid,
13    Invalid,
14    Reacting,
15    Reacted,
16    Cleaning,
17    Complete,
18    Error,
19}
20
21/// # Examples
22/// ```
23/// use evergreen::common::trigger::EventState;
24/// assert!(EventState::try_from("complete").is_ok());
25/// assert!(EventState::try_from("alligator").is_err());
26/// ```
27impl TryFrom<&str> for EventState {
28    type Error = EgError;
29    fn try_from(value: &str) -> Result<Self, EgError> {
30        match value {
31            "pending" => Ok(Self::Pending),
32            "collecting" => Ok(Self::Collecting),
33            "collected" => Ok(Self::Collected),
34            "validating" => Ok(Self::Validating),
35            "valid" => Ok(Self::Valid),
36            "invalid" => Ok(Self::Invalid),
37            "reacting" => Ok(Self::Reacting),
38            "reacted" => Ok(Self::Reacted),
39            "cleaning" => Ok(Self::Cleaning),
40            "complete" => Ok(Self::Complete),
41            "error" => Ok(Self::Error),
42            _ => Err(format!("Invalid Trigger Event State: {value}").into()),
43        }
44    }
45}
46
47impl From<EventState> for &'static str {
48    fn from(state: EventState) -> &'static str {
49        match state {
50            EventState::Pending => "pending",
51            EventState::Collecting => "collecting",
52            EventState::Collected => "collected",
53            EventState::Validating => "validating",
54            EventState::Valid => "valid",
55            EventState::Invalid => "invalid",
56            EventState::Reacting => "reacting",
57            EventState::Reacted => "reacted",
58            EventState::Cleaning => "cleaning",
59            EventState::Complete => "complete",
60            EventState::Error => "error",
61        }
62    }
63}
64
65pub struct Event {
66    id: i64,
67    event_def: i64,
68    state: EventState,
69    target: EgValue,
70    target_pkey: EgValue,
71    group_value: Option<EgValue>,
72    user_data: Option<EgValue>,
73}
74
75impl fmt::Display for Event {
76    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
77        write!(f, "A/T Event id={}", self.id)
78    }
79}
80
81impl Event {
82    /// Create an Event from an un-fleshed "atev" object.
83    pub fn from_source(source: EgValue) -> EgResult<Event> {
84        // required field w/ limited set of values
85        let state: EventState = source["state"].as_str().unwrap().try_into()?;
86
87        let id = source.id()?;
88        let event_def = source["event_def"].int()?;
89
90        let user_data = if let Some(data) = source["user_data"].as_str() {
91            match EgValue::parse(data) {
92                Ok(d) => Some(d),
93                Err(e) => {
94                    return Err(format!("Invalid user data for event {id}: {e} {data}").into())
95                }
96            }
97        } else {
98            None
99        };
100
101        Ok(Event {
102            id,
103            event_def,
104            state,
105            user_data,
106            group_value: None,
107            target_pkey: source["target"].clone(),
108            target: EgValue::Null,
109        })
110    }
111
112    pub fn id(&self) -> i64 {
113        self.id
114    }
115    pub fn event_def(&self) -> i64 {
116        self.event_def
117    }
118    pub fn target(&self) -> &EgValue {
119        &self.target
120    }
121    pub fn set_target(&mut self, target: EgValue) {
122        self.target = target
123    }
124
125    /// Pkey value may be a number or string.
126    pub fn target_pkey(&self) -> &EgValue {
127        &self.target_pkey
128    }
129    pub fn state(&self) -> EventState {
130        self.state
131    }
132    pub fn set_state(&mut self, state: EventState) {
133        self.state = state;
134    }
135    pub fn user_data(&self) -> Option<&EgValue> {
136        self.user_data.as_ref()
137    }
138    pub fn group_value(&self) -> Option<&EgValue> {
139        self.group_value.as_ref()
140    }
141    pub fn set_group_value(&mut self, value: EgValue) {
142        self.group_value = Some(value);
143    }
144}
evergreen/common/trigger/event.rs

evergreen/common/trigger/
event.rs
