world-shipping 0.2.2

A simple shipping calculator
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
130
131
132
133
134
135
136
137
138
139
140
141

use crate::errors::InputValidationError;
use log::debug;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use typeshare::typeshare;

#[typeshare]
#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
pub enum Provider {
    #[serde(rename = "ups")]
    UPS,
    #[serde(rename = "fedex")]
    FedEx,
    #[serde(rename = "dhl")]
    DHL,
    #[serde(rename = "usps")]
    USPS,
    #[serde(rename = "la_poste")]
    LaPoste,
    #[serde(rename = "dpd")]
    DPD,
}

// String = Carrier service level
#[typeshare]
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct ProviderInfo {
    pub name: String,
    pub id: Provider,
    pub services: Vec<ServiceInfo>,
}

#[typeshare]
#[derive(Debug, Serialize, Deserialize, PartialEq, Clone)]
pub enum ServiceLevel {
    Standard,
    Express,
}

#[typeshare]
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct ServiceInfo {
    pub service: ServiceLevel,
    // #[serde(default)]
    // pub country: Option<String>,
    #[serde(default)]
    pub zone: Option<String>,
    pub shipping_time_days: HashMap<String, ShippingTime>,
    pub rates: Vec<RateInfo>,
}

#[typeshare]
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct ShippingTime {
    pub min: u8,
    pub max: u8,
}

#[typeshare]
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct RateInfo {
    pub name: String,
    pub max_weight: u32,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_dimensions: Option<Dimensions>,
    #[serde(default)]
    pub insurance_included: bool,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub insurance_amount: Option<u32>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub insurance_optional: Option<Vec<InsuranceOption>>,
    #[serde(default)]
    pub tracking_included: bool,
    pub rate: Vec<Rate>,
    #[serde(default)]
    pub vat_exemption: bool,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vat_exemption_text: Option<String>,
}

#[typeshare]
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Dimensions {
    pub length: Option<u32>,
    pub width: Option<u32>,
    pub height: Option<u32>,
    pub length_width_height_max: Option<u32>,
    pub longest_side_max: Option<u32>,
    pub shortest_longest_side_max: Option<u32>,
}

#[typeshare]
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct InsuranceOption {
    pub online_price: f64,
    pub insurance_amount: u32,
}

#[typeshare]
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Rate {
    pub countries: Vec<String>,
    pub online_price: f64,
    #[serde(default)]
    pub vat_exemption: bool,
}

#[typeshare]
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Region {
    pub country: String,
    pub region: Option<String>,
}

impl Region {
    pub fn new(country: String, region: Option<String>) -> Result<Self, InputValidationError> {
        Self::validate(&country, &region)?;
        Ok(Self { country, region })
    }

    fn validate(country: &str, region: &Option<String>) -> Result<(), InputValidationError> {
        let country_info = rust_iso3166::from_alpha2(country)
            .ok_or_else(|| InputValidationError::InvalidCountryCode(country.to_string()))?;

        debug!("Found country: {}", country_info.name);

        if let Some(region_code) = region {
            let _ = country_info
                .subdivisions()
                .ok_or_else(|| InputValidationError::UnexpectedRegionCode(region_code.clone()))?;

            let country_region_code = format!("{}-{}", country, region_code);
            let region = rust_iso3166::iso3166_2::from_code(&country_region_code)
                .ok_or_else(|| InputValidationError::InvalidRegionCode(region_code.clone()))?;

            debug!("Found region: {}", region.name);
        }

        Ok(())
    }
}