1use serde::{Deserialize, Serialize};
6
7use crate::namespaces;
8
9#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
11#[serde(rename = "workbook")]
12pub struct WorkbookXml {
13 #[serde(rename = "@xmlns", default = "crate::default_spreadsheet_ml_ns")]
14 pub xmlns: String,
15
16 #[serde(rename = "@xmlns:r", default = "crate::default_relationships_ns")]
17 pub xmlns_r: String,
18
19 #[serde(rename = "fileVersion", skip_serializing_if = "Option::is_none")]
20 pub file_version: Option<FileVersion>,
21
22 #[serde(rename = "fileSharing", skip_serializing_if = "Option::is_none")]
23 pub file_sharing: Option<FileSharing>,
24
25 #[serde(rename = "workbookPr", skip_serializing_if = "Option::is_none")]
26 pub workbook_pr: Option<WorkbookPr>,
27
28 #[serde(rename = "workbookProtection", skip_serializing_if = "Option::is_none")]
29 pub workbook_protection: Option<WorkbookProtection>,
30
31 #[serde(rename = "bookViews", skip_serializing_if = "Option::is_none")]
32 pub book_views: Option<BookViews>,
33
34 #[serde(rename = "sheets")]
35 pub sheets: Sheets,
36
37 #[serde(rename = "externalReferences", skip_serializing_if = "Option::is_none")]
38 pub external_references: Option<ExternalReferences>,
39
40 #[serde(rename = "definedNames", skip_serializing_if = "Option::is_none")]
41 pub defined_names: Option<DefinedNames>,
42
43 #[serde(rename = "calcPr", skip_serializing_if = "Option::is_none")]
44 pub calc_pr: Option<CalcPr>,
45
46 #[serde(rename = "oleSize", skip_serializing_if = "Option::is_none")]
47 pub ole_size: Option<OleSize>,
48
49 #[serde(rename = "pivotCaches", skip_serializing_if = "Option::is_none")]
50 pub pivot_caches: Option<PivotCaches>,
51}
52
53#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
55pub struct FileVersion {
56 #[serde(rename = "@appName", skip_serializing_if = "Option::is_none")]
57 pub app_name: Option<String>,
58
59 #[serde(rename = "@lastEdited", skip_serializing_if = "Option::is_none")]
60 pub last_edited: Option<String>,
61
62 #[serde(rename = "@lowestEdited", skip_serializing_if = "Option::is_none")]
63 pub lowest_edited: Option<String>,
64
65 #[serde(rename = "@rupBuild", skip_serializing_if = "Option::is_none")]
66 pub rup_build: Option<String>,
67}
68
69#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
71pub struct FileSharing {
72 #[serde(
73 rename = "@readOnlyRecommended",
74 skip_serializing_if = "Option::is_none"
75 )]
76 pub read_only_recommended: Option<bool>,
77
78 #[serde(rename = "@userName", skip_serializing_if = "Option::is_none")]
79 pub user_name: Option<String>,
80
81 #[serde(
82 rename = "@reservationPassword",
83 skip_serializing_if = "Option::is_none"
84 )]
85 pub reservation_password: Option<String>,
86
87 #[serde(rename = "@algorithmName", skip_serializing_if = "Option::is_none")]
88 pub algorithm_name: Option<String>,
89
90 #[serde(rename = "@hashValue", skip_serializing_if = "Option::is_none")]
91 pub hash_value: Option<String>,
92
93 #[serde(rename = "@saltValue", skip_serializing_if = "Option::is_none")]
94 pub salt_value: Option<String>,
95
96 #[serde(rename = "@spinCount", skip_serializing_if = "Option::is_none")]
97 pub spin_count: Option<u32>,
98}
99
100#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
102pub struct WorkbookPr {
103 #[serde(rename = "@date1904", skip_serializing_if = "Option::is_none")]
104 pub date1904: Option<bool>,
105
106 #[serde(rename = "@dateCompatibility", skip_serializing_if = "Option::is_none")]
107 pub date_compatibility: Option<bool>,
108
109 #[serde(rename = "@filterPrivacy", skip_serializing_if = "Option::is_none")]
110 pub filter_privacy: Option<bool>,
111
112 #[serde(
113 rename = "@defaultThemeVersion",
114 skip_serializing_if = "Option::is_none"
115 )]
116 pub default_theme_version: Option<u32>,
117
118 #[serde(rename = "@showObjects", skip_serializing_if = "Option::is_none")]
119 pub show_objects: Option<String>,
120
121 #[serde(rename = "@backupFile", skip_serializing_if = "Option::is_none")]
122 pub backup_file: Option<bool>,
123
124 #[serde(rename = "@codeName", skip_serializing_if = "Option::is_none")]
125 pub code_name: Option<String>,
126
127 #[serde(
128 rename = "@checkCompatibility",
129 skip_serializing_if = "Option::is_none"
130 )]
131 pub check_compatibility: Option<bool>,
132
133 #[serde(
134 rename = "@autoCompressPictures",
135 skip_serializing_if = "Option::is_none"
136 )]
137 pub auto_compress_pictures: Option<bool>,
138
139 #[serde(
140 rename = "@refreshAllConnections",
141 skip_serializing_if = "Option::is_none"
142 )]
143 pub refresh_all_connections: Option<bool>,
144
145 #[serde(
146 rename = "@saveExternalLinkValues",
147 skip_serializing_if = "Option::is_none"
148 )]
149 pub save_external_link_values: Option<bool>,
150
151 #[serde(rename = "@updateLinks", skip_serializing_if = "Option::is_none")]
152 pub update_links: Option<String>,
153
154 #[serde(
155 rename = "@hidePivotFieldList",
156 skip_serializing_if = "Option::is_none"
157 )]
158 pub hide_pivot_field_list: Option<bool>,
159
160 #[serde(
161 rename = "@showPivotChartFilter",
162 skip_serializing_if = "Option::is_none"
163 )]
164 pub show_pivot_chart_filter: Option<bool>,
165
166 #[serde(rename = "@allowRefreshQuery", skip_serializing_if = "Option::is_none")]
167 pub allow_refresh_query: Option<bool>,
168
169 #[serde(rename = "@publishItems", skip_serializing_if = "Option::is_none")]
170 pub publish_items: Option<bool>,
171
172 #[serde(
173 rename = "@showBorderUnselectedTables",
174 skip_serializing_if = "Option::is_none"
175 )]
176 pub show_border_unselected_tables: Option<bool>,
177
178 #[serde(rename = "@promptedSolutions", skip_serializing_if = "Option::is_none")]
179 pub prompted_solutions: Option<bool>,
180
181 #[serde(rename = "@showInkAnnotation", skip_serializing_if = "Option::is_none")]
182 pub show_ink_annotation: Option<bool>,
183}
184
185#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
187pub struct BookViews {
188 #[serde(rename = "workbookView")]
189 pub workbook_views: Vec<WorkbookView>,
190}
191
192#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
194pub struct WorkbookView {
195 #[serde(rename = "@xWindow", skip_serializing_if = "Option::is_none")]
196 pub x_window: Option<i32>,
197
198 #[serde(rename = "@yWindow", skip_serializing_if = "Option::is_none")]
199 pub y_window: Option<i32>,
200
201 #[serde(rename = "@windowWidth", skip_serializing_if = "Option::is_none")]
202 pub window_width: Option<u32>,
203
204 #[serde(rename = "@windowHeight", skip_serializing_if = "Option::is_none")]
205 pub window_height: Option<u32>,
206
207 #[serde(rename = "@activeTab", skip_serializing_if = "Option::is_none")]
208 pub active_tab: Option<u32>,
209}
210
211#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
213pub struct Sheets {
214 #[serde(rename = "sheet")]
215 pub sheets: Vec<SheetEntry>,
216}
217
218#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
220pub struct ExternalReferences {
221 #[serde(rename = "externalReference", default)]
222 pub references: Vec<ExternalReference>,
223}
224
225#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
227pub struct ExternalReference {
228 #[serde(rename = "@r:id", alias = "@id")]
229 pub r_id: String,
230}
231
232#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
234pub struct SheetEntry {
235 #[serde(rename = "@name")]
236 pub name: String,
237
238 #[serde(rename = "@sheetId")]
239 pub sheet_id: u32,
240
241 #[serde(rename = "@state", skip_serializing_if = "Option::is_none")]
242 pub state: Option<String>,
243
244 #[serde(rename = "@r:id", alias = "@id")]
245 pub r_id: String,
246}
247
248#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
250pub struct DefinedNames {
251 #[serde(rename = "definedName", default)]
252 pub defined_names: Vec<DefinedName>,
253}
254
255#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
257pub struct DefinedName {
258 #[serde(rename = "@name")]
259 pub name: String,
260
261 #[serde(rename = "@localSheetId", skip_serializing_if = "Option::is_none")]
262 pub local_sheet_id: Option<u32>,
263
264 #[serde(rename = "@comment", skip_serializing_if = "Option::is_none")]
265 pub comment: Option<String>,
266
267 #[serde(rename = "@hidden", skip_serializing_if = "Option::is_none")]
268 pub hidden: Option<bool>,
269
270 #[serde(rename = "$value")]
272 pub value: String,
273}
274
275#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
277pub struct WorkbookProtection {
278 #[serde(rename = "@workbookPassword", skip_serializing_if = "Option::is_none")]
279 pub workbook_password: Option<String>,
280
281 #[serde(rename = "@lockStructure", skip_serializing_if = "Option::is_none")]
282 pub lock_structure: Option<bool>,
283
284 #[serde(rename = "@lockWindows", skip_serializing_if = "Option::is_none")]
285 pub lock_windows: Option<bool>,
286
287 #[serde(rename = "@revisionsPassword", skip_serializing_if = "Option::is_none")]
288 pub revisions_password: Option<String>,
289
290 #[serde(rename = "@lockRevision", skip_serializing_if = "Option::is_none")]
291 pub lock_revision: Option<bool>,
292}
293
294#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
296pub struct CalcPr {
297 #[serde(rename = "@calcId", skip_serializing_if = "Option::is_none")]
298 pub calc_id: Option<u32>,
299
300 #[serde(rename = "@calcMode", skip_serializing_if = "Option::is_none")]
301 pub calc_mode: Option<String>,
302
303 #[serde(rename = "@fullCalcOnLoad", skip_serializing_if = "Option::is_none")]
304 pub full_calc_on_load: Option<bool>,
305
306 #[serde(rename = "@refMode", skip_serializing_if = "Option::is_none")]
307 pub ref_mode: Option<String>,
308
309 #[serde(rename = "@iterate", skip_serializing_if = "Option::is_none")]
310 pub iterate: Option<bool>,
311
312 #[serde(rename = "@iterateCount", skip_serializing_if = "Option::is_none")]
313 pub iterate_count: Option<u32>,
314
315 #[serde(rename = "@iterateDelta", skip_serializing_if = "Option::is_none")]
316 pub iterate_delta: Option<f64>,
317
318 #[serde(rename = "@fullPrecision", skip_serializing_if = "Option::is_none")]
319 pub full_precision: Option<bool>,
320
321 #[serde(rename = "@calcCompleted", skip_serializing_if = "Option::is_none")]
322 pub calc_completed: Option<bool>,
323
324 #[serde(rename = "@calcOnSave", skip_serializing_if = "Option::is_none")]
325 pub calc_on_save: Option<bool>,
326
327 #[serde(rename = "@concurrentCalc", skip_serializing_if = "Option::is_none")]
328 pub concurrent_calc: Option<bool>,
329
330 #[serde(
331 rename = "@concurrentManualCount",
332 skip_serializing_if = "Option::is_none"
333 )]
334 pub concurrent_manual_count: Option<u32>,
335
336 #[serde(rename = "@forceFullCalc", skip_serializing_if = "Option::is_none")]
337 pub force_full_calc: Option<bool>,
338}
339
340#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
342pub struct OleSize {
343 #[serde(rename = "@ref")]
344 pub reference: String,
345}
346
347#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
349pub struct PivotCaches {
350 #[serde(rename = "pivotCache", default)]
351 pub caches: Vec<PivotCacheEntry>,
352}
353
354#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
356pub struct PivotCacheEntry {
357 #[serde(rename = "@cacheId")]
358 pub cache_id: u32,
359
360 #[serde(rename = "@r:id", alias = "@id")]
361 pub r_id: String,
362}
363
364impl Default for WorkbookXml {
365 fn default() -> Self {
366 Self {
367 xmlns: namespaces::SPREADSHEET_ML.to_string(),
368 xmlns_r: namespaces::RELATIONSHIPS.to_string(),
369 file_version: None,
370 file_sharing: None,
371 workbook_pr: None,
372 workbook_protection: None,
373 book_views: None,
374 sheets: Sheets {
375 sheets: vec![SheetEntry {
376 name: "Sheet1".to_string(),
377 sheet_id: 1,
378 state: None,
379 r_id: "rId1".to_string(),
380 }],
381 },
382 external_references: None,
383 defined_names: None,
384 calc_pr: None,
385 ole_size: None,
386 pivot_caches: None,
387 }
388 }
389}
390
391#[cfg(test)]
392mod tests {
393 use super::*;
394
395 #[test]
396 fn test_workbook_passthrough_elements_roundtrip_in_schema_order() {
397 let xml = r#"<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><fileSharing readOnlyRecommended="true" userName="owner" reservationPassword="ABCD"/><workbookPr dateCompatibility="true" refreshAllConnections="true"/><sheets><sheet name="Sheet1" sheetId="1" r:id="rId1"/></sheets><externalReferences><externalReference r:id="rId2"/><externalReference r:id="rId3"/></externalReferences><definedNames/><calcPr calcId="1"/><oleSize ref="A1:C3"/><pivotCaches/></workbook>"#;
398
399 let workbook: WorkbookXml = quick_xml::de::from_str(xml).unwrap();
400 assert_eq!(
401 workbook.file_sharing.as_ref().unwrap().user_name.as_deref(),
402 Some("owner")
403 );
404 assert_eq!(
405 workbook
406 .external_references
407 .as_ref()
408 .unwrap()
409 .references
410 .len(),
411 2
412 );
413 assert_eq!(workbook.ole_size.as_ref().unwrap().reference, "A1:C3");
414 assert_eq!(
415 workbook.workbook_pr.as_ref().unwrap().date_compatibility,
416 Some(true)
417 );
418 assert_eq!(
419 workbook
420 .workbook_pr
421 .as_ref()
422 .unwrap()
423 .refresh_all_connections,
424 Some(true)
425 );
426
427 let serialized = quick_xml::se::to_string(&workbook).unwrap();
428 assert!(serialized.find("fileSharing").unwrap() < serialized.find("workbookPr").unwrap());
429 assert!(
430 serialized.find("externalReferences").unwrap()
431 < serialized.find("definedNames").unwrap()
432 );
433 assert!(serialized.find("calcPr").unwrap() < serialized.find("oleSize").unwrap());
434 let reparsed: WorkbookXml = quick_xml::de::from_str(&serialized).unwrap();
435 assert_eq!(workbook, reparsed);
436 }
437
438 #[test]
439 fn test_workbook_default() {
440 let wb = WorkbookXml::default();
441 assert_eq!(wb.xmlns, namespaces::SPREADSHEET_ML);
442 assert_eq!(wb.xmlns_r, namespaces::RELATIONSHIPS);
443 assert_eq!(wb.sheets.sheets.len(), 1);
444 assert_eq!(wb.sheets.sheets[0].name, "Sheet1");
445 assert_eq!(wb.sheets.sheets[0].sheet_id, 1);
446 assert_eq!(wb.sheets.sheets[0].r_id, "rId1");
447 assert!(wb.sheets.sheets[0].state.is_none());
448 assert!(wb.file_version.is_none());
449 assert!(wb.workbook_pr.is_none());
450 assert!(wb.workbook_protection.is_none());
451 assert!(wb.book_views.is_none());
452 assert!(wb.defined_names.is_none());
453 assert!(wb.calc_pr.is_none());
454 assert!(wb.pivot_caches.is_none());
455 }
456
457 #[test]
458 fn test_workbook_roundtrip() {
459 let wb = WorkbookXml::default();
460 let xml = quick_xml::se::to_string(&wb).unwrap();
461 let parsed: WorkbookXml = quick_xml::de::from_str(&xml).unwrap();
462 assert_eq!(wb.xmlns, parsed.xmlns);
463 assert_eq!(wb.xmlns_r, parsed.xmlns_r);
464 assert_eq!(wb.sheets.sheets.len(), parsed.sheets.sheets.len());
465 assert_eq!(wb.sheets.sheets[0].name, parsed.sheets.sheets[0].name);
466 assert_eq!(
467 wb.sheets.sheets[0].sheet_id,
468 parsed.sheets.sheets[0].sheet_id
469 );
470 assert_eq!(wb.sheets.sheets[0].r_id, parsed.sheets.sheets[0].r_id);
471 }
472
473 #[test]
474 fn test_workbook_serialize_structure() {
475 let wb = WorkbookXml::default();
476 let xml = quick_xml::se::to_string(&wb).unwrap();
477 assert!(xml.contains("<workbook"));
478 assert!(xml.contains("<sheets>"));
479 assert!(xml.contains("<sheet "));
480 assert!(xml.contains("name=\"Sheet1\""));
481 assert!(xml.contains("sheetId=\"1\""));
482 }
483
484 #[test]
485 fn test_workbook_optional_fields_not_serialized() {
486 let wb = WorkbookXml::default();
487 let xml = quick_xml::se::to_string(&wb).unwrap();
488 assert!(!xml.contains("fileVersion"));
489 assert!(!xml.contains("workbookPr"));
490 assert!(!xml.contains("workbookProtection"));
491 assert!(!xml.contains("bookViews"));
492 assert!(!xml.contains("definedNames"));
493 assert!(!xml.contains("calcPr"));
494 assert!(!xml.contains("pivotCaches"));
495 }
496
497 #[test]
498 fn test_workbook_with_all_optional_fields() {
499 let wb = WorkbookXml {
500 xmlns: namespaces::SPREADSHEET_ML.to_string(),
501 xmlns_r: namespaces::RELATIONSHIPS.to_string(),
502 file_version: Some(FileVersion {
503 app_name: Some("xl".to_string()),
504 last_edited: Some("7".to_string()),
505 lowest_edited: Some("7".to_string()),
506 rup_build: Some("27425".to_string()),
507 }),
508 file_sharing: None,
509 workbook_pr: Some(WorkbookPr {
510 date1904: Some(false),
511 date_compatibility: None,
512 filter_privacy: None,
513 default_theme_version: Some(166925),
514 show_objects: None,
515 backup_file: None,
516 code_name: None,
517 check_compatibility: None,
518 auto_compress_pictures: None,
519 refresh_all_connections: None,
520 save_external_link_values: None,
521 update_links: None,
522 hide_pivot_field_list: None,
523 show_pivot_chart_filter: None,
524 allow_refresh_query: None,
525 publish_items: None,
526 show_border_unselected_tables: None,
527 prompted_solutions: None,
528 show_ink_annotation: None,
529 }),
530 workbook_protection: None,
531 book_views: Some(BookViews {
532 workbook_views: vec![WorkbookView {
533 x_window: Some(0),
534 y_window: Some(0),
535 window_width: Some(28800),
536 window_height: Some(12210),
537 active_tab: Some(0),
538 }],
539 }),
540 sheets: Sheets {
541 sheets: vec![SheetEntry {
542 name: "Sheet1".to_string(),
543 sheet_id: 1,
544 state: None,
545 r_id: "rId1".to_string(),
546 }],
547 },
548 external_references: None,
549 defined_names: None,
550 calc_pr: Some(CalcPr {
551 calc_id: Some(191029),
552 calc_mode: None,
553 full_calc_on_load: None,
554 ref_mode: None,
555 iterate: None,
556 iterate_count: None,
557 iterate_delta: None,
558 full_precision: None,
559 calc_completed: None,
560 calc_on_save: None,
561 concurrent_calc: None,
562 concurrent_manual_count: None,
563 force_full_calc: None,
564 }),
565 ole_size: None,
566 pivot_caches: None,
567 };
568
569 let xml = quick_xml::se::to_string(&wb).unwrap();
570 let parsed: WorkbookXml = quick_xml::de::from_str(&xml).unwrap();
571 assert!(parsed.file_version.is_some());
572 assert!(parsed.workbook_pr.is_some());
573 assert!(parsed.book_views.is_some());
574 assert!(parsed.calc_pr.is_some());
575 assert_eq!(
576 parsed.file_version.as_ref().unwrap().app_name,
577 Some("xl".to_string())
578 );
579 assert_eq!(parsed.calc_pr.as_ref().unwrap().calc_id, Some(191029));
580 }
581
582 #[test]
583 fn test_parse_real_excel_workbook() {
584 let xml = r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
585<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
586 <sheets>
587 <sheet name="Sheet1" sheetId="1" r:id="rId1"/>
588 <sheet name="Sheet2" sheetId="2" r:id="rId2"/>
589 </sheets>
590</workbook>"#;
591
592 let parsed: WorkbookXml = quick_xml::de::from_str(xml).unwrap();
593 assert_eq!(parsed.sheets.sheets.len(), 2);
594 assert_eq!(parsed.sheets.sheets[0].name, "Sheet1");
595 assert_eq!(parsed.sheets.sheets[0].r_id, "rId1");
596 assert_eq!(parsed.sheets.sheets[1].name, "Sheet2");
597 assert_eq!(parsed.sheets.sheets[1].r_id, "rId2");
598 }
599
600 #[test]
601 fn test_multiple_sheets() {
602 let wb = WorkbookXml {
603 sheets: Sheets {
604 sheets: vec![
605 SheetEntry {
606 name: "Data".to_string(),
607 sheet_id: 1,
608 state: None,
609 r_id: "rId1".to_string(),
610 },
611 SheetEntry {
612 name: "Summary".to_string(),
613 sheet_id: 2,
614 state: None,
615 r_id: "rId2".to_string(),
616 },
617 SheetEntry {
618 name: "Hidden".to_string(),
619 sheet_id: 3,
620 state: Some("hidden".to_string()),
621 r_id: "rId3".to_string(),
622 },
623 ],
624 },
625 ..WorkbookXml::default()
626 };
627
628 let xml = quick_xml::se::to_string(&wb).unwrap();
629 let parsed: WorkbookXml = quick_xml::de::from_str(&xml).unwrap();
630 assert_eq!(parsed.sheets.sheets.len(), 3);
631 assert_eq!(parsed.sheets.sheets[2].state, Some("hidden".to_string()));
632 }
633
634 #[test]
635 fn test_sheet_entry_state_not_serialized_when_none() {
636 let entry = SheetEntry {
637 name: "Sheet1".to_string(),
638 sheet_id: 1,
639 state: None,
640 r_id: "rId1".to_string(),
641 };
642 let xml = quick_xml::se::to_string(&entry).unwrap();
643 assert!(!xml.contains("state"));
644 }
645
646 #[test]
647 fn test_extended_workbook_pr_roundtrip() {
648 let pr = WorkbookPr {
649 date1904: Some(false),
650 date_compatibility: Some(true),
651 filter_privacy: Some(true),
652 default_theme_version: Some(166925),
653 show_objects: Some("all".to_string()),
654 backup_file: Some(true),
655 code_name: Some("ThisWorkbook".to_string()),
656 check_compatibility: Some(true),
657 auto_compress_pictures: Some(false),
658 refresh_all_connections: Some(true),
659 save_external_link_values: Some(true),
660 update_links: Some("always".to_string()),
661 hide_pivot_field_list: Some(false),
662 show_pivot_chart_filter: Some(true),
663 allow_refresh_query: Some(true),
664 publish_items: Some(false),
665 show_border_unselected_tables: Some(true),
666 prompted_solutions: Some(false),
667 show_ink_annotation: Some(true),
668 };
669 let xml = quick_xml::se::to_string(&pr).unwrap();
670 let parsed: WorkbookPr = quick_xml::de::from_str(&xml).unwrap();
671 assert_eq!(pr, parsed);
672 assert!(xml.contains("showObjects=\"all\""));
673 assert!(xml.contains("backupFile=\"true\""));
674 assert!(xml.contains("codeName=\"ThisWorkbook\""));
675 assert!(xml.contains("checkCompatibility=\"true\""));
676 assert!(xml.contains("autoCompressPictures=\"false\""));
677 assert!(xml.contains("saveExternalLinkValues=\"true\""));
678 assert!(xml.contains("updateLinks=\"always\""));
679 assert!(xml.contains("hidePivotFieldList=\"false\""));
680 assert!(xml.contains("showPivotChartFilter=\"true\""));
681 assert!(xml.contains("allowRefreshQuery=\"true\""));
682 assert!(xml.contains("publishItems=\"false\""));
683 assert!(xml.contains("showBorderUnselectedTables=\"true\""));
684 assert!(xml.contains("promptedSolutions=\"false\""));
685 assert!(xml.contains("showInkAnnotation=\"true\""));
686 }
687
688 #[test]
689 fn test_extended_calc_pr_roundtrip() {
690 let calc = CalcPr {
691 calc_id: Some(191029),
692 calc_mode: Some("auto".to_string()),
693 full_calc_on_load: Some(true),
694 ref_mode: Some("A1".to_string()),
695 iterate: Some(true),
696 iterate_count: Some(100),
697 iterate_delta: Some(0.001),
698 full_precision: Some(true),
699 calc_completed: Some(true),
700 calc_on_save: Some(true),
701 concurrent_calc: Some(true),
702 concurrent_manual_count: Some(4),
703 force_full_calc: Some(false),
704 };
705 let xml = quick_xml::se::to_string(&calc).unwrap();
706 let parsed: CalcPr = quick_xml::de::from_str(&xml).unwrap();
707 assert_eq!(calc, parsed);
708 assert!(xml.contains("refMode=\"A1\""));
709 assert!(xml.contains("iterate=\"true\""));
710 assert!(xml.contains("iterateCount=\"100\""));
711 assert!(xml.contains("iterateDelta=\"0.001\""));
712 assert!(xml.contains("fullPrecision=\"true\""));
713 assert!(xml.contains("calcCompleted=\"true\""));
714 assert!(xml.contains("calcOnSave=\"true\""));
715 assert!(xml.contains("concurrentCalc=\"true\""));
716 assert!(xml.contains("concurrentManualCount=\"4\""));
717 assert!(xml.contains("forceFullCalc=\"false\""));
718 }
719
720 #[test]
721 fn test_workbook_protection_roundtrip() {
722 let prot = WorkbookProtection {
723 workbook_password: Some("ABCD".to_string()),
724 lock_structure: Some(true),
725 lock_windows: Some(false),
726 revisions_password: Some("1234".to_string()),
727 lock_revision: Some(true),
728 };
729 let xml = quick_xml::se::to_string(&prot).unwrap();
730 let parsed: WorkbookProtection = quick_xml::de::from_str(&xml).unwrap();
731 assert_eq!(prot, parsed);
732 assert!(xml.contains("workbookPassword=\"ABCD\""));
733 assert!(xml.contains("lockStructure=\"true\""));
734 assert!(xml.contains("lockWindows=\"false\""));
735 assert!(xml.contains("revisionsPassword=\"1234\""));
736 assert!(xml.contains("lockRevision=\"true\""));
737 }
738
739 #[test]
740 fn test_workbook_protection_optional_fields_skipped() {
741 let prot = WorkbookProtection {
742 workbook_password: None,
743 lock_structure: Some(true),
744 lock_windows: None,
745 revisions_password: None,
746 lock_revision: None,
747 };
748 let xml = quick_xml::se::to_string(&prot).unwrap();
749 assert!(!xml.contains("workbookPassword"));
750 assert!(xml.contains("lockStructure=\"true\""));
751 assert!(!xml.contains("lockWindows"));
752 assert!(!xml.contains("revisionsPassword"));
753 assert!(!xml.contains("lockRevision"));
754 }
755
756 #[test]
757 fn test_workbook_xml_with_protection_roundtrip() {
758 let wb = WorkbookXml {
759 workbook_protection: Some(WorkbookProtection {
760 workbook_password: Some("CC23".to_string()),
761 lock_structure: Some(true),
762 lock_windows: None,
763 revisions_password: None,
764 lock_revision: None,
765 }),
766 ..WorkbookXml::default()
767 };
768 let xml = quick_xml::se::to_string(&wb).unwrap();
769 let parsed: WorkbookXml = quick_xml::de::from_str(&xml).unwrap();
770 assert!(parsed.workbook_protection.is_some());
771 let prot = parsed.workbook_protection.unwrap();
772 assert_eq!(prot.workbook_password, Some("CC23".to_string()));
773 assert_eq!(prot.lock_structure, Some(true));
774 }
775
776 #[test]
777 fn test_workbook_xml_element_order() {
778 let wb = WorkbookXml {
779 workbook_pr: Some(WorkbookPr {
780 date1904: Some(false),
781 date_compatibility: None,
782 filter_privacy: None,
783 default_theme_version: None,
784 show_objects: None,
785 backup_file: None,
786 code_name: None,
787 check_compatibility: None,
788 auto_compress_pictures: None,
789 refresh_all_connections: None,
790 save_external_link_values: None,
791 update_links: None,
792 hide_pivot_field_list: None,
793 show_pivot_chart_filter: None,
794 allow_refresh_query: None,
795 publish_items: None,
796 show_border_unselected_tables: None,
797 prompted_solutions: None,
798 show_ink_annotation: None,
799 }),
800 workbook_protection: Some(WorkbookProtection {
801 workbook_password: None,
802 lock_structure: Some(true),
803 lock_windows: None,
804 revisions_password: None,
805 lock_revision: None,
806 }),
807 book_views: Some(BookViews {
808 workbook_views: vec![WorkbookView {
809 x_window: Some(0),
810 y_window: Some(0),
811 window_width: Some(28800),
812 window_height: Some(12210),
813 active_tab: None,
814 }],
815 }),
816 ..WorkbookXml::default()
817 };
818 let xml = quick_xml::se::to_string(&wb).unwrap();
819 let pr_pos = xml
820 .find("workbookPr")
821 .expect("workbookPr should be present");
822 let prot_pos = xml
823 .find("workbookProtection")
824 .expect("workbookProtection should be present");
825 let bv_pos = xml.find("bookViews").expect("bookViews should be present");
826 assert!(
827 pr_pos < prot_pos,
828 "workbookPr ({pr_pos}) should come before workbookProtection ({prot_pos})"
829 );
830 assert!(
831 prot_pos < bv_pos,
832 "workbookProtection ({prot_pos}) should come before bookViews ({bv_pos})"
833 );
834 }
835}