1use serde::{Deserialize, Serialize};
7
8#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
10#[serde(rename = "pivotCacheDefinition")]
11pub struct PivotCacheDefinition {
12 #[serde(rename = "@xmlns", default = "crate::default_spreadsheet_ml_ns")]
13 pub xmlns: String,
14
15 #[serde(rename = "@xmlns:r", default = "crate::default_relationships_ns")]
16 pub xmlns_r: String,
17
18 #[serde(
19 rename = "@r:id",
20 alias = "@id",
21 skip_serializing_if = "Option::is_none"
22 )]
23 pub r_id: Option<String>,
24
25 #[serde(rename = "@recordCount", skip_serializing_if = "Option::is_none")]
26 pub record_count: Option<u32>,
27
28 #[serde(rename = "@refreshOnLoad", skip_serializing_if = "Option::is_none")]
29 pub refresh_on_load: Option<bool>,
30
31 #[serde(rename = "cacheSource")]
32 pub cache_source: CacheSource,
33
34 #[serde(rename = "cacheFields")]
35 pub cache_fields: CacheFields,
36}
37
38#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
40pub struct CacheSource {
41 #[serde(rename = "@type")]
42 pub source_type: String,
43
44 #[serde(rename = "worksheetSource", skip_serializing_if = "Option::is_none")]
45 pub worksheet_source: Option<WorksheetSource>,
46}
47
48#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
50pub struct WorksheetSource {
51 #[serde(rename = "@ref")]
52 pub reference: String,
53
54 #[serde(rename = "@sheet")]
55 pub sheet: String,
56}
57
58#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
60pub struct CacheFields {
61 #[serde(rename = "@count", skip_serializing_if = "Option::is_none")]
62 pub count: Option<u32>,
63
64 #[serde(rename = "cacheField", default)]
65 pub fields: Vec<CacheField>,
66}
67
68#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
70pub struct CacheField {
71 #[serde(rename = "@name")]
72 pub name: String,
73
74 #[serde(rename = "@numFmtId", skip_serializing_if = "Option::is_none")]
75 pub num_fmt_id: Option<u32>,
76
77 #[serde(rename = "sharedItems", skip_serializing_if = "Option::is_none")]
78 pub shared_items: Option<SharedItems>,
79}
80
81#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
83pub struct SharedItems {
84 #[serde(
85 rename = "@containsSemiMixedTypes",
86 skip_serializing_if = "Option::is_none"
87 )]
88 pub contains_semi_mixed_types: Option<bool>,
89
90 #[serde(rename = "@containsString", skip_serializing_if = "Option::is_none")]
91 pub contains_string: Option<bool>,
92
93 #[serde(rename = "@containsNumber", skip_serializing_if = "Option::is_none")]
94 pub contains_number: Option<bool>,
95
96 #[serde(rename = "@containsBlank", skip_serializing_if = "Option::is_none")]
97 pub contains_blank: Option<bool>,
98
99 #[serde(rename = "@count", skip_serializing_if = "Option::is_none")]
100 pub count: Option<u32>,
101
102 #[serde(rename = "s", default)]
103 pub string_items: Vec<StringItem>,
104
105 #[serde(rename = "n", default)]
106 pub number_items: Vec<NumberItem>,
107}
108
109#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
111pub struct StringItem {
112 #[serde(rename = "@v")]
113 pub value: String,
114}
115
116#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
118pub struct NumberItem {
119 #[serde(rename = "@v")]
120 pub value: f64,
121}
122
123#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
125#[serde(rename = "pivotCacheRecords")]
126pub struct PivotCacheRecords {
127 #[serde(rename = "@xmlns", default = "crate::default_spreadsheet_ml_ns")]
128 pub xmlns: String,
129
130 #[serde(rename = "@xmlns:r", default = "crate::default_relationships_ns")]
131 pub xmlns_r: String,
132
133 #[serde(rename = "@count", skip_serializing_if = "Option::is_none")]
134 pub count: Option<u32>,
135
136 #[serde(rename = "r", default)]
137 pub records: Vec<CacheRecord>,
138}
139
140#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
147pub struct CacheRecord {
148 #[serde(rename = "x", default)]
149 pub index_fields: Vec<IndexField>,
150
151 #[serde(rename = "n", default)]
152 pub number_fields: Vec<NumberField>,
153
154 #[serde(rename = "s", default)]
155 pub string_fields: Vec<StringField>,
156
157 #[serde(rename = "b", default)]
158 pub bool_fields: Vec<BoolField>,
159}
160
161#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
163pub struct IndexField {
164 #[serde(rename = "@v")]
165 pub v: u32,
166}
167
168#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
170pub struct NumberField {
171 #[serde(rename = "@v")]
172 pub v: f64,
173}
174
175#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
177pub struct StringField {
178 #[serde(rename = "@v")]
179 pub v: String,
180}
181
182#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
184pub struct BoolField {
185 #[serde(rename = "@v")]
186 pub v: bool,
187}
188
189#[cfg(test)]
190mod tests {
191 use super::*;
192
193 #[test]
194 fn test_worksheet_source_roundtrip() {
195 let src = WorksheetSource {
196 reference: "A1:D10".to_string(),
197 sheet: "Sheet1".to_string(),
198 };
199 let xml = quick_xml::se::to_string(&src).unwrap();
200 let parsed: WorksheetSource = quick_xml::de::from_str(&xml).unwrap();
201 assert_eq!(src, parsed);
202 }
203
204 #[test]
205 fn test_cache_source_roundtrip() {
206 let src = CacheSource {
207 source_type: "worksheet".to_string(),
208 worksheet_source: Some(WorksheetSource {
209 reference: "A1:D10".to_string(),
210 sheet: "Data".to_string(),
211 }),
212 };
213 let xml = quick_xml::se::to_string(&src).unwrap();
214 let parsed: CacheSource = quick_xml::de::from_str(&xml).unwrap();
215 assert_eq!(src, parsed);
216 }
217
218 #[test]
219 fn test_cache_source_without_worksheet() {
220 let src = CacheSource {
221 source_type: "external".to_string(),
222 worksheet_source: None,
223 };
224 let xml = quick_xml::se::to_string(&src).unwrap();
225 assert!(!xml.contains("worksheetSource"));
226 let parsed: CacheSource = quick_xml::de::from_str(&xml).unwrap();
227 assert_eq!(src, parsed);
228 }
229
230 #[test]
231 fn test_string_item_roundtrip() {
232 let item = StringItem {
233 value: "North".to_string(),
234 };
235 let xml = quick_xml::se::to_string(&item).unwrap();
236 let parsed: StringItem = quick_xml::de::from_str(&xml).unwrap();
237 assert_eq!(item, parsed);
238 }
239
240 #[test]
241 fn test_number_item_roundtrip() {
242 let item = NumberItem { value: 42.5 };
243 let xml = quick_xml::se::to_string(&item).unwrap();
244 let parsed: NumberItem = quick_xml::de::from_str(&xml).unwrap();
245 assert_eq!(item, parsed);
246 }
247
248 #[test]
249 fn test_shared_items_with_strings_roundtrip() {
250 let items = SharedItems {
251 contains_semi_mixed_types: Some(false),
252 contains_string: Some(true),
253 contains_number: Some(false),
254 contains_blank: None,
255 count: Some(3),
256 string_items: vec![
257 StringItem {
258 value: "North".to_string(),
259 },
260 StringItem {
261 value: "South".to_string(),
262 },
263 StringItem {
264 value: "East".to_string(),
265 },
266 ],
267 number_items: vec![],
268 };
269 let xml = quick_xml::se::to_string(&items).unwrap();
270 let parsed: SharedItems = quick_xml::de::from_str(&xml).unwrap();
271 assert_eq!(items, parsed);
272 }
273
274 #[test]
275 fn test_shared_items_with_numbers_roundtrip() {
276 let items = SharedItems {
277 contains_semi_mixed_types: None,
278 contains_string: Some(false),
279 contains_number: Some(true),
280 contains_blank: None,
281 count: Some(2),
282 string_items: vec![],
283 number_items: vec![NumberItem { value: 100.0 }, NumberItem { value: 200.0 }],
284 };
285 let xml = quick_xml::se::to_string(&items).unwrap();
286 let parsed: SharedItems = quick_xml::de::from_str(&xml).unwrap();
287 assert_eq!(items, parsed);
288 }
289
290 #[test]
291 fn test_shared_items_empty_roundtrip() {
292 let items = SharedItems {
293 contains_semi_mixed_types: None,
294 contains_string: None,
295 contains_number: None,
296 contains_blank: None,
297 count: Some(0),
298 string_items: vec![],
299 number_items: vec![],
300 };
301 let xml = quick_xml::se::to_string(&items).unwrap();
302 let parsed: SharedItems = quick_xml::de::from_str(&xml).unwrap();
303 assert_eq!(items, parsed);
304 }
305
306 #[test]
307 fn test_cache_field_roundtrip() {
308 let field = CacheField {
309 name: "Region".to_string(),
310 num_fmt_id: Some(0),
311 shared_items: Some(SharedItems {
312 contains_semi_mixed_types: None,
313 contains_string: Some(true),
314 contains_number: None,
315 contains_blank: None,
316 count: Some(2),
317 string_items: vec![
318 StringItem {
319 value: "North".to_string(),
320 },
321 StringItem {
322 value: "South".to_string(),
323 },
324 ],
325 number_items: vec![],
326 }),
327 };
328 let xml = quick_xml::se::to_string(&field).unwrap();
329 let parsed: CacheField = quick_xml::de::from_str(&xml).unwrap();
330 assert_eq!(field, parsed);
331 }
332
333 #[test]
334 fn test_cache_field_no_shared_items() {
335 let field = CacheField {
336 name: "Amount".to_string(),
337 num_fmt_id: None,
338 shared_items: None,
339 };
340 let xml = quick_xml::se::to_string(&field).unwrap();
341 assert!(!xml.contains("sharedItems"));
342 assert!(!xml.contains("numFmtId"));
343 let parsed: CacheField = quick_xml::de::from_str(&xml).unwrap();
344 assert_eq!(field, parsed);
345 }
346
347 #[test]
348 fn test_cache_fields_roundtrip() {
349 let fields = CacheFields {
350 count: Some(2),
351 fields: vec![
352 CacheField {
353 name: "Region".to_string(),
354 num_fmt_id: Some(0),
355 shared_items: None,
356 },
357 CacheField {
358 name: "Sales".to_string(),
359 num_fmt_id: Some(0),
360 shared_items: None,
361 },
362 ],
363 };
364 let xml = quick_xml::se::to_string(&fields).unwrap();
365 let parsed: CacheFields = quick_xml::de::from_str(&xml).unwrap();
366 assert_eq!(fields, parsed);
367 }
368
369 #[test]
370 fn test_pivot_cache_definition_roundtrip() {
371 let def = PivotCacheDefinition {
372 xmlns: "http://schemas.openxmlformats.org/spreadsheetml/2006/main".to_string(),
373 xmlns_r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
374 .to_string(),
375 r_id: None,
376 record_count: Some(5),
377 refresh_on_load: Some(true),
378 cache_source: CacheSource {
379 source_type: "worksheet".to_string(),
380 worksheet_source: Some(WorksheetSource {
381 reference: "A1:C6".to_string(),
382 sheet: "Data".to_string(),
383 }),
384 },
385 cache_fields: CacheFields {
386 count: Some(3),
387 fields: vec![
388 CacheField {
389 name: "Name".to_string(),
390 num_fmt_id: Some(0),
391 shared_items: None,
392 },
393 CacheField {
394 name: "Region".to_string(),
395 num_fmt_id: Some(0),
396 shared_items: None,
397 },
398 CacheField {
399 name: "Sales".to_string(),
400 num_fmt_id: Some(0),
401 shared_items: None,
402 },
403 ],
404 },
405 };
406 let xml = quick_xml::se::to_string(&def).unwrap();
407 let parsed: PivotCacheDefinition = quick_xml::de::from_str(&xml).unwrap();
408 assert_eq!(def, parsed);
409 }
410
411 #[test]
412 fn test_pivot_cache_definition_structure() {
413 let def = PivotCacheDefinition {
414 xmlns: "http://schemas.openxmlformats.org/spreadsheetml/2006/main".to_string(),
415 xmlns_r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
416 .to_string(),
417 r_id: Some("rId1".to_string()),
418 record_count: Some(10),
419 refresh_on_load: Some(true),
420 cache_source: CacheSource {
421 source_type: "worksheet".to_string(),
422 worksheet_source: Some(WorksheetSource {
423 reference: "A1:D11".to_string(),
424 sheet: "Sheet1".to_string(),
425 }),
426 },
427 cache_fields: CacheFields {
428 count: Some(1),
429 fields: vec![CacheField {
430 name: "Col1".to_string(),
431 num_fmt_id: None,
432 shared_items: None,
433 }],
434 },
435 };
436 let xml = quick_xml::se::to_string(&def).unwrap();
437 assert!(xml.contains("<pivotCacheDefinition"));
438 assert!(xml.contains("recordCount=\"10\""));
439 assert!(xml.contains("<cacheSource"));
440 assert!(xml.contains("type=\"worksheet\""));
441 assert!(xml.contains("<worksheetSource"));
442 assert!(xml.contains("<cacheFields"));
443 }
444
445 #[test]
446 fn test_index_field_roundtrip() {
447 let field = IndexField { v: 3 };
448 let xml = quick_xml::se::to_string(&field).unwrap();
449 let parsed: IndexField = quick_xml::de::from_str(&xml).unwrap();
450 assert_eq!(field, parsed);
451 }
452
453 #[test]
454 fn test_number_field_roundtrip() {
455 let field = NumberField { v: 99.5 };
456 let xml = quick_xml::se::to_string(&field).unwrap();
457 let parsed: NumberField = quick_xml::de::from_str(&xml).unwrap();
458 assert_eq!(field, parsed);
459 }
460
461 #[test]
462 fn test_string_field_roundtrip() {
463 let field = StringField {
464 v: "hello".to_string(),
465 };
466 let xml = quick_xml::se::to_string(&field).unwrap();
467 let parsed: StringField = quick_xml::de::from_str(&xml).unwrap();
468 assert_eq!(field, parsed);
469 }
470
471 #[test]
472 fn test_bool_field_roundtrip() {
473 let field = BoolField { v: true };
474 let xml = quick_xml::se::to_string(&field).unwrap();
475 let parsed: BoolField = quick_xml::de::from_str(&xml).unwrap();
476 assert_eq!(field, parsed);
477 }
478
479 #[test]
480 fn test_cache_record_roundtrip() {
481 let record = CacheRecord {
482 index_fields: vec![IndexField { v: 0 }, IndexField { v: 1 }],
483 number_fields: vec![NumberField { v: 150.0 }],
484 string_fields: vec![],
485 bool_fields: vec![],
486 };
487 let xml = quick_xml::se::to_string(&record).unwrap();
488 let parsed: CacheRecord = quick_xml::de::from_str(&xml).unwrap();
489 assert_eq!(record, parsed);
490 }
491
492 #[test]
493 fn test_cache_record_with_strings() {
494 let record = CacheRecord {
495 index_fields: vec![],
496 number_fields: vec![],
497 string_fields: vec![
498 StringField {
499 v: "alpha".to_string(),
500 },
501 StringField {
502 v: "beta".to_string(),
503 },
504 ],
505 bool_fields: vec![BoolField { v: false }],
506 };
507 let xml = quick_xml::se::to_string(&record).unwrap();
508 let parsed: CacheRecord = quick_xml::de::from_str(&xml).unwrap();
509 assert_eq!(record, parsed);
510 }
511
512 #[test]
513 fn test_pivot_cache_records_roundtrip() {
514 let records = PivotCacheRecords {
515 xmlns: "http://schemas.openxmlformats.org/spreadsheetml/2006/main".to_string(),
516 xmlns_r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
517 .to_string(),
518 count: Some(2),
519 records: vec![
520 CacheRecord {
521 index_fields: vec![IndexField { v: 0 }],
522 number_fields: vec![NumberField { v: 100.0 }],
523 string_fields: vec![],
524 bool_fields: vec![],
525 },
526 CacheRecord {
527 index_fields: vec![IndexField { v: 1 }],
528 number_fields: vec![NumberField { v: 200.0 }],
529 string_fields: vec![],
530 bool_fields: vec![],
531 },
532 ],
533 };
534 let xml = quick_xml::se::to_string(&records).unwrap();
535 let parsed: PivotCacheRecords = quick_xml::de::from_str(&xml).unwrap();
536 assert_eq!(records, parsed);
537 }
538
539 #[test]
540 fn test_pivot_cache_records_empty() {
541 let records = PivotCacheRecords {
542 xmlns: "http://schemas.openxmlformats.org/spreadsheetml/2006/main".to_string(),
543 xmlns_r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
544 .to_string(),
545 count: Some(0),
546 records: vec![],
547 };
548 let xml = quick_xml::se::to_string(&records).unwrap();
549 let parsed: PivotCacheRecords = quick_xml::de::from_str(&xml).unwrap();
550 assert_eq!(records, parsed);
551 }
552
553 #[test]
554 fn test_pivot_cache_records_structure() {
555 let records = PivotCacheRecords {
556 xmlns: "http://schemas.openxmlformats.org/spreadsheetml/2006/main".to_string(),
557 xmlns_r: "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
558 .to_string(),
559 count: Some(1),
560 records: vec![CacheRecord {
561 index_fields: vec![IndexField { v: 0 }],
562 number_fields: vec![],
563 string_fields: vec![],
564 bool_fields: vec![],
565 }],
566 };
567 let xml = quick_xml::se::to_string(&records).unwrap();
568 assert!(xml.contains("<pivotCacheRecords"));
569 assert!(xml.contains("count=\"1\""));
570 }
571}