146 lines
4.2 KiB
Rust
146 lines
4.2 KiB
Rust
use serde::{Deserialize, Serialize};
|
|
|
|
use super::key_encryption::KeyEncryption;
|
|
#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
|
|
|
pub struct Number {
|
|
pub fixed_state: bool,
|
|
pub number: i32,
|
|
pub number_unit: String,
|
|
}
|
|
|
|
impl Number {
|
|
// Constructor for Number struct
|
|
pub fn new(fixed_state: bool, number: i32, number_unit: String) -> Self {
|
|
Number {
|
|
fixed_state,
|
|
number,
|
|
number_unit,
|
|
}
|
|
}
|
|
pub fn display_info(&self) {
|
|
println!("Number:");
|
|
println!("Fixed State: {}", self.fixed_state);
|
|
println!("Number: {}", self.number);
|
|
println!("Number Unit: {}", self.number_unit);
|
|
}
|
|
|
|
// Additional methods for Number can be added here.
|
|
}
|
|
|
|
// Struct for representing an amount with various attributes.
|
|
#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
|
|
|
pub struct Amount {
|
|
pub timestamp: u64,
|
|
pub change_source_list: Vec<String>,
|
|
pub amount_cent: i64,
|
|
pub amount_unit: String,
|
|
pub amount_unit_ref: String, // This can be a reference to an external unit system.
|
|
}
|
|
|
|
impl Amount {
|
|
// Constructor for Amount struct
|
|
pub fn new(
|
|
timestamp: u64,
|
|
change_source_list: Vec<String>,
|
|
amount_cent: i64,
|
|
amount_unit: String,
|
|
amount_unit_ref: String,
|
|
) -> Self {
|
|
Amount {
|
|
timestamp,
|
|
change_source_list,
|
|
amount_cent,
|
|
amount_unit,
|
|
amount_unit_ref,
|
|
}
|
|
}
|
|
pub fn display(&self) -> String {
|
|
format!(
|
|
"Amount: {} {} {} {} {}",
|
|
self.timestamp,
|
|
self.change_source_list.join(","),
|
|
self.amount_cent,
|
|
self.amount_unit,
|
|
self.amount_unit_ref
|
|
)
|
|
}
|
|
pub fn display_info(&self) {
|
|
println!("Amount:");
|
|
println!("Timestamp: {}", self.timestamp);
|
|
println!("Change Source List: {:?}", self.change_source_list);
|
|
println!("Amount cent: {}", self.amount_cent);
|
|
println!("Amount Unit: {}", self.amount_unit);
|
|
println!("Amount Unit Reference: {}", self.amount_unit_ref);
|
|
}
|
|
// Additional methods for Amount can be added here.
|
|
}
|
|
|
|
#[derive(Debug, Serialize, Deserialize, Default, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
|
|
|
|
pub struct MetaData {
|
|
pub tag_list: Vec<String>,
|
|
pub zone_list: Vec<String>,
|
|
pub label_list: Vec<String>,
|
|
pub ref_list: Vec<String>,
|
|
pub data_list: Vec<String>,
|
|
pub amount: Amount,
|
|
pub number: Number,
|
|
pub render_template_list: Vec<String>,
|
|
pub legal_text_list: Vec<String>,
|
|
pub key_list: Vec<KeyEncryption>,
|
|
}
|
|
|
|
impl MetaData {
|
|
pub fn new(
|
|
tag_list: Vec<String>,
|
|
zone_list: Vec<String>,
|
|
label_list: Vec<String>,
|
|
ref_list: Vec<String>,
|
|
data_list: Vec<String>,
|
|
amount: Amount,
|
|
number: Number,
|
|
render_template_list: Vec<String>,
|
|
legal_text_list: Vec<String>,
|
|
key_list: Vec<KeyEncryption>,
|
|
) -> Self {
|
|
MetaData {
|
|
tag_list,
|
|
zone_list,
|
|
label_list,
|
|
ref_list,
|
|
data_list,
|
|
amount,
|
|
number,
|
|
render_template_list,
|
|
legal_text_list,
|
|
key_list,
|
|
}
|
|
}
|
|
pub fn display_info(&self) {
|
|
println!("MetaData:");
|
|
println!("Tag List: {:?}", self.tag_list);
|
|
println!("Zone List: {:?}", self.zone_list);
|
|
println!("Label List: {:?}", self.label_list);
|
|
println!("Ref List: {:?}", self.ref_list);
|
|
println!("Data List: {:?}", self.data_list);
|
|
|
|
println!("Amount:");
|
|
self.amount.display_info(); // Assuming Amount has a display_info method
|
|
|
|
println!("Number:");
|
|
self.number.display_info(); // Assuming Number has a display_info method
|
|
|
|
println!("Render Template List: {:?}", self.render_template_list);
|
|
println!("Legal Text List: {:?}", self.legal_text_list);
|
|
|
|
println!("Key List:");
|
|
for key in &self.key_list {
|
|
key.display_info(); // Assuming KeyEncryption has a display_info method
|
|
}
|
|
}
|
|
|
|
// Methods for manipulating MetaData can be added here.
|
|
}
|