678 lines
22 KiB
Rust
678 lines
22 KiB
Rust
use std::sync::Mutex;
|
|
|
|
use chrono::{Timelike, Utc};
|
|
use clap::{Arg, Command};
|
|
#[cfg(feature = "desktop")]
|
|
use mize::item::ItemData;
|
|
use rusqlite::{params, Connection};
|
|
use serde_json::{json, Value};
|
|
|
|
use dioxus::prelude::*;
|
|
use mize::{mize_err, mize_part, Mize, MizeError, MizePart, MizePartCreate, MizeResult};
|
|
|
|
use crate::cli::CliPart;
|
|
use crate::habitica::Habitica;
|
|
use crate::SpacetimePart;
|
|
use generated::spacetime::{
|
|
activitiesQueryTableAccess, next_action, remove_activity, task_partQueryTableAccess,
|
|
update_activity, update_upcoming, Action, ActivitiesTableAccess, Activity, DbConnection,
|
|
TaskPart, TaskPartTableAccess,
|
|
};
|
|
use spacetimedb_sdk::{
|
|
credentials, DbContext, Error, Event, Identity, Status, SubscriptionHandle, Table,
|
|
TableWithPrimaryKey,
|
|
};
|
|
|
|
mod dashboard;
|
|
|
|
#[mize_part]
|
|
#[derive(Default)]
|
|
pub struct C2vi {
|
|
mize: Mize,
|
|
db: Mutex<Option<Connection>>,
|
|
}
|
|
|
|
impl MizePart for C2vi {
|
|
fn opts(&self, mize: &mut Mize) {
|
|
mize.new_opt("c2vi.local_storage_path");
|
|
}
|
|
}
|
|
impl MizePartCreate for C2vi {}
|
|
|
|
impl C2vi {
|
|
fn with_db<F, R>(&self, f: F) -> MizeResult<R>
|
|
where
|
|
F: FnOnce(&Connection) -> MizeResult<R>,
|
|
{
|
|
let guard = self
|
|
.db
|
|
.lock()
|
|
.map_err(|e| mize_err!("DB lock poisoned: {}", e))?;
|
|
let conn = guard
|
|
.as_ref()
|
|
.ok_or_else(|| mize_err!("DB not initialized"))?;
|
|
f(conn)
|
|
}
|
|
}
|
|
|
|
pub fn c2vi(mize: &mut Mize) -> MizeResult<()> {
|
|
#[cfg(feature = "desktop")]
|
|
if mize
|
|
.get_config("c2vi.dash.enable")
|
|
.unwrap_or(ItemData::empty())
|
|
.as_bool()
|
|
.unwrap_or(false)
|
|
{
|
|
// refresh the credentials every 23h
|
|
// as this is basically running as a daemon
|
|
use crate::auth::client::ClientAuth;
|
|
let mut auth = mize.get_part_native::<ClientAuth>("auth")?;
|
|
auth.refresh()?;
|
|
auth.start_refresh_thread()?;
|
|
drop(auth);
|
|
|
|
launch_c2vi_dashboard(mize);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[cfg(feature = "desktop")]
|
|
pub fn launch_c2vi_dashboard(mize: &mut Mize) {
|
|
use dioxus::desktop::{muda::Menu, Config, WindowBuilder};
|
|
let mize_clone = mize.clone();
|
|
LaunchBuilder::new()
|
|
.with_context_provider(move || Box::new(mize_clone.clone()))
|
|
.with_cfg(desktop! {
|
|
Config::new().with_window(WindowBuilder::new().with_decorations(false).with_title("PPC"))
|
|
})
|
|
.launch(c2vi_dash_main);
|
|
}
|
|
|
|
pub fn c2vi_dash_main() -> Element {
|
|
let mut current = use_signal_sync(|| "".to_string());
|
|
use_effect(move || {
|
|
let mut mize = use_context::<Mize>();
|
|
let mut spacetime = mize.get_part_native::<SpacetimePart>("spacetime").unwrap();
|
|
let con = spacetime.con();
|
|
con.subscription_builder()
|
|
.on_applied(move |ctx| {
|
|
let data = ctx.db.task_part().identity().find(&ctx.identity()).unwrap();
|
|
current.set(data.current.name.clone());
|
|
})
|
|
.add_query(|q| q.from.task_part())
|
|
.subscribe();
|
|
con.db
|
|
.task_part()
|
|
.on_update(move |_, old: &TaskPart, new: &TaskPart| {
|
|
current.set(new.current.name.clone());
|
|
});
|
|
});
|
|
rsx! {
|
|
div {
|
|
style: "text-align: center; padding: 2rem; font-size: 50px;",
|
|
p {
|
|
"{current}"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn c2vi_client(mize: &mut Mize) -> MizeResult<()> {
|
|
//let storage_path = mize.get_config("c2vi.local_storage_path")?.as_
|
|
let storage_path = "/home/me/work/app-data/ppc";
|
|
//println!("storage_path: {}", storage_path);
|
|
let db_path = std::path::PathBuf::from(&storage_path).join("data.db");
|
|
let conn = Connection::open(&db_path)
|
|
.map_err(|e| mize_err!("Failed to open C2vi database at {:?}: {}", db_path, e))?;
|
|
|
|
setup_tables(&conn)?;
|
|
|
|
let c2vi_part = C2vi {
|
|
mize: mize.clone(),
|
|
db: Mutex::new(Some(conn)),
|
|
};
|
|
mize.register_part(Box::new(c2vi_part))?;
|
|
|
|
// Register CLI subcommands
|
|
let mut cli = mize.get_part_native::<CliPart>("cli")?;
|
|
register_subcommands(&mut cli);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn setup_tables(conn: &Connection) -> MizeResult<()> {
|
|
conn.execute(
|
|
"CREATE TABLE IF NOT EXISTS habitica_dailies (
|
|
id TEXT PRIMARY KEY,
|
|
text TEXT NOT NULL,
|
|
notes TEXT,
|
|
priority TEXT,
|
|
frequency TEXT
|
|
)",
|
|
[],
|
|
)
|
|
.map_err(|e| mize_err!("DB error creating habitica_dailies: {}", e))?;
|
|
conn.execute(
|
|
"CREATE TABLE IF NOT EXISTS habitica_log (
|
|
date TEXT PRIMARY KEY,
|
|
data TEXT NOT NULL
|
|
)",
|
|
[],
|
|
)
|
|
.map_err(|e| mize_err!("DB error creating habitica_log: {}", e))?;
|
|
Ok(())
|
|
}
|
|
|
|
fn register_subcommands(cli: &mut CliPart) {
|
|
cli.subcommand(
|
|
Command::new("c2vi-dash").about("Run the c2vi dashboard gui"),
|
|
|_matches, mut _mize| Ok(dioxus::launch(dashboard::main)),
|
|
);
|
|
cli.subcommand(
|
|
Command::new("bed").about("Command to run when c2vi goes to bed"),
|
|
|_matches, mut mize| {
|
|
save_habitica_dailies(&mut mize)?;
|
|
save_habitica_logs(&mut mize)?;
|
|
Ok(())
|
|
},
|
|
);
|
|
|
|
cli.subcommand(
|
|
Command::new("clearTodos")
|
|
.about("Clear all Habitica todos")
|
|
.alias("clt"),
|
|
|_matches, mut mize| {
|
|
let todos = {
|
|
let mut hab = mize.get_part_native::<Habitica>("habitica")?;
|
|
hab.get_tasks("todos")?
|
|
};
|
|
let mut hab = mize.get_part_native::<Habitica>("habitica")?;
|
|
if let Some(arr) = todos.as_array() {
|
|
for todo in arr {
|
|
if let Some(id) = todo["id"].as_str() {
|
|
hab.delete_task(id)?;
|
|
}
|
|
}
|
|
}
|
|
Ok(())
|
|
},
|
|
);
|
|
|
|
cli.subcommand(
|
|
Command::new("listTodos")
|
|
.about("List all Habitica todos")
|
|
.alias("dut"),
|
|
|_matches, mut mize| {
|
|
let mut hab = mize.get_part_native::<Habitica>("habitica")?;
|
|
let todos = hab.get_tasks("todos")?;
|
|
if let Some(arr) = todos.as_array() {
|
|
for todo in arr {
|
|
if let Some(text) = todo["text"].as_str() {
|
|
println!("{}", text);
|
|
}
|
|
}
|
|
}
|
|
Ok(())
|
|
},
|
|
);
|
|
|
|
cli.subcommand(
|
|
Command::new("buyHealthPotion")
|
|
.about("Buy a health potion")
|
|
.alias("buyh"),
|
|
|_matches, mut mize| {
|
|
let mut hab = mize.get_part_native::<Habitica>("habitica")?;
|
|
hab.api_request(
|
|
reqwest::Method::POST,
|
|
"user/buy-health-potion".to_string(),
|
|
json!({}),
|
|
)?;
|
|
Ok(())
|
|
},
|
|
);
|
|
|
|
cli.subcommand(
|
|
Command::new("addActionItems")
|
|
.about("Add action items from temp file")
|
|
.alias("aal"),
|
|
|_matches, mut mize| add_action_items(&mut mize),
|
|
);
|
|
|
|
cli.subcommand(
|
|
Command::new("skip")
|
|
.about("Skip a Habitica todo")
|
|
.alias("sk")
|
|
.arg(Arg::new("num").default_value("1")),
|
|
|matches, mut mize| {
|
|
let num: usize = matches
|
|
.get_one::<String>("num")
|
|
.unwrap()
|
|
.parse()
|
|
.unwrap_or(1);
|
|
skip_habitica_todo(&mut mize, num)
|
|
},
|
|
);
|
|
|
|
cli.subcommand(
|
|
Command::new("dumpLog").about("Dump the complete Habitica log"),
|
|
|_matches, mut mize| dump_habitica_logs(&mut mize),
|
|
);
|
|
|
|
cli.subcommand(
|
|
Command::new("listDailies").about("List all dailies from local DB"),
|
|
|_matches, mut mize| {
|
|
let c2vi = mize.get_part_native::<C2vi>("c2vi")?;
|
|
c2vi.with_db(|conn| {
|
|
let mut stmt = conn
|
|
.prepare("SELECT id, text FROM habitica_dailies")
|
|
.map_err(|e| mize_err!("DB error: {}", e))?;
|
|
let rows = stmt
|
|
.query_map([], |row| {
|
|
Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))
|
|
})
|
|
.map_err(|e| mize_err!("DB error: {}", e))?;
|
|
for row in rows {
|
|
let (id, text) = row.map_err(|e| mize_err!("DB error: {}", e))?;
|
|
println!("{}: {}", id, text);
|
|
}
|
|
Ok(())
|
|
})
|
|
},
|
|
);
|
|
|
|
cli.subcommand(
|
|
Command::new("printTask")
|
|
.about("Print a specific task from Habitica")
|
|
.arg(Arg::new("id").required(true)),
|
|
|matches, mut mize| {
|
|
let id = matches.get_one::<String>("id").unwrap();
|
|
let mut hab = mize.get_part_native::<Habitica>("habitica")?;
|
|
let data = hab.api_request(reqwest::Method::GET, format!("tasks/{}", id), json!({}))?;
|
|
if let Some(history) = data.get("history") {
|
|
println!(
|
|
"{}",
|
|
serde_json::to_string_pretty(history).unwrap_or_default()
|
|
);
|
|
} else {
|
|
println!(
|
|
"{}",
|
|
serde_json::to_string_pretty(&data).unwrap_or_default()
|
|
);
|
|
}
|
|
Ok(())
|
|
},
|
|
);
|
|
}
|
|
|
|
// ============= Business Logic =============
|
|
|
|
fn format_date(dt: chrono::DateTime<Utc>) -> String {
|
|
dt.format("%Y-%m-%d").to_string()
|
|
}
|
|
|
|
/// Get the target date, adjusted for "save for yesterday" logic (before noon = yesterday)
|
|
fn get_target_date() -> (String, bool) {
|
|
let now = Utc::now();
|
|
let save_for_yesterday = now.hour() < 12;
|
|
let date = if save_for_yesterday {
|
|
now - chrono::Duration::days(1)
|
|
} else {
|
|
now
|
|
};
|
|
if save_for_yesterday {
|
|
println!(
|
|
"Saving logs for yesterday because it is {} hours of the day",
|
|
now.hour()
|
|
);
|
|
}
|
|
(format_date(date), save_for_yesterday)
|
|
}
|
|
|
|
/// Load existing log entry from DB, or return a default empty one
|
|
fn get_or_create_log(conn: &Connection, date: &str) -> MizeResult<Value> {
|
|
let mut stmt = conn
|
|
.prepare("SELECT data FROM habitica_log WHERE date = ?1")
|
|
.map_err(|e| mize_err!("DB error: {}", e))?;
|
|
let result: Option<String> = stmt.query_row(params![date], |row| row.get(0)).ok();
|
|
match result {
|
|
Some(data_str) => {
|
|
serde_json::from_str(&data_str).map_err(|e| mize_err!("JSON parse error: {}", e))
|
|
}
|
|
None => Ok(json!({
|
|
"dailies_done": [],
|
|
"dailies_skipped": [],
|
|
"todos_done": [],
|
|
"todos_skipped": []
|
|
})),
|
|
}
|
|
}
|
|
|
|
/// Upsert a log entry into the database
|
|
fn upsert_log(conn: &Connection, date: &str, data: &Value) -> MizeResult<()> {
|
|
let data_str =
|
|
serde_json::to_string(data).map_err(|e| mize_err!("JSON serialize error: {}", e))?;
|
|
conn.execute(
|
|
"INSERT INTO habitica_log (date, data) VALUES (?1, ?2)
|
|
ON CONFLICT(date) DO UPDATE SET data=excluded.data",
|
|
params![date, data_str],
|
|
)
|
|
.map_err(|e| mize_err!("DB error upserting log: {}", e))?;
|
|
Ok(())
|
|
}
|
|
|
|
fn save_habitica_dailies(mize: &mut Mize) -> MizeResult<()> {
|
|
println!("######### cli bed cmd #########");
|
|
|
|
// Fetch dailies from Habitica
|
|
let dailies = {
|
|
let mut hab = mize.get_part_native::<Habitica>("habitica")?;
|
|
hab.get_tasks("dailys")?
|
|
};
|
|
|
|
// Write to database
|
|
let c2vi = mize.get_part_native::<C2vi>("c2vi")?;
|
|
c2vi.with_db(|conn| {
|
|
if let Some(arr) = dailies.as_array() {
|
|
println!("Syncing {} dailies to database...", arr.len());
|
|
for daily in arr {
|
|
let id = daily["id"].as_str().unwrap_or("");
|
|
let text = daily["text"].as_str().unwrap_or("");
|
|
let notes = daily["notes"].as_str().unwrap_or("");
|
|
let priority = daily["priority"].to_string();
|
|
let frequency = daily["frequency"].as_str().unwrap_or("daily");
|
|
|
|
conn.execute(
|
|
"INSERT INTO habitica_dailies (id, text, notes, priority, frequency)
|
|
VALUES (?1, ?2, ?3, ?4, ?5)
|
|
ON CONFLICT(id) DO UPDATE SET
|
|
text=excluded.text,
|
|
notes=excluded.notes,
|
|
priority=excluded.priority,
|
|
frequency=excluded.frequency",
|
|
params![id, text, notes, priority, frequency],
|
|
)
|
|
.map_err(|e| mize_err!("DB error writing daily: {}", e))?;
|
|
}
|
|
}
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
fn save_habitica_logs(mize: &mut Mize) -> MizeResult<()> {
|
|
let (date_str, save_for_yesterday) = get_target_date();
|
|
|
|
// Fetch dailies and completed todos from Habitica
|
|
let (dailies, completed_todos) = {
|
|
let mut hab = mize.get_part_native::<Habitica>("habitica")?;
|
|
let dailies = hab.get_tasks("dailys")?;
|
|
let completed_todos = hab.get_tasks("completedTodos")?;
|
|
(dailies, completed_todos)
|
|
};
|
|
|
|
let c2vi = mize.get_part_native::<C2vi>("c2vi")?;
|
|
c2vi.with_db(|conn| {
|
|
let mut data = get_or_create_log(conn, &date_str)?;
|
|
|
|
// Process dailies
|
|
if let Some(arr) = dailies.as_array() {
|
|
for daily in arr {
|
|
let is_due = if save_for_yesterday {
|
|
// Look at history for yesterday's status
|
|
daily["history"]
|
|
.as_array()
|
|
.and_then(|h| h.iter().max_by_key(|e| e["date"].as_i64().unwrap_or(0)))
|
|
.map(|e| e["isDue"].as_bool().unwrap_or(false))
|
|
.unwrap_or(false)
|
|
} else {
|
|
daily["isDue"].as_bool().unwrap_or(false)
|
|
};
|
|
|
|
if !is_due {
|
|
continue;
|
|
}
|
|
|
|
let completed = if save_for_yesterday {
|
|
daily["history"]
|
|
.as_array()
|
|
.and_then(|h| h.iter().max_by_key(|e| e["date"].as_i64().unwrap_or(0)))
|
|
.map(|e| e["completed"].as_bool().unwrap_or(false))
|
|
.unwrap_or(false)
|
|
} else {
|
|
daily["completed"].as_bool().unwrap_or(false)
|
|
};
|
|
|
|
let daily_id = daily["id"].as_str().unwrap_or("");
|
|
let daily_text = daily["text"].as_str().unwrap_or("");
|
|
|
|
if completed {
|
|
data["dailies_done"]
|
|
.as_array_mut()
|
|
.unwrap()
|
|
.push(json!(daily_id));
|
|
println!("daily-done: {}", daily_text);
|
|
} else {
|
|
data["dailies_skipped"]
|
|
.as_array_mut()
|
|
.unwrap()
|
|
.push(json!(daily_id));
|
|
println!("daily-skipped: {}", daily_text);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Process completed todos
|
|
if let Some(arr) = completed_todos.as_array() {
|
|
let today_str = format_date(Utc::now());
|
|
for todo in arr {
|
|
let date_completed_str = todo["dateCompleted"].as_str().unwrap_or("");
|
|
|
|
// Parse the completion date (ISO 8601 format from Habitica)
|
|
let date_completed = chrono::DateTime::parse_from_rfc3339(date_completed_str)
|
|
.map(|d| format_date(d.with_timezone(&Utc)))
|
|
.unwrap_or_default();
|
|
|
|
// Check if already in the log for this date
|
|
if save_for_yesterday {
|
|
let existing_todos = data["todos_done"].as_array().unwrap();
|
|
let todo_id = todo["id"].as_str().unwrap_or("");
|
|
if existing_todos
|
|
.iter()
|
|
.any(|t| t["id"].as_str() == Some(todo_id))
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
let todo_entry = json!({
|
|
"id": todo["id"],
|
|
"text": todo["text"],
|
|
"notes": todo.get("notes").unwrap_or(&json!("")),
|
|
"checklist": todo.get("checklist").unwrap_or(&json!([])),
|
|
"tags": todo.get("tags").unwrap_or(&json!([])),
|
|
});
|
|
|
|
// Save if completed on the target date
|
|
if date_completed == date_str {
|
|
println!("todo-done: {}", todo["text"].as_str().unwrap_or(""));
|
|
data["todos_done"]
|
|
.as_array_mut()
|
|
.unwrap()
|
|
.push(todo_entry.clone());
|
|
}
|
|
|
|
// If saving for yesterday but todo was completed today, also record it
|
|
if save_for_yesterday && date_completed == today_str {
|
|
println!("todo-done: {}", todo["text"].as_str().unwrap_or(""));
|
|
data["todos_done"].as_array_mut().unwrap().push(todo_entry);
|
|
}
|
|
}
|
|
}
|
|
|
|
upsert_log(conn, &date_str, &data)?;
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
fn skip_habitica_todo(mize: &mut Mize, num: usize) -> MizeResult<()> {
|
|
let (date_str, _) = get_target_date();
|
|
|
|
// Fetch todos from Habitica
|
|
let todos = {
|
|
let mut hab = mize.get_part_native::<Habitica>("habitica")?;
|
|
hab.get_tasks("todos")?
|
|
};
|
|
|
|
let arr = todos
|
|
.as_array()
|
|
.ok_or_else(|| mize_err!("Expected array of todos"))?;
|
|
|
|
// Delete and log each skipped todo
|
|
for i in 0..num {
|
|
let todo = match arr.get(i) {
|
|
Some(t) => t,
|
|
None => continue,
|
|
};
|
|
|
|
let todo_id = todo["id"].as_str().unwrap_or("");
|
|
|
|
// Delete the todo and score the skip habit
|
|
{
|
|
let mut hab = mize.get_part_native::<Habitica>("habitica")?;
|
|
hab.delete_task(todo_id)?;
|
|
}
|
|
increment_habit(mize)?;
|
|
|
|
// Record in log
|
|
let c2vi = mize.get_part_native::<C2vi>("c2vi")?;
|
|
c2vi.with_db(|conn| {
|
|
let mut data = get_or_create_log(conn, &date_str)?;
|
|
data["todos_skipped"].as_array_mut().unwrap().push(json!({
|
|
"id": todo["id"],
|
|
"text": todo["text"],
|
|
"notes": todo.get("notes").unwrap_or(&json!("")),
|
|
"checklist": todo.get("checklist").unwrap_or(&json!([])),
|
|
"tags": todo.get("tags").unwrap_or(&json!([])),
|
|
}));
|
|
upsert_log(conn, &date_str, &data)?;
|
|
Ok(())
|
|
})?;
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn increment_habit(mize: &mut Mize) -> MizeResult<()> {
|
|
let mut hab = mize.get_part_native::<Habitica>("habitica")?;
|
|
let habits = hab.get_tasks("habits")?;
|
|
if let Some(arr) = habits.as_array() {
|
|
for habit in arr {
|
|
if habit["text"].as_str() == Some("skipped a planned task") {
|
|
let id = habit["id"].as_str().unwrap_or("");
|
|
hab.api_request(
|
|
reqwest::Method::POST,
|
|
format!("tasks/{}/score/down", id),
|
|
json!({}),
|
|
)?;
|
|
return Ok(());
|
|
}
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn add_action_items(mize: &mut Mize) -> MizeResult<()> {
|
|
let initial_content = "\
|
|
gu 10min TIMER
|
|
uw 15min FROG
|
|
b coffee/tee/kakau
|
|
uw FROG
|
|
b breakfast, brush teeth, lüften
|
|
uw FROG
|
|
|
|
lunch
|
|
|
|
uw 15min TIMER of next days FROG
|
|
fw
|
|
dt 30min TIMER
|
|
|
|
fun 20:00 (smth that can be stopped easily)
|
|
se 21:40
|
|
read
|
|
bed 22:10";
|
|
|
|
let tmp_file =
|
|
std::env::temp_dir().join(format!("habitica-tasks-{}.md", Utc::now().timestamp()));
|
|
std::fs::write(&tmp_file, initial_content)
|
|
.map_err(|e| mize_err!("Failed to write temp file: {}", e))?;
|
|
|
|
// Open in nvim for editing
|
|
std::process::Command::new("nvim")
|
|
.arg(&tmp_file)
|
|
.status()
|
|
.map_err(|e| mize_err!("Failed to run nvim: {}", e))?;
|
|
|
|
// Read back and parse
|
|
let list_str = std::fs::read_to_string(&tmp_file)
|
|
.map_err(|e| mize_err!("Failed to read temp file: {}", e))?;
|
|
let _ = std::fs::remove_file(&tmp_file);
|
|
|
|
let tasks: Vec<&str> = list_str
|
|
.lines()
|
|
.map(|l| l.trim())
|
|
.filter(|l| !l.is_empty())
|
|
.collect();
|
|
|
|
// Add tasks to Habitica
|
|
let mut task_ids = Vec::new();
|
|
{
|
|
let mut hab = mize.get_part_native::<Habitica>("habitica")?;
|
|
for todo_text in &tasks {
|
|
let data = hab.api_request(
|
|
reqwest::Method::POST,
|
|
"tasks/user".to_string(),
|
|
json!({ "text": todo_text, "type": "todo" }),
|
|
)?;
|
|
let id = data["id"].as_str().unwrap_or("").to_string();
|
|
println!("Added to-do: '{}' with id '{}'", todo_text, id);
|
|
task_ids.push(id);
|
|
}
|
|
|
|
// Move all tasks to bottom
|
|
for task_id in &task_ids {
|
|
hab.api_request(
|
|
reqwest::Method::POST,
|
|
format!("tasks/{}/move/to/-1", task_id),
|
|
json!({}),
|
|
)?;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
fn dump_habitica_logs(mize: &mut Mize) -> MizeResult<()> {
|
|
let c2vi = mize.get_part_native::<C2vi>("c2vi")?;
|
|
c2vi.with_db(|conn| {
|
|
let mut stmt = conn
|
|
.prepare("SELECT date, data FROM habitica_log ORDER BY date")
|
|
.map_err(|e| mize_err!("DB error: {}", e))?;
|
|
let rows = stmt
|
|
.query_map([], |row| {
|
|
Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?))
|
|
})
|
|
.map_err(|e| mize_err!("DB error: {}", e))?;
|
|
for row in rows {
|
|
let (date, data_str) = row.map_err(|e| mize_err!("DB error: {}", e))?;
|
|
let data: Value =
|
|
serde_json::from_str(&data_str).unwrap_or(json!({"parse_error": data_str}));
|
|
println!(
|
|
"{}: {}",
|
|
date,
|
|
serde_json::to_string_pretty(&data).unwrap_or_default()
|
|
);
|
|
}
|
|
Ok(())
|
|
})
|
|
}
|