387 lines
12 KiB
Rust
387 lines
12 KiB
Rust
use chrono::{DateTime, Datelike, Utc};
|
|
use chrono_tz::US::Central;
|
|
use clap::Parser;
|
|
use lettre::{
|
|
message::{Message, header::ContentType, Attachment, MultiPart, SinglePart},
|
|
SendmailTransport, Transport,
|
|
};
|
|
use log::{debug, error};
|
|
use reqwest::blocking::Client;
|
|
use serde::{Deserialize, Serialize};
|
|
use std::path::PathBuf;
|
|
|
|
fn main() -> Result<(), Box<dyn std::error::Error>> {
|
|
// --- Loading and setup ---
|
|
let args = CliArgs::parse();
|
|
|
|
simplelog::SimpleLogger::init(
|
|
match args.debug {
|
|
true => simplelog::LevelFilter::Debug,
|
|
false => simplelog::LevelFilter::Info,
|
|
},
|
|
simplelog::Config::default(),
|
|
)?;
|
|
|
|
debug!("Opening Config file: {}", args.config_file.display());
|
|
debug!(
|
|
"Config file exists: {}",
|
|
std::fs::metadata(&args.config_file).is_ok()
|
|
);
|
|
|
|
let file_contents = match std::fs::read_to_string(&args.config_file) {
|
|
Ok(val) => val,
|
|
Err(e) => {
|
|
error!("Could not read config file: {e}");
|
|
panic!("{e}");
|
|
}
|
|
};
|
|
|
|
let cfg: Config = match toml::from_str(&file_contents) {
|
|
Ok(val) => val,
|
|
Err(e) => {
|
|
error!("Could not parse config file: {e}");
|
|
panic!("{e}");
|
|
}
|
|
};
|
|
// --- END Loading and setup ---
|
|
|
|
let mut do_email_summary: bool = false;
|
|
|
|
// --- Get checked and unchecked ---
|
|
let primary_note = Client::new()
|
|
.get(format!(
|
|
"https://{}/index.php/apps/notes/api/v1/notes/{}",
|
|
&cfg.server_url, &cfg.primary_note_id
|
|
))
|
|
.header("Accept", "application/json")
|
|
.header("Content-Type", "application/json")
|
|
.basic_auth(&cfg.user, Some(&cfg.pswd))
|
|
.send()?
|
|
.json::<Note>()?;
|
|
|
|
let primary_note_lines: Vec<&str> = primary_note.content.lines().collect();
|
|
|
|
let mut unchecked: Vec<String> = vec![];
|
|
let mut checked: Vec<String> = vec![];
|
|
|
|
for line in primary_note_lines.iter() {
|
|
if line.starts_with("- [x] Send Summary") {
|
|
do_email_summary = true;
|
|
continue;
|
|
}
|
|
if line.starts_with("- [ ] Send Summary") {
|
|
continue;
|
|
}
|
|
// if line is a checkbox
|
|
if line.starts_with("- [") {
|
|
if line.starts_with("- [ ] ") {
|
|
unchecked.push(line.replace("- [ ] ", ""));
|
|
} else if line.starts_with("- [x] ") {
|
|
checked.push(line.replace("- [x] ", ""));
|
|
}
|
|
}
|
|
}
|
|
|
|
// --- END Get checked and unchecked ---
|
|
|
|
// --- Get current log ---
|
|
let logging_note = Client::new()
|
|
.get(format!(
|
|
"https://{}/index.php/apps/notes/api/v1/notes/{}",
|
|
&cfg.server_url, &cfg.logging_note_id
|
|
))
|
|
.header("Accept", "application/json")
|
|
.header("Content-Type", "application/json")
|
|
.basic_auth(&cfg.user, Some(&cfg.pswd))
|
|
.send()?
|
|
.json::<Note>()?;
|
|
|
|
let now = Utc::now().with_timezone(&Central);
|
|
|
|
let mut body_content: Vec<String> = vec![format!(
|
|
"*Last Updated:* {} Central Time",
|
|
now.format("%D - %H:%M:%S")
|
|
)];
|
|
|
|
let logging_note_lines: Vec<&str> = logging_note.content.lines().collect();
|
|
|
|
for line in logging_note_lines {
|
|
if line.starts_with("*Last Updated") {
|
|
continue;
|
|
}
|
|
if line.starts_with("# ") {
|
|
body_content.push(line.to_string());
|
|
continue;
|
|
}
|
|
if line.starts_with("### ") {
|
|
body_content.push(line.to_string());
|
|
continue;
|
|
}
|
|
|
|
// --- Assume it is a started log ---
|
|
let split: Vec<&str> = line.split('|').collect();
|
|
|
|
let item = match split.first() {
|
|
Some(val) => val,
|
|
None => {
|
|
error!("Couldn't split correctly, item 1");
|
|
panic!("Couldn't split correctly, item 1");
|
|
}
|
|
}
|
|
.replace('#', "")
|
|
.trim()
|
|
.to_string();
|
|
|
|
if unchecked.contains(&item) {
|
|
let timestamp = match split.get(1) {
|
|
Some(val) => val,
|
|
None => {
|
|
error!("Couldn't split correctly, item 2");
|
|
panic!("Couldn't split correctly, item 2");
|
|
}
|
|
};
|
|
let start_time = match DateTime::parse_from_rfc2822(timestamp) {
|
|
Ok(val) => val.with_timezone(&Central),
|
|
Err(e) => {
|
|
error!("Error parsing time: '{timestamp}' : {e}");
|
|
panic!("Error parsing time: '{timestamp}' : {e}");
|
|
}
|
|
};
|
|
|
|
let elapsed_time: chrono::Duration = now - start_time;
|
|
|
|
body_content.push(format!(
|
|
"### {item} | {}h {}m | {}/{}/{}",
|
|
elapsed_time.num_hours(),
|
|
elapsed_time.num_minutes() - elapsed_time.num_hours() * 60, // yes, I'm lazy
|
|
now.month(),
|
|
now.day(),
|
|
now.year()
|
|
));
|
|
} else if !line.is_empty() {
|
|
body_content.push(line.to_string());
|
|
}
|
|
checked.retain(|val| val != &item);
|
|
}
|
|
|
|
checked = checked
|
|
.into_iter()
|
|
.map(|val| {
|
|
format!(
|
|
"## {val} | {}",
|
|
Utc::now().with_timezone(&Central).to_rfc2822()
|
|
)
|
|
})
|
|
.collect();
|
|
|
|
debug!("Creating new logs for: {:#?}", checked);
|
|
|
|
body_content.splice(2..2, checked);
|
|
|
|
debug!("{:#?}", body_content);
|
|
|
|
Client::new()
|
|
.put(format!(
|
|
"https://{}/index.php/apps/notes/api/v1/notes/{}",
|
|
&cfg.server_url, &cfg.logging_note_id
|
|
))
|
|
.header("Accept", "application/json")
|
|
.header("Content-Type", "application/json")
|
|
.basic_auth(&cfg.user, Some(&cfg.pswd))
|
|
.body(serde_json::to_string(&NoteUpdate {
|
|
content: body_content.join("\n"),
|
|
})?)
|
|
.send()?;
|
|
|
|
if do_email_summary {
|
|
debug!("Send email selected");
|
|
reset_email_checkbox(&cfg);
|
|
send_email_summary(&cfg, body_content);
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Debug)]
|
|
struct Note {
|
|
id: usize,
|
|
etag: String,
|
|
readonly: bool,
|
|
modified: u64,
|
|
title: String,
|
|
category: String,
|
|
content: String,
|
|
favorite: bool,
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Debug)]
|
|
struct NoteUpdate {
|
|
content: String,
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Default)]
|
|
struct Config {
|
|
user: String,
|
|
pswd: String,
|
|
email_addr: String,
|
|
primary_note_id: String,
|
|
logging_note_id: String,
|
|
server_url: String,
|
|
}
|
|
|
|
#[derive(Parser, Debug)]
|
|
#[command(author, version, about, long_about=None)]
|
|
struct CliArgs {
|
|
/// Path to config .toml file
|
|
#[arg(short, long)]
|
|
config_file: PathBuf,
|
|
|
|
#[arg(short, long)]
|
|
debug: bool,
|
|
}
|
|
|
|
// All unwraps are unrecoverable errors
|
|
// All calls after depend on the success of the one before, and cannot run
|
|
// without. So it would be too much work to make an error type to handle an error
|
|
// that would cause a crash anyways
|
|
fn reset_email_checkbox(config: &Config) {
|
|
let primary_note = Client::new()
|
|
.get(format!(
|
|
"https://{}/index.php/apps/notes/api/v1/notes/{}",
|
|
&config.server_url, &config.primary_note_id
|
|
))
|
|
.header("Accept", "application/json")
|
|
.header("Content-Type", "application/json")
|
|
.basic_auth(&config.user, Some(&config.pswd))
|
|
.send()
|
|
.unwrap()
|
|
.json::<Note>()
|
|
.unwrap();
|
|
|
|
let primary_note_lines: Vec<&str> = primary_note.content.lines().collect();
|
|
|
|
let mut body_content: Vec<&str> = vec![];
|
|
|
|
for line in primary_note_lines.iter() {
|
|
if line.starts_with("- [x] Send Summary") {
|
|
body_content.push("- [ ] Send Summary");
|
|
} else {
|
|
body_content.push(line);
|
|
}
|
|
}
|
|
|
|
Client::new()
|
|
.put(format!(
|
|
"https://{}/index.php/apps/notes/api/v1/notes/{}",
|
|
&config.server_url, &config.primary_note_id
|
|
))
|
|
.header("Accept", "application/json")
|
|
.header("Content-Type", "application/json")
|
|
.basic_auth(&config.user, Some(&config.pswd))
|
|
.body(
|
|
serde_json::to_string(&NoteUpdate {
|
|
content: body_content.join("\n"),
|
|
})
|
|
.unwrap(),
|
|
)
|
|
.send()
|
|
.unwrap();
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Debug)]
|
|
struct SummaryRow {
|
|
date: String,
|
|
total_time: i64,
|
|
task_name: String,
|
|
}
|
|
|
|
// All unwraps are unrecoverable errors
|
|
// All calls after depend on the success of the one before, and cannot run
|
|
// without. So it would be too much work to make an error type to handle an error
|
|
// that would cause a crash anyways
|
|
fn send_email_summary(config: &Config, body_content: Vec<String>) {
|
|
let mut wtr = csv::Writer::from_writer(vec![]);
|
|
|
|
for line in body_content {
|
|
if line.starts_with("### ") {
|
|
let mut split: Vec<&str> = line.split('|').collect();
|
|
if split.len() != 3 {
|
|
error!("There was an issue with this line: {line}");
|
|
continue;
|
|
}
|
|
let date: String = match split.pop() {
|
|
Some(val) => val,
|
|
None => continue,
|
|
}
|
|
.to_string();
|
|
let time: i64 = {
|
|
// This should never error as the len should always be 3
|
|
let data = match split.pop() {
|
|
Some(val) => val,
|
|
None => continue,
|
|
}
|
|
.trim();
|
|
|
|
// There should always be an h and an m in the second item
|
|
let h_index = match data.chars().position(|c| c == 'h') {
|
|
Some(val) => val,
|
|
None => continue,
|
|
};
|
|
|
|
let m_index = match data.chars().position(|c| c == 'm') {
|
|
Some(val) => val,
|
|
None => continue,
|
|
};
|
|
|
|
// this should always be the "10" in "10h"
|
|
let hours = match data[0..h_index].parse::<i64>() {
|
|
Ok(val) => val,
|
|
Err(_) => continue,
|
|
};
|
|
|
|
// this should always be the "20" in "10h 20m"
|
|
let minutes = match data[(h_index + 2)..m_index].parse::<i64>() {
|
|
Ok(val) => val,
|
|
Err(_) => continue,
|
|
};
|
|
|
|
hours * 60 + minutes
|
|
};
|
|
|
|
let task_name: String = match split.pop() {
|
|
Some(val) => val.trim(),
|
|
None => continue,
|
|
}
|
|
.to_string()
|
|
.replace("### ", "");
|
|
|
|
wtr.serialize(SummaryRow { date: date.trim().to_string(), total_time: time, task_name }).unwrap();
|
|
}
|
|
}
|
|
|
|
let data = String::from_utf8(wtr.into_inner().unwrap()).unwrap();
|
|
|
|
debug!("{:#?}", data);
|
|
|
|
let attachment = Attachment::new("TimeSummary.csv".to_string()).body(data, ContentType::parse("text/csv").unwrap());
|
|
|
|
let email = Message::builder()
|
|
.from("NoReplay <noreply@nickiel.net>".parse().unwrap())
|
|
.to("Nicholas Young <nicholasyoungsumner@gmail.com>".parse().unwrap())
|
|
.subject("Testing email")
|
|
.header(ContentType::TEXT_PLAIN)
|
|
.multipart(
|
|
MultiPart::mixed()
|
|
.singlepart(SinglePart::plain("Hello World".to_string()))
|
|
.singlepart(attachment)
|
|
).unwrap();
|
|
|
|
|
|
let mailer = SendmailTransport::new();
|
|
|
|
match mailer.send(&email) {
|
|
Ok(val) => debug!("email sent: {:?}", val),
|
|
Err(e) => debug!("Couldn't send email {}", e)
|
|
};
|
|
|
|
}
|