#[derive(Debug, Clone, PartialEq, Default)]
#[non_exhaustive]
pub struct DocumentProperties {
pub title: Option<String>,
pub subject: Option<String>,
pub creator: Option<String>,
pub keywords: Option<String>,
pub description: Option<String>,
pub last_modified_by: Option<String>,
pub category: Option<String>,
pub content_status: Option<String>,
pub language: Option<String>,
pub identifier: Option<String>,
pub revision: Option<String>,
pub version: Option<String>,
pub created: Option<String>,
pub modified: Option<String>,
pub last_printed: Option<String>,
pub company: Option<String>,
pub manager: Option<String>,
pub custom: Vec<CustomProperty>,
}
impl DocumentProperties {
#[cfg(feature = "write")]
pub(crate) fn has_core(&self) -> bool {
self.core_fields().iter().any(|(_, value)| value.is_some())
}
#[cfg(feature = "write")]
pub(crate) fn core_fields(&self) -> [(&'static str, &Option<String>); 15] {
[
("dc:title", &self.title),
("dc:subject", &self.subject),
("dc:creator", &self.creator),
("cp:keywords", &self.keywords),
("dc:description", &self.description),
("cp:lastModifiedBy", &self.last_modified_by),
("cp:lastPrinted", &self.last_printed),
("dcterms:created", &self.created),
("dcterms:modified", &self.modified),
("cp:category", &self.category),
("cp:contentStatus", &self.content_status),
("dc:language", &self.language),
("dc:identifier", &self.identifier),
("cp:revision", &self.revision),
("cp:version", &self.version),
]
}
pub(crate) fn core_field_mut(&mut self, local: &str) -> Option<&mut Option<String>> {
Some(match local {
"title" => &mut self.title,
"subject" => &mut self.subject,
"creator" => &mut self.creator,
"keywords" => &mut self.keywords,
"description" => &mut self.description,
"lastModifiedBy" => &mut self.last_modified_by,
"lastPrinted" => &mut self.last_printed,
"created" => &mut self.created,
"modified" => &mut self.modified,
"category" => &mut self.category,
"contentStatus" => &mut self.content_status,
"language" => &mut self.language,
"identifier" => &mut self.identifier,
"revision" => &mut self.revision,
"version" => &mut self.version,
_ => return None,
})
}
pub fn set_custom(&mut self, name: impl Into<String>, value: impl Into<PropertyValue>) {
let (name, value) = (name.into(), value.into());
match self.custom.iter_mut().find(|p| same_name(&p.name, &name)) {
Some(existing) => existing.value = value,
None => self.custom.push(CustomProperty { name, value }),
}
}
#[must_use]
pub fn custom(&self, name: &str) -> Option<&PropertyValue> {
self.custom
.iter()
.find(|p| same_name(&p.name, name))
.map(|p| &p.value)
}
}
fn same_name(a: &str, b: &str) -> bool {
a.chars()
.flat_map(char::to_lowercase)
.eq(b.chars().flat_map(char::to_lowercase))
}
#[derive(Debug, Clone, PartialEq)]
pub struct CustomProperty {
pub name: String,
pub value: PropertyValue,
}
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub enum PropertyValue {
Text(String),
Integer(i64),
Number(f64),
Bool(bool),
Date(String),
}
impl From<&str> for PropertyValue {
fn from(text: &str) -> Self {
Self::Text(text.to_owned())
}
}
impl From<String> for PropertyValue {
fn from(text: String) -> Self {
Self::Text(text)
}
}
impl From<i64> for PropertyValue {
fn from(n: i64) -> Self {
Self::Integer(n)
}
}
impl From<f64> for PropertyValue {
fn from(n: f64) -> Self {
Self::Number(n)
}
}
impl From<bool> for PropertyValue {
fn from(b: bool) -> Self {
Self::Bool(b)
}
}