mirror of
https://github.com/ankitects/anki.git
synced 2025-09-23 08:22:24 -04:00
278 lines
8.6 KiB
Rust
278 lines
8.6 KiB
Rust
// Copyright: Ankitects Pty Ltd and contributors
|
|
// License: GNU AGPL, version 3 or later; http://www.gnu.org/licenses/agpl.html
|
|
|
|
use askama::Template;
|
|
use chrono::prelude::*;
|
|
|
|
use crate::{
|
|
card::CardQueue,
|
|
i18n::I18n,
|
|
prelude::*,
|
|
revlog::{RevlogEntry, RevlogReviewKind},
|
|
scheduler::timespan::time_span,
|
|
};
|
|
|
|
struct CardStats {
|
|
added: TimestampSecs,
|
|
first_review: Option<TimestampSecs>,
|
|
latest_review: Option<TimestampSecs>,
|
|
due: Due,
|
|
interval_secs: u32,
|
|
ease: u32,
|
|
reviews: u32,
|
|
lapses: u32,
|
|
average_secs: f32,
|
|
total_secs: f32,
|
|
card_type: String,
|
|
notetype: String,
|
|
deck: String,
|
|
nid: NoteId,
|
|
cid: CardId,
|
|
revlog: Vec<RevlogEntry>,
|
|
}
|
|
|
|
#[derive(Template)]
|
|
#[template(path = "../src/stats/card_stats.html")]
|
|
struct CardStatsTemplate {
|
|
stats: Vec<(String, String)>,
|
|
revlog: Vec<RevlogText>,
|
|
revlog_titles: RevlogText,
|
|
}
|
|
|
|
enum Due {
|
|
Time(TimestampSecs),
|
|
Position(i32),
|
|
Unknown,
|
|
}
|
|
|
|
struct RevlogText {
|
|
time: String,
|
|
kind: String,
|
|
kind_class: String,
|
|
rating: String,
|
|
rating_class: String,
|
|
interval: String,
|
|
ease: String,
|
|
taken_secs: String,
|
|
}
|
|
|
|
impl Collection {
|
|
pub fn card_stats(&mut self, cid: CardId) -> Result<String> {
|
|
let stats = self.gather_card_stats(cid)?;
|
|
Ok(self.card_stats_to_string(stats))
|
|
}
|
|
|
|
fn gather_card_stats(&mut self, cid: CardId) -> Result<CardStats> {
|
|
let card = self.storage.get_card(cid)?.ok_or(AnkiError::NotFound)?;
|
|
let note = self
|
|
.storage
|
|
.get_note(card.note_id)?
|
|
.ok_or(AnkiError::NotFound)?;
|
|
let nt = self
|
|
.get_notetype(note.notetype_id)?
|
|
.ok_or(AnkiError::NotFound)?;
|
|
let deck = self
|
|
.storage
|
|
.get_deck(card.deck_id)?
|
|
.ok_or(AnkiError::NotFound)?;
|
|
|
|
let revlog = self.storage.get_revlog_entries_for_card(card.id)?;
|
|
let average_secs;
|
|
let total_secs;
|
|
let normal_answer_count = revlog.iter().filter(|r| r.button_chosen > 0).count();
|
|
if normal_answer_count == 0 {
|
|
average_secs = 0.0;
|
|
total_secs = 0.0;
|
|
} else {
|
|
total_secs = revlog
|
|
.iter()
|
|
.map(|e| (e.taken_millis as f32) / 1000.0)
|
|
.sum();
|
|
average_secs = total_secs / normal_answer_count as f32;
|
|
}
|
|
|
|
let due = if card.original_due != 0 {
|
|
card.original_due
|
|
} else {
|
|
card.due
|
|
};
|
|
let due = match card.queue {
|
|
CardQueue::New => Due::Position(due),
|
|
CardQueue::Learn => Due::Time(TimestampSecs::now()),
|
|
CardQueue::Review | CardQueue::DayLearn => Due::Time({
|
|
let days_remaining = due - (self.timing_today()?.days_elapsed as i32);
|
|
let mut due = TimestampSecs::now();
|
|
due.0 += (days_remaining as i64) * 86_400;
|
|
due
|
|
}),
|
|
_ => Due::Unknown,
|
|
};
|
|
|
|
Ok(CardStats {
|
|
added: card.id.as_secs(),
|
|
first_review: revlog.first().map(|e| e.id.as_secs()),
|
|
latest_review: revlog.last().map(|e| e.id.as_secs()),
|
|
due,
|
|
interval_secs: card.interval * 86_400,
|
|
ease: (card.ease_factor as u32) / 10,
|
|
reviews: card.reps,
|
|
lapses: card.lapses,
|
|
average_secs,
|
|
total_secs,
|
|
card_type: nt.get_template(card.template_idx)?.name.clone(),
|
|
notetype: nt.name.clone(),
|
|
deck: deck.human_name(),
|
|
nid: card.note_id,
|
|
cid: card.id,
|
|
revlog: revlog.into_iter().map(Into::into).collect(),
|
|
})
|
|
}
|
|
|
|
fn card_stats_to_string(&mut self, cs: CardStats) -> String {
|
|
let tr = &self.tr;
|
|
|
|
let mut stats = vec![(tr.card_stats_added().into(), cs.added.date_string())];
|
|
if let Some(first) = cs.first_review {
|
|
stats.push((tr.card_stats_first_review().into(), first.date_string()))
|
|
}
|
|
if let Some(last) = cs.latest_review {
|
|
stats.push((tr.card_stats_latest_review().into(), last.date_string()))
|
|
}
|
|
|
|
match cs.due {
|
|
Due::Time(secs) => {
|
|
stats.push((tr.statistics_due_date().into(), secs.date_string()));
|
|
}
|
|
Due::Position(pos) => {
|
|
stats.push((tr.card_stats_new_card_position().into(), pos.to_string()));
|
|
}
|
|
Due::Unknown => {}
|
|
};
|
|
|
|
if cs.interval_secs > 0 {
|
|
stats.push((
|
|
tr.card_stats_interval().into(),
|
|
time_span(cs.interval_secs as f32, tr, true),
|
|
));
|
|
}
|
|
|
|
if cs.ease > 0 {
|
|
stats.push((tr.card_stats_ease().into(), format!("{}%", cs.ease)));
|
|
}
|
|
stats.push((tr.card_stats_review_count().into(), cs.reviews.to_string()));
|
|
stats.push((tr.card_stats_lapse_count().into(), cs.lapses.to_string()));
|
|
|
|
if cs.total_secs > 0.0 {
|
|
stats.push((
|
|
tr.card_stats_average_time().into(),
|
|
time_span(cs.average_secs, tr, true),
|
|
));
|
|
stats.push((
|
|
tr.card_stats_total_time().into(),
|
|
time_span(cs.total_secs, tr, true),
|
|
));
|
|
}
|
|
|
|
stats.push((tr.card_stats_card_template().into(), cs.card_type));
|
|
stats.push((tr.card_stats_note_type().into(), cs.notetype));
|
|
stats.push((tr.card_stats_deck_name().into(), cs.deck));
|
|
stats.push((tr.card_stats_card_id().into(), cs.cid.0.to_string()));
|
|
stats.push((tr.card_stats_note_id().into(), cs.nid.0.to_string()));
|
|
|
|
let revlog = cs
|
|
.revlog
|
|
.into_iter()
|
|
.rev()
|
|
.map(|e| revlog_to_text(e, tr))
|
|
.collect();
|
|
let revlog_titles = RevlogText {
|
|
time: tr.card_stats_review_log_date().into(),
|
|
kind: tr.card_stats_review_log_type().into(),
|
|
kind_class: "".to_string(),
|
|
rating: tr.card_stats_review_log_rating().into(),
|
|
interval: tr.card_stats_interval().into(),
|
|
ease: tr.card_stats_ease().into(),
|
|
rating_class: "".to_string(),
|
|
taken_secs: tr.card_stats_review_log_time_taken().into(),
|
|
};
|
|
|
|
CardStatsTemplate {
|
|
stats,
|
|
revlog,
|
|
revlog_titles,
|
|
}
|
|
.render()
|
|
.unwrap()
|
|
}
|
|
}
|
|
|
|
fn revlog_to_text(e: RevlogEntry, tr: &I18n) -> RevlogText {
|
|
let dt = Local.timestamp(e.id.as_secs().0, 0);
|
|
let time = dt.format("<b>%Y-%m-%d</b> @ %H:%M").to_string();
|
|
let kind = match e.review_kind {
|
|
RevlogReviewKind::Learning => tr.card_stats_review_log_type_learn().into(),
|
|
RevlogReviewKind::Review => tr.card_stats_review_log_type_review().into(),
|
|
RevlogReviewKind::Relearning => tr.card_stats_review_log_type_relearn().into(),
|
|
RevlogReviewKind::Filtered => tr.card_stats_review_log_type_filtered().into(),
|
|
RevlogReviewKind::Manual => tr.card_stats_review_log_type_manual().into(),
|
|
};
|
|
let kind_class = match e.review_kind {
|
|
RevlogReviewKind::Learning => String::from("revlog-learn"),
|
|
RevlogReviewKind::Review => String::from("revlog-review"),
|
|
RevlogReviewKind::Relearning => String::from("revlog-relearn"),
|
|
RevlogReviewKind::Filtered => String::from("revlog-filtered"),
|
|
RevlogReviewKind::Manual => String::from("revlog-manual"),
|
|
};
|
|
let rating = e.button_chosen.to_string();
|
|
let interval = if e.interval == 0 {
|
|
String::from("")
|
|
} else {
|
|
let interval_secs = e.interval_secs();
|
|
time_span(interval_secs as f32, tr, true)
|
|
};
|
|
let ease = if e.ease_factor > 0 {
|
|
format!("{}%", e.ease_factor / 10)
|
|
} else {
|
|
"".to_string()
|
|
};
|
|
let rating_class = if e.button_chosen == 1 {
|
|
String::from("revlog-ease1")
|
|
} else {
|
|
"".to_string()
|
|
};
|
|
let taken_secs = tr
|
|
.statistics_seconds_taken((e.taken_millis / 1000) as i32)
|
|
.into();
|
|
|
|
RevlogText {
|
|
time,
|
|
kind,
|
|
kind_class,
|
|
rating,
|
|
rating_class,
|
|
interval,
|
|
ease,
|
|
taken_secs,
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use super::*;
|
|
use crate::{collection::open_test_collection, search::SortMode};
|
|
|
|
#[test]
|
|
fn stats() -> Result<()> {
|
|
let mut col = open_test_collection();
|
|
|
|
let nt = col.get_notetype_by_name("Basic")?.unwrap();
|
|
let mut note = nt.new_note();
|
|
col.add_note(&mut note, DeckId(1))?;
|
|
|
|
let cid = col.search_cards("", SortMode::NoOrder)?[0];
|
|
let _report = col.card_stats(cid)?;
|
|
//println!("report {}", report);
|
|
|
|
Ok(())
|
|
}
|
|
}
|