tackler-api 0.16.0

API components for Tackler accounting engine with native GIT SCM support
Documentation 
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

/*
 * Tackler-NG 2022-2025
 * SPDX-License-Identifier: Apache-2.0
 */

//! Transaction Geo location
//!
use crate::tackler;
use rust_decimal::Decimal;
use serde::Serialize;
use std::fmt::{Display, Formatter};

/// Geo Point
///
#[derive(Serialize, Debug, Clone)]
pub struct GeoPoint {
    /// Latitude in decimal format
    pub lat: Decimal,
    /// Longitude in decimal format
    pub lon: Decimal,
    /// optional depth/altitude, in meters
    #[serde(skip_serializing_if = "Option::is_none")]
    pub alt: Option<Decimal>,
}

impl Display for GeoPoint {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        let alt = match &self.alt {
            Some(a) => format!(",{a}"),
            None => String::new(),
        };
        write!(f, "geo:{},{}{}", self.lat, self.lon, alt)
    }
}
/// Maximum latitude 90 deg (of North)
pub const MAX_LAT: Decimal = Decimal::from_parts(90, 0, 0, false, 0);
/// Minimum latitude -90 deg (of South)
pub const MIN_LAT: Decimal = Decimal::from_parts(90, 0, 0, true, 0);
/// Maximum longitude 180 (of East)
pub const MAX_LON: Decimal = Decimal::from_parts(180, 0, 0, false, 0);
/// Minimum longitude -180 (of West)
pub const MIN_LON: Decimal = Decimal::from_parts(180, 0, 0, true, 0);
/// Minimum altitude (Jules Verne: Voyage au centre de la Terre)
pub const MIN_ALTITUDE: Decimal = Decimal::from_parts(6_378_137, 0, 0, true, 0);

#[allow(clippy::manual_range_contains)]
impl GeoPoint {
    /// Make Geo point from given coordinates.
    ///
    /// * `lat` in decimals, must be inclusive -90 -- 90
    /// * `lon` in decimals, must be inclusive -180 -- 180
    /// * `alt` in meters, must be more than -6378137 meters
    ///
    /// # Errors
    ///
    /// Returns `Err` in case of invalid coordinates
    pub fn from(
        lat: Decimal,
        lon: Decimal,
        alt: Option<Decimal>,
    ) -> Result<GeoPoint, tackler::Error> {
        if lat < MIN_LAT || MAX_LAT < lat {
            let msg = format!("Value out of specification for Latitude: {lat}");
            return Err(msg.into());
        }
        if lon < MIN_LON || MAX_LON < lon {
            let msg = format!("Value out of specification for Longitude: {lon}");
            return Err(msg.into());
        }
        if let Some(z) = alt {
            if z < Decimal::from(-6_378_137) {
                // Jules Verne: Voyage au centre de la Terre
                let msg = format!("Value Out of specification for Altitude: {z}");
                return Err(msg.into());
            }
        }
        Ok(GeoPoint { lat, lon, alt })
    }
}
#[cfg(test)]
mod tests {
    use crate::location::GeoPoint;
    use rust_decimal_macros::dec;

    // todo: GeoPoint::from + checks

    #[test]
    fn geo_display() {
        let tests: Vec<(GeoPoint, String)> = vec![
            (
                GeoPoint::from(dec!(60), dec!(24), None).unwrap(/*:test:*/),
                "geo:60,24".to_string(),
            ),
            (
                GeoPoint::from(dec!(60), dec!(24), Some(dec!(5))).unwrap(/*:test:*/),
                "geo:60,24,5".to_string(),
            ),
            (
                GeoPoint::from(dec!(60.167), dec!(24.955), Some(dec!(5.0))).unwrap(/*:test:*/),
                "geo:60.167,24.955,5.0".to_string(),
            ),
            (
                GeoPoint::from(dec!(60.167000), dec!(24.955000), Some(dec!(5.000))).unwrap(/*:test:*/),
                "geo:60.167000,24.955000,5.000".to_string(),
            ),
            (
                GeoPoint::from(dec!(-60), dec!(-24), Some(dec!(-5))).unwrap(/*:test:*/),
                "geo:-60,-24,-5".to_string(),
            ),
            (
                GeoPoint::from(dec!(-60.167), dec!(-24.955), Some(dec!(-5.0))).unwrap(/*:test:*/),
                "geo:-60.167,-24.955,-5.0".to_string(),
            ),
            (
                GeoPoint::from(dec!(-60.167000), dec!(-24.955000), Some(dec!(-5.000))).unwrap(/*:test:*/),
                "geo:-60.167000,-24.955000,-5.000".to_string(),
            ),
        ];

        let mut count = 0;
        let should_be_count = tests.len();
        for t in tests {
            let geo_str = format!("{}", t.0);
            assert_eq!(geo_str, t.1);
            count += 1;
        }
        assert_eq!(count, should_be_count);
    }
}