x12_alt 0.1.0

Data types for X12 EDI
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

use std::fmt;
use serde::{de, Deserialize, ser, Serialize};
/**648

See docs at <https://www.stedi.com/edi/x12-005010/element/648>*/
#[derive(Debug, Clone, Copy, PartialEq)]
pub enum PriceMultiplierQualifier {
    ///CSD - Cost Markup Multiplier - Original Cost
    CostMarkupMultiplierOriginalCost,
    ///CSR - Cost Markup Multiplier - Retail Cost
    CostMarkupMultiplierRetailCost,
    ///DIS - Discount Multiplier
    DiscountMultiplier,
    ///ILP - Cost Markup Multiplier - Wholesale Cost
    CostMarkupMultiplierWholesaleCost,
    ///PSP - Percent Solution Multiplier
    PercentSolutionMultiplier,
    ///SEL - Selling Multiplier
    SellingMultiplier,
}
impl PriceMultiplierQualifier {
    pub fn code(&self) -> &str {
        {
            use PriceMultiplierQualifier::*;
            match self {
                CostMarkupMultiplierOriginalCost => "CSD",
                CostMarkupMultiplierRetailCost => "CSR",
                DiscountMultiplier => "DIS",
                CostMarkupMultiplierWholesaleCost => "ILP",
                PercentSolutionMultiplier => "PSP",
                SellingMultiplier => "SEL",
            }
        }
    }
    pub fn from_code(code: &[u8]) -> Option<PriceMultiplierQualifier> {
        use PriceMultiplierQualifier::*;
        match code {
            b"CSD" => Some(CostMarkupMultiplierOriginalCost),
            b"CSR" => Some(CostMarkupMultiplierRetailCost),
            b"DIS" => Some(DiscountMultiplier),
            b"ILP" => Some(CostMarkupMultiplierWholesaleCost),
            b"PSP" => Some(PercentSolutionMultiplier),
            b"SEL" => Some(SellingMultiplier),
            _ => None,
        }
    }
    fn description(&self) -> &str {
        use PriceMultiplierQualifier::*;
        match self {
            CostMarkupMultiplierOriginalCost => "Cost Markup Multiplier - Original Cost",
            CostMarkupMultiplierRetailCost => "Cost Markup Multiplier - Retail Cost",
            DiscountMultiplier => "Discount Multiplier",
            CostMarkupMultiplierWholesaleCost => {
                "Cost Markup Multiplier - Wholesale Cost"
            }
            PercentSolutionMultiplier => "Percent Solution Multiplier",
            SellingMultiplier => "Selling Multiplier",
        }
    }
    fn from_description(description: &str) -> Option<PriceMultiplierQualifier> {
        {
            use PriceMultiplierQualifier::*;
            match description {
                "Cost Markup Multiplier - Original Cost" => {
                    Some(CostMarkupMultiplierOriginalCost)
                }
                "Cost Markup Multiplier - Retail Cost" => {
                    Some(CostMarkupMultiplierRetailCost)
                }
                "Discount Multiplier" => Some(DiscountMultiplier),
                "Cost Markup Multiplier - Wholesale Cost" => {
                    Some(CostMarkupMultiplierWholesaleCost)
                }
                "Percent Solution Multiplier" => Some(PercentSolutionMultiplier),
                "Selling Multiplier" => Some(SellingMultiplier),
                _ => None,
            }
        }
    }
}
impl Serialize for PriceMultiplierQualifier {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: ser::Serializer,
    {
        let value = if serializer.is_human_readable() {
            self.description()
        } else {
            self.code()
        };
        serializer.serialize_str(value)
    }
}
struct Visitor;
impl<'de> de::Visitor<'de> for Visitor {
    type Value = PriceMultiplierQualifier;
    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("Price Multiplier Qualifier")
    }
    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        PriceMultiplierQualifier::from_description(v)
            .ok_or_else(|| E::custom(
                format!("Invalid Price Multiplier Qualifier: {}", v),
            ))
    }
    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        PriceMultiplierQualifier::from_code(v)
            .ok_or_else(|| E::custom(
                format!(
                    "Invalid Price Multiplier Qualifier: {}", std::str::from_utf8(v)
                    .unwrap()
                ),
            ))
    }
}
impl<'de> Deserialize<'de> for PriceMultiplierQualifier {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: de::Deserializer<'de>,
    {
        if deserializer.is_human_readable() {
            deserializer.deserialize_str(Visitor)
        } else {
            deserializer.deserialize_bytes(Visitor)
        }
    }
}