ooxmlsdk_build/
models.rs

1use serde::{Deserialize, Serialize};
2
3#[derive(Clone, Debug, Default, Deserialize, Serialize)]
4#[serde(default, rename_all = "PascalCase")]
5pub struct OpenXmlPart {
6  pub root: String,
7  pub name: String,
8  pub base: String,
9  pub content_type: String,
10  pub relationship_type: String,
11  pub target: String,
12  pub root_element: String,
13  pub extension: String,
14  pub paths: OpenXmlPartPaths,
15  pub version: String,
16  pub children: Vec<OpenXmlPartChild>,
17  #[serde(skip)]
18  pub module_name: String,
19}
20
21#[derive(Clone, Debug, Default, Deserialize, Serialize)]
22#[serde(default, rename_all = "PascalCase")]
23pub struct OpenXmlPartPaths {
24  pub general: String,
25  pub word: String,
26  pub excel: String,
27  pub power_point: String,
28}
29
30#[derive(Clone, Debug, Default, Deserialize, Serialize)]
31#[serde(default, rename_all = "PascalCase")]
32pub struct OpenXmlPartChild {
33  pub min_occurs_is_non_zero: bool,
34  pub max_occurs_great_than_one: bool,
35  pub api_name: String,
36  pub name: String,
37  pub has_fixed_content: bool,
38  pub is_data_part_reference: bool,
39  pub is_special_embedded_part: bool,
40}
41
42#[derive(Clone, Debug, Default, Deserialize, Serialize)]
43#[serde(default, rename_all = "PascalCase")]
44pub struct OpenXmlSchema {
45  pub target_namespace: String,
46  pub types: Vec<OpenXmlSchemaType>,
47  pub enums: Vec<OpenXmlSchemaEnum>,
48  #[serde(skip)]
49  pub module_name: String,
50}
51
52#[derive(Clone, Debug, Default, Deserialize, Serialize)]
53#[serde(default, rename_all = "PascalCase")]
54pub struct OpenXmlSchemaType {
55  pub name: String,
56  pub class_name: String,
57  pub summary: String,
58  pub version: String,
59  pub part: String,
60  pub composite_type: String,
61  pub base_class: String,
62  pub is_leaf_text: bool,
63  pub is_leaf_element: bool,
64  pub is_derived: bool,
65  pub is_abstract: bool,
66  pub attributes: Vec<OpenXmlSchemaTypeAttribute>,
67  pub children: Vec<OpenXmlSchemaTypeChild>,
68  pub particle: OpenXmlSchemaTypeParticle,
69  #[serde(skip)]
70  pub module_name: String,
71}
72
73impl OpenXmlSchemaType {
74  pub fn is_one_sequence_flatten(&self) -> bool {
75    if self.composite_type == "OneSequence" || self.particle.kind == "Sequence" {
76      for p in &self.particle.items {
77        if !p.kind.is_empty() || !p.items.is_empty() {
78          return false;
79        }
80      }
81
82      true
83    } else {
84      false
85    }
86  }
87}
88
89#[derive(Clone, Debug, Default, Deserialize, Serialize)]
90#[serde(default, rename_all = "PascalCase")]
91pub struct OpenXmlSchemaTypeAttribute {
92  pub q_name: String,
93  pub property_name: String,
94  pub r#type: String,
95  pub property_comments: String,
96  pub version: String,
97  pub validators: Vec<OpenXmlSchemaTypeAttributeValidator>,
98}
99
100#[derive(Clone, Debug, Default, Deserialize, Serialize)]
101#[serde(default, rename_all = "PascalCase")]
102pub struct OpenXmlSchemaTypeAttributeValidator {
103  pub name: String,
104  pub is_list: bool,
105  pub r#type: String,
106  pub union_id: u64,
107  pub is_initial_version: bool,
108  pub arguments: Vec<OpenXmlSchemaTypeAttributeValidatorArgument>,
109}
110
111#[derive(Clone, Debug, Default, Deserialize, Serialize)]
112#[serde(default, rename_all = "PascalCase")]
113pub struct OpenXmlSchemaTypeAttributeValidatorArgument {
114  pub name: String,
115  pub r#type: String,
116  pub value: String,
117}
118
119#[derive(Clone, Debug, Default, Deserialize, Serialize)]
120#[serde(default, rename_all = "PascalCase")]
121pub struct OpenXmlSchemaTypeChild {
122  pub name: String,
123  pub property_name: String,
124  pub property_comments: String,
125}
126
127#[derive(Clone, Debug, Default, Deserialize, Serialize)]
128#[serde(default, rename_all = "PascalCase")]
129pub struct OpenXmlSchemaTypeParticle {
130  pub kind: String,
131  pub name: String,
132  pub occurs: Vec<OpenXmlSchemaTypeParticleOccur>,
133  pub items: Vec<OpenXmlSchemaTypeParticle>,
134  pub initial_version: String,
135  pub require_filter: bool,
136  pub namespace: String,
137}
138
139#[derive(Clone, Debug, Default, Deserialize, Serialize)]
140#[serde(default, rename_all = "PascalCase")]
141pub struct OpenXmlSchemaTypeParticleOccur {
142  pub max: u64,
143  pub min: u64,
144  pub include_version: bool,
145  pub version: String,
146}
147
148#[derive(Clone, Debug, Default, Deserialize, Serialize)]
149#[serde(default, rename_all = "PascalCase")]
150pub struct OpenXmlSchemaEnum {
151  pub name: String,
152  pub r#type: String,
153  pub facets: Vec<OpenXmlSchemaEnumFacet>,
154  pub version: String,
155  #[serde(skip)]
156  pub module_name: String,
157}
158
159#[derive(Clone, Debug, Default, Deserialize, Serialize)]
160#[serde(default, rename_all = "PascalCase")]
161pub struct OpenXmlSchemaEnumFacet {
162  pub name: String,
163  pub value: String,
164  pub version: String,
165}
166
167#[derive(Clone, Debug, Default, Deserialize, Serialize)]
168#[serde(default, rename_all = "PascalCase")]
169pub struct OpenXmlNamespace {
170  pub prefix: String,
171  pub uri: String,
172  pub version: String,
173}
174
175#[derive(Clone, Debug, Default, Deserialize, Serialize)]
176#[serde(default, rename_all = "PascalCase")]
177pub struct TypedNamespace {
178  pub prefix: String,
179  pub namespace: String,
180}
181
182#[derive(Clone, Debug, Default, Deserialize, Serialize)]
183#[serde(default, rename_all = "PascalCase")]
184pub struct TypedSchema {
185  pub name: String,
186  pub class_name: String,
187  pub part_class_name: String,
188}