x12-types 0.11.1

Bindings for the ASC X12 EDI definitions
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
142
143
144
145

//! v004010 repesents all entities of the 004010 specification.

use crate::util::Parser;
use nom::multi::many0;
use nom::IResult;
use nom::Parser as _;
use serde::{Deserialize, Serialize};
use std::fmt::Display;
use validator::Validate;

pub mod segment;
pub use segment::*;

mod _204_doc;
pub use _204_doc::*;
#[cfg(test)]
mod _204_test;

mod _214_doc;
pub use _214_doc::*;
#[cfg(test)]
mod _214_test;

mod _301_doc;
pub use _301_doc::*;
#[cfg(test)]
mod _301_test;

mod _309_doc;
pub use _309_doc::*;
#[cfg(test)]
mod _309_test;

mod _310_doc;
pub use _310_doc::*;
#[cfg(test)]
mod _310_test;

mod _315_doc;
pub use _315_doc::*;
#[cfg(test)]
mod _315_test;

mod _322_doc;
pub use _322_doc::*;
#[cfg(test)]
mod _322_test;

mod _404_doc;
pub use _404_doc::*;
#[cfg(test)]
mod _404_test;

mod _810_doc;
pub use _810_doc::*;
#[cfg(test)]
mod _810_test;

mod _856_doc;
pub use _856_doc::*;
#[cfg(test)]
mod _856_test;

mod _940_doc;
pub use _940_doc::*;
#[cfg(test)]
mod _940_test;

mod _945_doc;
pub use _945_doc::*;
#[cfg(test)]
mod _945_test;

mod _997_doc;
pub use _997_doc::*;
#[cfg(test)]
mod _997_test;

mod _998_doc;
pub use _998_doc::*;
#[cfg(test)]
mod _998_test;

#[cfg(test)]
mod segments_test;

#[derive(Serialize, Deserialize, Clone, Default, Debug, PartialEq, Eq, Validate)]
pub struct Transmission<T> {
    #[validate(nested)]
    pub isa: ISA,
    pub functional_group: Vec<FunctionalGroup<T>>,
    #[validate(nested)]
    pub iea: IEA,
}

impl<'a, T: Default + Parser<&'a str, T, nom::error::Error<&'a str>>>
    Parser<&'a str, Transmission<T>, nom::error::Error<&'a str>> for Transmission<T>
{
    fn parse(input: &'a str) -> IResult<&'a str, Transmission<T>> {
        let mut output = Transmission::default();
        let (input, obj) = ISA::parse(input)?;
        output.isa = obj;
        // functional group
        let (input, gs) = GS::parse(input)?;
        let (input, t_obj) = many0(T::parse).parse(input)?;
        // let (input, t_obj) = T::parse(input)?;
        let (input, ge) = GE::parse(input)?;
        let fg = FunctionalGroup {
            gs,
            segments: t_obj,
            // segments: vec![t_obj],
            ge,
        };
        output.functional_group.push(fg);
        let (input, obj) = IEA::parse(input)?;
        output.iea = obj;
        Ok((input, output))
    }
}

impl<T: Display> Display for Transmission<T> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let mut lines = vec![];
        lines.push(format!("{}", self.isa));
        for fg in &self.functional_group {
            lines.push(format!("{}", fg.gs));
            for segment in &fg.segments {
                lines.push(format!("{segment}"));
            }
            lines.push(format!("{}", fg.ge));
        }
        lines.push(format!("{}", self.iea));
        let all = lines.join("");
        write!(f, "{all}")
    }
}

#[derive(Serialize, Deserialize, Clone, Default, Debug, PartialEq, Eq, Validate)]
pub struct FunctionalGroup<T> {
    #[validate(nested)]
    pub gs: GS,
    pub segments: Vec<T>,
    #[validate(nested)]
    pub ge: GE,
}