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

//! Modifiers which can be injected by the application logic to change the
//! state dynamically per request.

use crate::api;

/// `StatusModifier`s are used to modify the status
pub trait StatusModifier: Send + Sync {
    /// Called after all registered sensors are read
    fn modify(&self, status: &mut api::Status);
}

/// This modifier updates the opening state based on the
/// first people now present sensor (if present).
pub struct StateFromPeopleNowPresent;

impl StatusModifier for StateFromPeopleNowPresent {
    fn modify(&self, status: &mut api::Status) {
        // Update state depending on number of people present
        let people_now_present: Option<u64> = status
            .sensors
            .as_ref()
            .and_then(|sensors: &api::Sensors| sensors.people_now_present.first())
            .map(|sensor: &api::PeopleNowPresentSensor| sensor.value);
        if let Some(count) = people_now_present {
            status.state.open = Some(count > 0);
            if count == 1 {
                status.state.message = Some(format!("{} person here right now", count));
            } else if count > 1 {
                status.state.message = Some(format!("{} people here right now", count));
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    mod state_from_people_now_present {
        use super::*;

        #[test]
        fn no_sensors() {
            let mut status = api::Status::default();
            status.sensors = None;
            assert_eq!(status.state.message, None);
            StateFromPeopleNowPresent.modify(&mut status);
            assert_eq!(status.sensors, None);
            assert_eq!(status.state.message, None);
        }

        #[test]
        fn no_people_present_sensor() {
            let mut status = api::Status::default();
            status.sensors = Some(api::Sensors {
                people_now_present: vec![],
                temperature: vec![],
            });
            assert_eq!(status.state.message, None);
            StateFromPeopleNowPresent.modify(&mut status);
            assert_eq!(status.state.message, None);
        }

        fn make_pnp_sensor(value: u64) -> api::PeopleNowPresentSensor {
            api::PeopleNowPresentSensor {
                location: None,
                name: None,
                names: None,
                description: None,
                value,
            }
        }

        #[test]
        fn zero_people_present() {
            let mut status = api::Status::default();
            status.state.message = Some("This will remain unchanged.".to_string());
            status.sensors = Some(api::Sensors {
                people_now_present: vec![make_pnp_sensor(0)],
                temperature: vec![],
            });
            assert_eq!(
                status.state.message,
                Some("This will remain unchanged.".to_string())
            );
            StateFromPeopleNowPresent.modify(&mut status);
            assert_eq!(
                status.state.message,
                Some("This will remain unchanged.".to_string())
            );
        }

        #[test]
        fn one_person_present() {
            let mut status = api::Status::default();
            status.sensors = Some(api::Sensors {
                people_now_present: vec![make_pnp_sensor(1)],
                temperature: vec![],
            });
            assert_eq!(status.state.message, None);
            StateFromPeopleNowPresent.modify(&mut status);
            assert_eq!(status.state.message, Some("1 person here right now".to_string()));
        }

        #[test]
        fn two_people_present() {
            let mut status = api::Status::default();
            status.sensors = Some(api::Sensors {
                people_now_present: vec![make_pnp_sensor(2)],
                temperature: vec![],
            });
            assert_eq!(status.state.message, None);
            StateFromPeopleNowPresent.modify(&mut status);
            assert_eq!(status.state.message, Some("2 people here right now".to_string()));
        }
    }
}