ankit 0.1.0

Complete async Rust client for the AnkiConnect API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

//! Example: Adding notes to Anki.
//!
//! This example demonstrates various ways to add notes, including:
//! - Simple note creation with NoteBuilder
//! - Adding notes with tags
//! - Bulk adding multiple notes
//! - Adding notes with duplicate handling
//!
//! Run with: cargo run --example add_notes

use ankit::{AnkiClient, NoteBuilder};

#[tokio::main]
async fn main() -> ankit::Result<()> {
    let client = AnkiClient::new();

    // First, ensure we have a deck to work with
    let test_deck = "Example Deck";
    let _deck_id = client.decks().create(test_deck).await?;
    println!("Using deck: {}", test_deck);

    // ========== SIMPLE NOTE ==========
    println!("\n--- Adding a simple note ---");

    let note = NoteBuilder::new(test_deck, "Basic")
        .field("Front", "What is the capital of France?")
        .field("Back", "Paris")
        .build();

    match client.notes().add(note).await {
        Ok(id) => println!("Created note with ID: {}", id),
        Err(e) => println!("Note creation failed (might be duplicate): {}", e),
    }

    // ========== NOTE WITH TAGS ==========
    println!("\n--- Adding a note with tags ---");

    let note = NoteBuilder::new(test_deck, "Basic")
        .field("Front", "What is the capital of Japan?")
        .field("Back", "Tokyo")
        .tag("geography")
        .tag("capitals")
        .tags(["asia", "countries"])
        .build();

    match client.notes().add(note).await {
        Ok(id) => println!("Created tagged note with ID: {}", id),
        Err(e) => println!("Note creation failed: {}", e),
    }

    // ========== ALLOWING DUPLICATES ==========
    println!("\n--- Adding a note with duplicate allowed ---");

    let note = NoteBuilder::new(test_deck, "Basic")
        .field("Front", "What is 2 + 2?")
        .field("Back", "4")
        .allow_duplicate(true) // Allow this even if a duplicate exists
        .build();

    match client.notes().add(note).await {
        Ok(id) => println!("Created note (duplicates allowed) with ID: {}", id),
        Err(e) => println!("Note creation failed: {}", e),
    }

    // ========== BULK ADDING NOTES ==========
    println!("\n--- Adding multiple notes at once ---");

    let notes = vec![
        NoteBuilder::new(test_deck, "Basic")
            .field("Front", "What is the capital of Germany?")
            .field("Back", "Berlin")
            .tag("geography")
            .build(),
        NoteBuilder::new(test_deck, "Basic")
            .field("Front", "What is the capital of Italy?")
            .field("Back", "Rome")
            .tag("geography")
            .build(),
        NoteBuilder::new(test_deck, "Basic")
            .field("Front", "What is the capital of Spain?")
            .field("Back", "Madrid")
            .tag("geography")
            .build(),
    ];

    let results = client.notes().add_many(&notes).await?;
    let successful = results.iter().filter(|r| r.is_some()).count();
    let failed = results.iter().filter(|r| r.is_none()).count();
    println!(
        "Bulk add results: {} successful, {} failed (duplicates)",
        successful, failed
    );

    // ========== CHECK BEFORE ADDING ==========
    println!("\n--- Checking if notes can be added ---");

    let notes_to_check = vec![
        NoteBuilder::new(test_deck, "Basic")
            .field("Front", "New unique question")
            .field("Back", "New answer")
            .build(),
        NoteBuilder::new(test_deck, "Basic")
            .field("Front", "What is the capital of France?") // Likely duplicate
            .field("Back", "Paris")
            .build(),
    ];

    let can_add = client.notes().can_add(&notes_to_check).await?;
    for (i, result) in can_add.iter().enumerate() {
        println!(
            "  Note {}: {}",
            i + 1,
            if *result { "can add" } else { "duplicate" }
        );
    }

    // ========== DETAILED DUPLICATE CHECK ==========
    println!("\n--- Detailed duplicate check ---");

    let detailed = client.notes().can_add_detailed(&notes_to_check).await?;
    for (i, result) in detailed.iter().enumerate() {
        if result.can_add {
            println!("  Note {}: can add", i + 1);
        } else {
            println!(
                "  Note {}: {}",
                i + 1,
                result.error.as_deref().unwrap_or("unknown error")
            );
        }
    }

    println!("\nDone! Check Anki to see the new notes in '{}'", test_deck);
    Ok(())
}