pcvolkmer/osc-variant
1
0
Fork 0
mirror of https://github.com/pcvolkmer/osc-variant.git synced 2025-04-19 19:56:50 +00:00
Code Issues

feat: make properties optional

Browse Source
This commit is contained in:
Paul-Christian Volkmer 2025-04-13 21:35:49 +02:00
parent 1d43261ab6
commit db520507ba
1 changed files with 270 additions and 367 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

407
src/model/form.rs
View File

@ -54,25 +54,32 @@ pub struct Form<Type> {
_type: PhantomData<Type>, _type: PhantomData<Type>,
#[serde(rename = "DataCatalogues")] #[serde(rename = "DataCatalogues")]
data_catalogues: DataCatalogues, #[serde(skip_serializing_if = "Option::is_none")]
data_catalogues: Option<DataCatalogues>,
#[serde(rename = "Category")] #[serde(rename = "Category")]
category: String, category: String,
#[serde(rename = "Name")] #[serde(rename = "Name")]
name: String, name: String,
#[serde(rename = "Version")] #[serde(rename = "Version")]
version: String, #[serde(skip_serializing_if = "Option::is_none")]
version: Option<String>,
#[serde(rename = "MenuEntry")] #[serde(rename = "MenuEntry")]
menu_entry: String, #[serde(skip_serializing_if = "Option::is_none")]
menu_entry: Option<String>,
#[serde(rename = "Title")] #[serde(rename = "Title")]
title: String, #[serde(skip_serializing_if = "Option::is_none")]
title: Option<String>,
#[serde(rename = "Description")] #[serde(rename = "Description")]
description: String, #[serde(skip_serializing_if = "Option::is_none")]
description: Option<String>,
#[serde(rename = "Note")] #[serde(rename = "Note")]
note: String, #[serde(skip_serializing_if = "Option::is_none")]
note: Option<String>,
#[serde(rename = "Readonly")] #[serde(rename = "Readonly")]
readonly: bool, readonly: bool,
#[serde(rename = "Active")] #[serde(rename = "Active")]
active: bool, #[serde(skip_serializing_if = "Option::is_none")]
active: Option<bool>,
#[serde(rename = "TudokPosition")] #[serde(rename = "TudokPosition")]
tudok_position: String, tudok_position: String,
#[serde(rename = "Aktenbereich")] #[serde(rename = "Aktenbereich")]
@ -85,9 +92,11 @@ pub struct Form<Type> {
#[serde(skip_serializing_if = "Option::is_none")] #[serde(skip_serializing_if = "Option::is_none")]
hotkey: Option<String>, hotkey: Option<String>,
#[serde(rename = "Summary")] #[serde(rename = "Summary")]
summary: String, #[serde(skip_serializing_if = "Option::is_none")]
summary: Option<String>,
#[serde(rename = "BigSummary")] #[serde(rename = "BigSummary")]
big_summary: String, #[serde(skip_serializing_if = "Option::is_none")]
big_summary: Option<String>,
#[serde(rename = "KalenderSchnipsel")] #[serde(rename = "KalenderSchnipsel")]
#[serde(skip_serializing_if = "Option::is_none")] #[serde(skip_serializing_if = "Option::is_none")]
kalender_schnipsel: Option<String>, kalender_schnipsel: Option<String>,
@ -184,15 +193,20 @@ pub struct Form<Type> {
#[serde(skip_serializing_if = "Option::is_none")] #[serde(skip_serializing_if = "Option::is_none")]
seitenanzahl_sichtbar: Option<bool>, seitenanzahl_sichtbar: Option<bool>,
#[serde(rename = "Entries")] #[serde(rename = "Entries")]
entries: Entries<Entry>, #[serde(skip_serializing_if = "Option::is_none")]
entries: Option<Entries<Entry>>,
#[serde(rename = "PlausibilityRules")] #[serde(rename = "PlausibilityRules")]
plausibility_rules: PlausibilityRules<DataFormEntries>, #[serde(skip_serializing_if = "Option::is_none")]
plausibility_rules: Option<PlausibilityRules<DataFormEntries>>,
#[serde(rename = "Haeufigkeiten")] #[serde(rename = "Haeufigkeiten")]
haeufigkeiten: Haeufigkeiten, #[serde(skip_serializing_if = "Option::is_none")]
haeufigkeiten: Option<Haeufigkeiten>,
#[serde(rename = "Kennzahlen")] #[serde(rename = "Kennzahlen")]
kennzahlen: Kennzahlen, #[serde(skip_serializing_if = "Option::is_none")]
kennzahlen: Option<Kennzahlen>,
#[serde(rename = "Ordner")] #[serde(rename = "Ordner")]
ordner: Ordner, #[serde(skip_serializing_if = "Option::is_none")]
ordner: Option<Ordner>,
#[serde(rename = "MenuCategory")] #[serde(rename = "MenuCategory")]
#[serde(skip_serializing_if = "Option::is_none")] #[serde(skip_serializing_if = "Option::is_none")]
menu_category: Option<MenuCategory>, menu_category: Option<MenuCategory>,
@ -208,7 +222,8 @@ impl<Type: 'static> FormEntryContainer for Form<Type> {
fn apply_profile(&mut self, profile: &Profile) { fn apply_profile(&mut self, profile: &Profile) {
profile.forms.iter().for_each(|profile_form| { profile.forms.iter().for_each(|profile_form| {
if self.name == profile_form.name { if self.name == profile_form.name {
self.entries.entry.iter_mut().for_each(|entry| { if let Some(ref mut entries) = self.entries {
entries.entry.iter_mut().for_each(|entry| {
profile_form profile_form
.form_references .form_references
.iter() .iter()
@ -231,6 +246,7 @@ impl<Type: 'static> FormEntryContainer for Form<Type> {
} }
}); });
} }
}
}); });
} }
} }
@ -261,15 +277,20 @@ impl<Type: 'static> Sortable for Form<Type> {
} }
fn sorted(&mut self) -> &Self { fn sorted(&mut self) -> &Self {
self.data_catalogues.data_catalogue.sort_unstable(); if let Some(ref mut data_catalogues) = self.data_catalogues {
data_catalogues.data_catalogue.sort_unstable();
}
self.entries.entry.sort_unstable_by_key(Entry::sorting_key); if let Some(ref mut entries) = self.entries {
entries.entry.sort_unstable_by_key(Entry::sorting_key);
self.entries.entry.iter_mut().for_each(|item| { entries.entry.iter_mut().for_each(|item| {
item.sorted(); item.sorted();
}); });
}
if let Some(ref mut plausibility_rule) = self.plausibility_rules.plausibility_rule { if let Some(ref mut plausibility_rules) = self.plausibility_rules {
if let Some(ref mut plausibility_rule) = plausibility_rules.plausibility_rule {
plausibility_rule.sort_unstable_by_key(|item| item.bezeichnung.clone()); plausibility_rule.sort_unstable_by_key(|item| item.bezeichnung.clone());
for item in plausibility_rule { for item in plausibility_rule {
@ -278,6 +299,8 @@ impl<Type: 'static> Sortable for Form<Type> {
} }
} }
} }
}
self self
} }
} }
@ -315,7 +338,8 @@ where
Self: Listable + 'static, Self: Listable + 'static,
{ {
fn requires_form_reference(&self, name: &str) -> bool { fn requires_form_reference(&self, name: &str) -> bool {
self.entries if let Some(ref entries) = self.entries {
entries
.entry .entry
.iter() .iter()
.map(|item| { .map(|item| {
@ -328,10 +352,14 @@ where
.filter(|&it| it) .filter(|&it| it)
.last() .last()
.unwrap_or_default() .unwrap_or_default()
} else {
false
}
} }
fn requires_subform(&self, name: &str) -> bool { fn requires_subform(&self, name: &str) -> bool {
self.entries if let Some(ref entries) = self.entries {
entries
.entry .entry
.iter() .iter()
.map(|item| { .map(|item| {
@ -344,11 +372,14 @@ where
.filter(|&it| it) .filter(|&it| it)
.last() .last()
.unwrap_or_default() .unwrap_or_default()
} else {
false
}
} }
fn get_required_entries<'a>(&'a self, all: &'a OnkostarEditor) -> Vec<Requirement<'a>> { fn get_required_entries<'a>(&'a self, all: &'a OnkostarEditor) -> Vec<Requirement<'a>> {
let mut result = self let mut result = match self.data_catalogues {
.data_catalogues Some(ref data_catalogues) => data_catalogues
.data_catalogue .data_catalogue
.iter() .iter()
.collect::<HashSet<_>>() .collect::<HashSet<_>>()
@ -357,11 +388,14 @@ where
Some(contained) => Requirement::DataCatalogue(contained), Some(contained) => Requirement::DataCatalogue(contained),
None => Requirement::ExternalDataCatalogue(entry.to_string()), None => Requirement::ExternalDataCatalogue(entry.to_string()),
}) })
.collect::<Vec<_>>(); .collect::<Vec<_>>(),
None => vec![],
};
result.sort_unstable_by_key(Requirement::sorting_key); result.sort_unstable_by_key(Requirement::sorting_key);
let referenced_forms = &mut self if let Some(ref entries) = self.entries {
.entries let referenced_forms = &mut entries
.entry .entry
.iter() .iter()
.filter(|&entry| entry.get_type() == "formReference") .filter(|&entry| entry.get_type() == "formReference")
@ -382,8 +416,7 @@ where
referenced_forms.sort_unstable_by_key(Requirement::sorting_key); referenced_forms.sort_unstable_by_key(Requirement::sorting_key);
result.append(referenced_forms); result.append(referenced_forms);
let sub_forms = &mut self let sub_forms = &mut entries
.entries
.entry .entry
.iter() .iter()
.filter(|&entry| entry.get_type() == "subform") .filter(|&entry| entry.get_type() == "subform")
@ -403,6 +436,7 @@ where
.collect::<Vec<_>>(); .collect::<Vec<_>>();
sub_forms.sort_unstable_by_key(Requirement::sorting_key); sub_forms.sort_unstable_by_key(Requirement::sorting_key);
result.append(sub_forms); result.append(sub_forms);
}
result result
} }
@ -410,19 +444,26 @@ where
impl<Type: 'static> FolderContent for Form<Type> { impl<Type: 'static> FolderContent for Form<Type> {
fn get_library_folder(&self) -> String { fn get_library_folder(&self) -> String {
self.ordner.bibliothek.name.to_string() match &self.ordner {
Some(ordner) => ordner.bibliothek.name.to_string(),
None => String::new(),
}
} }
} }
impl<Type> Form<Type> { impl<Type> Form<Type> {
fn common_check(&self) -> Vec<CheckNotice> { fn common_check(&self) -> Vec<CheckNotice> {
let missing_forms = self let missing_forms = match self.entries {
.entries Some(ref entries) => entries
.entry .entry
.iter() .iter()
.filter(|entry| entry.type_ == "formReference" && entry.referenced_data_form.is_none()) .filter(|entry| {
entry.type_ == "formReference" && entry.referenced_data_form.is_none()
})
.map(|entry| format!("'{}'", entry.get_name())) .map(|entry| format!("'{}'", entry.get_name()))
.collect::<Vec<_>>(); .collect::<Vec<_>>(),
None => vec![],
};
let mut result = vec![]; let mut result = vec![];
@ -445,8 +486,9 @@ impl<Type> Form<Type> {
impl Checkable for Form<DataFormType> { impl Checkable for Form<DataFormType> {
fn check(&self) -> Vec<CheckNotice> { fn check(&self) -> Vec<CheckNotice> {
let mut result = if self let mut result = match self.entries {
.entries Some(ref entries) => {
if entries
.entry .entry
.iter() .iter()
.filter(|entry| entry.procedure_date_status != "none") .filter(|entry| entry.procedure_date_status != "none")
@ -464,6 +506,9 @@ impl Checkable for Form<DataFormType> {
}] }]
} else { } else {
vec![] vec![]
}
}
None => vec![],
}; };
result.append(&mut self.common_check()); result.append(&mut self.common_check());
@ -516,7 +561,7 @@ mod tests {
use std::str::FromStr; use std::str::FromStr;
use crate::model::onkostar_editor::OnkostarEditor; use crate::model::onkostar_editor::OnkostarEditor;
use crate::model::{Filter, RefEntries, Script}; use crate::model::Script;
use crate::profile::Profile; use crate::profile::Profile;
#[test] #[test]
@ -537,25 +582,14 @@ mod tests {
assert!(profile.is_ok()); assert!(profile.is_ok());
let profile = profile.unwrap(); let profile = profile.unwrap();
assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[2].name,
"Auswahl"
);
assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[2].default_value,
""
);
onkostar_editor.apply_profile(&profile); onkostar_editor.apply_profile(&profile);
assert_eq!( let Some(actual) = &onkostar_editor.editor.data_form[0].entries else {
onkostar_editor.editor.data_form[0].entries.entry[2].name, panic!()
"Auswahl" };
);
assert_eq!( assert_eq!(actual.entry[2].name, "Auswahl");
onkostar_editor.editor.data_form[0].entries.entry[2].default_value, assert_eq!(actual.entry[2].default_value, "B");
"B"
);
} }
#[test] #[test]
@ -573,25 +607,14 @@ mod tests {
assert!(profile.is_ok()); assert!(profile.is_ok());
let profile = profile.unwrap(); let profile = profile.unwrap();
assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[2].name,
"Auswahl"
);
assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[2].default_value,
""
);
onkostar_editor.apply_profile(&profile); onkostar_editor.apply_profile(&profile);
assert_eq!( let Some(actual) = &onkostar_editor.editor.data_form[0].entries else {
onkostar_editor.editor.data_form[0].entries.entry[2].name, panic!()
"Auswahl" };
);
assert_eq!( assert_eq!(actual.entry[2].name, "Auswahl");
onkostar_editor.editor.data_form[0].entries.entry[2].default_value, assert_eq!(actual.entry[2].default_value, "");
""
);
} }
#[test] #[test]
@ -664,15 +687,15 @@ mod tests {
assert!(profile.is_ok()); assert!(profile.is_ok());
let profile = profile.unwrap(); let profile = profile.unwrap();
assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[2].scripts,
None
);
onkostar_editor.apply_profile(&profile); onkostar_editor.apply_profile(&profile);
let actual = match &onkostar_editor.editor.data_form[0].entries {
Some(entries) => entries,
None => panic!(),
};
assert_eq!( assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[2].scripts, actual.entry[2].scripts,
Some(Script { Some(Script {
code: "// Example code&#10;console.log(42);".into(), code: "// Example code&#10;console.log(42);".into(),
valid: true valid: true
@ -700,15 +723,15 @@ mod tests {
assert!(profile.is_ok()); assert!(profile.is_ok());
let profile = profile.unwrap(); let profile = profile.unwrap();
assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[2].scripts,
None
);
onkostar_editor.apply_profile(&profile); onkostar_editor.apply_profile(&profile);
let actual = match &onkostar_editor.editor.data_form[0].entries {
Some(entries) => entries,
None => panic!(),
};
assert_eq!( assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[2].scripts, actual.entry[2].scripts,
Some(Script { Some(Script {
code: "// Example code&#10;console.log(42);".into(), code: "// Example code&#10;console.log(42);".into(),
valid: true valid: true
@ -737,51 +760,20 @@ mod tests {
assert!(profile.is_ok()); assert!(profile.is_ok());
let profile = profile.unwrap(); let profile = profile.unwrap();
assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[0].filter,
None
);
assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[1].filter,
None
);
assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[2].filter,
Some(Filter {
condition: "getGlobalSetting('mehrere_mtb_in_mtbepisode') = 'true'".into(),
valid: true,
ref_entries: Some(RefEntries { ref_entry: None })
})
);
assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[3].filter,
None
);
onkostar_editor.apply_profile(&profile); onkostar_editor.apply_profile(&profile);
assert_eq!( let actual = match &onkostar_editor.editor.data_form[0].entries {
onkostar_editor.editor.data_form[0].entries.entry[0].filter, Some(entries) => entries,
None None => panic!(),
); };
assert_eq!( assert_eq!(actual.entry[0].filter, None);
onkostar_editor.editor.data_form[0].entries.entry[1].filter,
None
);
assert_eq!( assert_eq!(actual.entry[1].filter, None);
onkostar_editor.editor.data_form[0].entries.entry[2].filter,
None
);
assert_eq!( assert_eq!(actual.entry[2].filter, None);
onkostar_editor.editor.data_form[0].entries.entry[3].filter,
None assert_eq!(actual.entry[3].filter, None);
);
} }
#[test] #[test]
@ -805,51 +797,20 @@ mod tests {
assert!(profile.is_ok()); assert!(profile.is_ok());
let profile = profile.unwrap(); let profile = profile.unwrap();
assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[0].filter,
None
);
assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[1].filter,
None
);
assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[2].filter,
Some(Filter {
condition: "getGlobalSetting('mehrere_mtb_in_mtbepisode') = 'true'".into(),
valid: true,
ref_entries: Some(RefEntries { ref_entry: None })
})
);
assert_eq!(
onkostar_editor.editor.data_form[0].entries.entry[3].filter,
None
);
onkostar_editor.apply_profile(&profile); onkostar_editor.apply_profile(&profile);
assert_eq!( let actual = match &onkostar_editor.editor.data_form[0].entries {
onkostar_editor.editor.data_form[0].entries.entry[0].filter, Some(entries) => entries,
None None => panic!(),
); };
assert_eq!( assert_eq!(actual.entry[0].filter, None);
onkostar_editor.editor.data_form[0].entries.entry[1].filter,
None
);
assert_eq!( assert_eq!(actual.entry[1].filter, None);
onkostar_editor.editor.data_form[0].entries.entry[2].filter,
None
);
assert_eq!( assert_eq!(actual.entry[2].filter, None);
onkostar_editor.editor.data_form[0].entries.entry[3].filter,
None assert_eq!(actual.entry[3].filter, None);
);
} }
#[test] #[test]
@ -870,25 +831,14 @@ mod tests {
assert!(profile.is_ok()); assert!(profile.is_ok());
let profile = profile.unwrap(); let profile = profile.unwrap();
assert_eq!(
onkostar_editor.editor.unterformular[0].entries.entry[1].name,
"Termin"
);
assert_eq!(
onkostar_editor.editor.unterformular[0].entries.entry[1].default_value,
""
);
onkostar_editor.apply_profile(&profile); onkostar_editor.apply_profile(&profile);
assert_eq!( let Some(actual) = &onkostar_editor.editor.unterformular[0].entries else {
onkostar_editor.editor.unterformular[0].entries.entry[1].name, panic!()
"Termin" };
);
assert_eq!( assert_eq!(actual.entry[1].name, "Termin");
onkostar_editor.editor.unterformular[0].entries.entry[1].default_value, assert_eq!(actual.entry[1].default_value, "2024-03-18");
"2024-03-18"
);
} }
#[test] #[test]
@ -906,25 +856,14 @@ mod tests {
assert!(profile.is_ok()); assert!(profile.is_ok());
let profile = profile.unwrap(); let profile = profile.unwrap();
assert_eq!(
onkostar_editor.editor.unterformular[0].entries.entry[1].name,
"Termin"
);
assert_eq!(
onkostar_editor.editor.unterformular[0].entries.entry[1].default_value,
""
);
onkostar_editor.apply_profile(&profile); onkostar_editor.apply_profile(&profile);
assert_eq!( let Some(actual) = &onkostar_editor.editor.unterformular[0].entries else {
onkostar_editor.editor.unterformular[0].entries.entry[1].name, panic!()
"Termin" };
);
assert_eq!( assert_eq!(actual.entry[1].name, "Termin");
onkostar_editor.editor.unterformular[0].entries.entry[1].default_value, assert_eq!(actual.entry[1].default_value, "");
""
);
} }
#[test] #[test]
@ -969,15 +908,14 @@ mod tests {
assert!(profile.is_ok()); assert!(profile.is_ok());
let profile = profile.unwrap(); let profile = profile.unwrap();
assert_eq!(
onkostar_editor.editor.unterformular[0].entries.entry[1].scripts,
None
);
onkostar_editor.apply_profile(&profile); onkostar_editor.apply_profile(&profile);
let Some(actual) = &onkostar_editor.editor.unterformular[0].entries else {
panic!()
};
assert_eq!( assert_eq!(
onkostar_editor.editor.unterformular[0].entries.entry[1].scripts, actual.entry[1].scripts,
Some(Script { Some(Script {
code: "// Example code&#10;console.log(42);".into(), code: "// Example code&#10;console.log(42);".into(),
valid: true valid: true
@ -1005,15 +943,14 @@ mod tests {
assert!(profile.is_ok()); assert!(profile.is_ok());
let profile = profile.unwrap(); let profile = profile.unwrap();
assert_eq!(
onkostar_editor.editor.unterformular[0].entries.entry[1].scripts,
None
);
onkostar_editor.apply_profile(&profile); onkostar_editor.apply_profile(&profile);
let Some(actual) = &onkostar_editor.editor.unterformular[0].entries else {
panic!()
};
assert_eq!( assert_eq!(
onkostar_editor.editor.unterformular[0].entries.entry[1].scripts, actual.entry[1].scripts,
Some(Script { Some(Script {
code: "// Example code&#10;console.log(42);".into(), code: "// Example code&#10;console.log(42);".into(),
valid: true valid: true
@ -1042,31 +979,14 @@ mod tests {
assert!(profile.is_ok()); assert!(profile.is_ok());
let profile = profile.unwrap(); let profile = profile.unwrap();
assert_eq!(
onkostar_editor.editor.unterformular[0].entries.entry[0].filter,
None
);
assert_eq!(
onkostar_editor.editor.unterformular[0].entries.entry[1].filter,
Some(Filter {
condition: "getGlobalSetting('mehrere_mtb_in_mtbepisode') = 'true'".into(),
valid: true,
ref_entries: Some(RefEntries { ref_entry: None })
})
);
onkostar_editor.apply_profile(&profile); onkostar_editor.apply_profile(&profile);
assert_eq!( let Some(actual) = &onkostar_editor.editor.unterformular[0].entries else {
onkostar_editor.editor.unterformular[0].entries.entry[0].filter, panic!()
None };
);
assert_eq!( assert_eq!(actual.entry[0].filter, None);
onkostar_editor.editor.unterformular[0].entries.entry[1].filter, assert_eq!(actual.entry[1].filter, None);
None
);
} }
#[test] #[test]
@ -1090,30 +1010,13 @@ mod tests {
assert!(profile.is_ok()); assert!(profile.is_ok());
let profile = profile.unwrap(); let profile = profile.unwrap();
assert_eq!(
onkostar_editor.editor.unterformular[0].entries.entry[0].filter,
None
);
assert_eq!(
onkostar_editor.editor.unterformular[0].entries.entry[1].filter,
Some(Filter {
condition: "getGlobalSetting('mehrere_mtb_in_mtbepisode') = 'true'".into(),
valid: true,
ref_entries: Some(RefEntries { ref_entry: None })
})
);
onkostar_editor.apply_profile(&profile); onkostar_editor.apply_profile(&profile);
assert_eq!( let Some(actual) = &onkostar_editor.editor.unterformular[0].entries else {
onkostar_editor.editor.unterformular[0].entries.entry[0].filter, panic!()
None };
);
assert_eq!( assert_eq!(actual.entry[0].filter, None);
onkostar_editor.editor.unterformular[0].entries.entry[1].filter, assert_eq!(actual.entry[1].filter, None);
None
);
} }
} }