use std::collections::{HashMap, HashSet};
use std::path::Path;
use ankit::AnkiClient;
use crate::error::{Error, Result};
use crate::schema::{DeckDef, DeckDefinition, ModelDef, NoteDef, PackageInfo, TemplateDef};
pub struct DeckExporter<'a> {
client: &'a AnkiClient,
}
impl<'a> DeckExporter<'a> {
pub fn new(client: &'a AnkiClient) -> Self {
Self { client }
}
pub async fn export_deck(&self, deck_name: &str) -> Result<DeckDefinition> {
let query = format!("deck:\"{}\"", deck_name);
let note_ids = self.client.notes().find(&query).await?;
if note_ids.is_empty() {
return Ok(DeckDefinition {
package: PackageInfo {
name: deck_name.to_string(),
version: "1.0.0".to_string(),
author: None,
description: None,
},
models: Vec::new(),
decks: vec![DeckDef {
name: deck_name.to_string(),
description: None,
id: None,
}],
notes: Vec::new(),
media: Vec::new(),
});
}
let note_infos = self.client.notes().info(¬e_ids).await?;
let model_names: HashSet<String> =
note_infos.iter().map(|n| n.model_name.clone()).collect();
let mut models = Vec::new();
for model_name in &model_names {
let model_def = self.fetch_model(model_name).await?;
models.push(model_def);
}
let notes: Vec<NoteDef> = note_infos
.iter()
.map(|note| {
let fields: HashMap<String, String> = note
.fields
.iter()
.map(|(name, field)| (name.clone(), field.value.clone()))
.collect();
NoteDef {
deck: deck_name.to_string(),
model: note.model_name.clone(),
fields,
tags: note.tags.clone(),
guid: None,
note_id: Some(note.note_id),
}
})
.collect();
Ok(DeckDefinition {
package: PackageInfo {
name: deck_name.to_string(),
version: "1.0.0".to_string(),
author: None,
description: None,
},
models,
decks: vec![DeckDef {
name: deck_name.to_string(),
description: None,
id: None,
}],
notes,
media: Vec::new(),
})
}
pub async fn export_decks(
&self,
deck_names: &[&str],
package_name: &str,
) -> Result<DeckDefinition> {
let mut all_notes = Vec::new();
let mut model_names: HashSet<String> = HashSet::new();
let mut decks = Vec::new();
for deck_name in deck_names {
let query = format!("deck:\"{}\"", deck_name);
let note_ids = self.client.notes().find(&query).await?;
decks.push(DeckDef {
name: deck_name.to_string(),
description: None,
id: None,
});
if note_ids.is_empty() {
continue;
}
let note_infos = self.client.notes().info(¬e_ids).await?;
for note in ¬e_infos {
model_names.insert(note.model_name.clone());
}
for note in note_infos {
let fields: HashMap<String, String> = note
.fields
.iter()
.map(|(name, field)| (name.clone(), field.value.clone()))
.collect();
all_notes.push(NoteDef {
deck: deck_name.to_string(),
model: note.model_name.clone(),
fields,
tags: note.tags,
guid: None,
note_id: Some(note.note_id),
});
}
}
let mut models = Vec::new();
for model_name in &model_names {
let model_def = self.fetch_model(model_name).await?;
models.push(model_def);
}
Ok(DeckDefinition {
package: PackageInfo {
name: package_name.to_string(),
version: "1.0.0".to_string(),
author: None,
description: None,
},
models,
decks,
notes: all_notes,
media: Vec::new(),
})
}
async fn fetch_model(&self, model_name: &str) -> Result<ModelDef> {
let fields = self.client.models().field_names(model_name).await?;
let templates_map = self.client.models().templates(model_name).await?;
let templates: Vec<TemplateDef> = templates_map
.into_iter()
.map(|(name, template)| TemplateDef {
name,
front: template.front,
back: template.back,
})
.collect();
let styling = self.client.models().styling(model_name).await?;
let css = if styling.css.is_empty() {
None
} else {
Some(styling.css)
};
Ok(ModelDef {
name: model_name.to_string(),
fields,
templates,
css,
sort_field: None,
id: None,
markdown_fields: vec![],
model_type: None,
})
}
}
impl DeckDefinition {
pub fn write_toml(&self, path: impl AsRef<Path>) -> Result<()> {
let content = self.to_toml()?;
std::fs::write(path, content)?;
Ok(())
}
pub fn to_toml(&self) -> Result<String> {
toml::to_string_pretty(self).map_err(|e| Error::TomlSerialize(e.to_string()))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_to_toml_roundtrip() {
let toml_input = r#"
[package]
name = "Test Deck"
version = "1.0.0"
[[models]]
name = "Basic"
fields = ["Front", "Back"]
[[models.templates]]
name = "Card 1"
front = "{{Front}}"
back = "{{Back}}"
[[decks]]
name = "Test Deck"
[[notes]]
deck = "Test Deck"
model = "Basic"
tags = ["test"]
[notes.fields]
Front = "Question"
Back = "Answer"
"#;
let definition = DeckDefinition::parse(toml_input).unwrap();
let toml_output = definition.to_toml().unwrap();
let definition2 = DeckDefinition::parse(&toml_output).unwrap();
assert_eq!(definition.package.name, definition2.package.name);
assert_eq!(definition.models.len(), definition2.models.len());
assert_eq!(definition.notes.len(), definition2.notes.len());
}
#[test]
fn test_note_id_serialization() {
let toml_input = r#"
[package]
name = "Test"
version = "1.0.0"
[[models]]
name = "Basic"
fields = ["Front", "Back"]
[[models.templates]]
name = "Card 1"
front = "{{Front}}"
back = "{{Back}}"
[[decks]]
name = "Test"
[[notes]]
deck = "Test"
model = "Basic"
note_id = 1234567890
[notes.fields]
Front = "Q"
Back = "A"
"#;
let definition = DeckDefinition::parse(toml_input).unwrap();
assert_eq!(definition.notes[0].note_id, Some(1234567890));
let toml_output = definition.to_toml().unwrap();
assert!(
toml_output.contains("note_id = 1234567890"),
"note_id should be in output: {}",
toml_output
);
let definition2 = DeckDefinition::parse(&toml_output).unwrap();
assert_eq!(definition2.notes[0].note_id, Some(1234567890));
}
#[test]
fn test_note_id_omitted_when_none() {
let toml_input = r#"
[package]
name = "Test"
version = "1.0.0"
[[models]]
name = "Basic"
fields = ["Front", "Back"]
[[models.templates]]
name = "Card 1"
front = "{{Front}}"
back = "{{Back}}"
[[decks]]
name = "Test"
[[notes]]
deck = "Test"
model = "Basic"
[notes.fields]
Front = "Q"
Back = "A"
"#;
let definition = DeckDefinition::parse(toml_input).unwrap();
assert_eq!(definition.notes[0].note_id, None);
let toml_output = definition.to_toml().unwrap();
assert!(
!toml_output.contains("note_id"),
"note_id should be omitted when None: {}",
toml_output
);
}
}