A bot that allows users to post issues on a Gitea instance without registering simply by acting as a medium.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

316 lines
12 KiB

use melib::Envelope;
use rusqlite::types::ToSql;
use rusqlite::{Connection, NO_PARAMS};
use std::io::{stdin, Read};
use time::Timespec;
use uuid::Uuid;
mod error;
use error::*;
mod api;
mod conf;
use conf::*;
mod cron;
mod templates;
type Password = Uuid;
static PASSWORD_COMMANDS: &'static [&'static str] = &["reply", "unsubscribe", "subscribe", "close"];
use melib::{email::parser, Address};
#[derive(Debug)]
pub struct Issue {
id: i64,
submitter: Address,
password: Password,
time_created: Timespec,
anonymous: bool,
subscribed: bool,
title: String,
last_update: String,
}
fn new_address(s: &str) -> Address {
parser::address(s.as_bytes()).to_full_result().unwrap()
}
pub fn send_mail(d: melib::email::Draft, conf: &Config) {
use std::io::Write;
use std::process::Stdio;
let parts = conf.mailer.split_whitespace().collect::<Vec<&str>>();
let (cmd, args) = (parts[0], &parts[1..]);
let mut mailer = std::process::Command::new(cmd)
.args(args)
.stdin(Stdio::piped())
.stdout(Stdio::inherit())
.spawn()
.expect("Failed to start mailer command");
{
let stdin = mailer.stdin.as_mut().expect("failed to open stdin");
let draft = d.finalise().unwrap();
stdin
.write_all(draft.as_bytes())
.expect("Failed to write to stdin");
}
let output = mailer.wait().expect("Failed to wait on mailer");
if !output.success() {
// TODO: commit to database queue
eprintln!("mailer fail");
std::process::exit(1);
}
}
fn main() -> std::result::Result<(), std::io::Error> {
let mut file = std::fs::File::open("./config.toml")?;
let args = std::env::args().skip(1).collect::<Vec<String>>();
let perform_cron: bool;
if args.len() > 1 {
eprintln!("Too many arguments.");
std::process::exit(1);
} else if args == &["cron"] {
perform_cron = true;
} else if args.is_empty() {
perform_cron = false;
} else {
eprintln!("Usage: issue_bot [cron]");
std::process::exit(1);
}
let mut contents = String::new();
file.read_to_string(&mut contents)?;
let conf: Config = toml::from_str(&contents).unwrap();
/* - read mail from stdin
* - decide which case this mail falls to
* a) error/junk
* reply with error
* b) new issue
* - assign random id to issue
* - reply to sender with id
* - save id to sqlite3
* - post issue
* c) reply
* d) close
*
*
*/
let db_path = "./sqlite3.db";
let conn = Connection::open(db_path).unwrap();
conn.execute(
"CREATE TABLE IF NOT EXISTS issue (
id INTEGER PRIMARY KEY,
submitter TEXT NOT NULL,
password BLOB,
time_created TEXT NOT NULL,
anonymous BOOLEAN,
subscribed BOOLEAN,
title TEXT NOT NULL,
last_update TEXT
)",
NO_PARAMS,
)
.unwrap();
if perform_cron {
cron::check(conn, conf);
return Ok(());
}
let mut new_message_raw = String::new();
stdin().lock().read_to_string(&mut new_message_raw).unwrap();
let envelope = Envelope::from_bytes(new_message_raw.as_bytes(), None);
if let Ok(envelope) = envelope {
let mut reply = melib::Draft::new_reply(&envelope, &[]);
reply.headers_mut().insert(
"From".to_string(),
format!(
"{local_part}@{domain}",
local_part = &conf.local_part,
domain = &conf.domain
),
);
let tags: Vec<String> = envelope.to()[0].get_tags('+');
match tags.as_slice() {
s if s.is_empty() || s == &["anonymous"] => {
/* Assign new issue */
let subject = envelope.subject().to_string();
let body = envelope.body_bytes(new_message_raw.as_bytes()).text();
let from = envelope.from()[0].clone();
let mut reply = melib::Draft::new_reply(&envelope, &[]);
let anonymous = !tags.is_empty();
reply.headers_mut().insert(
"From".to_string(),
format!(
"{local_part}@{domain}",
local_part = &conf.local_part,
domain = &conf.domain
),
);
match api::new_issue(&conn, subject.clone(), body, anonymous, from, &conf) {
Ok((password, issue_id)) => {
reply.headers_mut().insert(
"Subject".to_string(),
format!(
"[{tag}] Issue `{}` successfully created",
&subject,
tag = &conf.tag
),
);
reply.set_body(templates::new_issue_success(
subject, password, issue_id, &conf,
));
send_mail(reply, &conf);
}
Err(e) => {
reply.headers_mut().insert(
"Subject".to_string(),
format!(
"[{tag}] Issue `{}` could not be created",
&subject,
tag = &conf.tag
),
);
reply.set_body(templates::new_issue_failure(e, &conf));
send_mail(reply, &conf);
}
}
}
&[ref p, ref cmd]
if Password::parse_str(p).is_ok() && PASSWORD_COMMANDS.contains(&cmd.as_str()) =>
{
let p = Password::parse_str(p).unwrap();
match cmd.as_str() {
"reply" => {
let body = envelope.body_bytes(new_message_raw.as_bytes()).text();
let from = envelope.from()[0].clone();
match api::new_reply(&conn, body, p, from, &conf) {
Ok((title, issue_id, is_subscribed)) => {
reply.headers_mut().insert(
"Subject".to_string(),
format!(
"[{tag}] Your reply on issue `{}` has been posted",
&title,
tag = &conf.tag,
),
);
reply.set_body(templates::new_reply_success(
title,
p,
issue_id,
is_subscribed,
&conf,
));
send_mail(reply, &conf);
}
Err(e) => {
reply.headers_mut().insert(
"Subject".to_string(),
format!(
"[{tag}] Your reply could not be created",
tag = &conf.tag,
),
);
reply.set_body(templates::new_reply_failure(e, &conf));
send_mail(reply, &conf);
}
}
}
"close" => match api::close(&conn, p, &conf) {
Ok((title, issue_id, _)) => {
reply.headers_mut().insert(
"Subject".to_string(),
format!(
"[{tag}] issue `{}` has been closed",
&title,
tag = &conf.tag
),
);
reply.set_body(templates::close_success(title, issue_id, &conf));
send_mail(reply, &conf);
}
Err(e) => {
reply.headers_mut().insert(
"Subject".to_string(),
format!("[{tag}] issue could not be closed", tag = &conf.tag,),
);
reply.set_body(templates::close_failure(e, &conf));
send_mail(reply, &conf);
}
},
"unsubscribe" => match api::change_subscription(&conn, p, false) {
Ok((title, issue_id, _)) => {
reply.headers_mut().insert(
"Subject".to_string(),
format!(
"[{tag}] subscription removal to `{}` successful",
&title,
tag = &conf.tag
),
);
reply.set_body(templates::change_subscription_success(
title, p, issue_id, false, &conf,
));
send_mail(reply, &conf);
}
Err(e) => {
eprintln!("error: {}", e.to_string());
reply.headers_mut().insert(
"Subject".to_string(),
format!("[{tag}] could not unsubscribe", tag = &conf.tag,),
);
reply.set_body(templates::change_subscription_failure(false, &conf));
send_mail(reply, &conf);
}
},
"subscribe" => match api::change_subscription(&conn, p, true) {
Ok((title, issue_id, _)) => {
reply.headers_mut().insert(
"Subject".to_string(),
format!(
"[{tag}] subscription to `{}` successful",
&title,
tag = &conf.tag
),
);
reply.set_body(templates::change_subscription_success(
title, p, issue_id, true, &conf,
));
send_mail(reply, &conf);
}
Err(e) => {
eprintln!("error: {}", e.to_string());
reply.headers_mut().insert(
"Subject".to_string(),
format!("[{tag}] could not subscribe", tag = &conf.tag,),
);
reply.set_body(templates::change_subscription_failure(true, &conf));
send_mail(reply, &conf);
}
},
other => {
reply.headers_mut().insert(
"Subject".to_string(),
format!("[{tag}] invalid action: `{}`", &other, tag = &conf.tag),
);
reply.set_body(templates::invalid_request(&conf));
send_mail(reply, &conf);
}
}
}
other => {
reply.headers_mut().insert(
"Subject".to_string(),
format!("[{tag}] invalid request", tag = &conf.tag),
);
reply.set_body(templates::invalid_request(&conf));
send_mail(reply, &conf);
println!("error: {:?}", other);
}
}
}
Ok(())
}