TFC/tfcconnection
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

making email a lot smarter

Browse source
This commit is contained in:
Chris Cochrun 2024-11-08 07:07:10 -06:00
parent a777d0a29e
commit e8dbb324f3
4 changed files with 253 additions and 437 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

19
src/api/camp_form.rs
View file

@ -11,6 +11,8 @@ use maud::html;
use maud::DOCTYPE; use maud::DOCTYPE;
use reqwest::{Client, Error}; use reqwest::{Client, Error};
use crate::email::send_email;
#[derive(Debug, MultipartForm, Default)] #[derive(Debug, MultipartForm, Default)]
struct CampForm { struct CampForm {
#[multipart(rename = "first-name")] #[multipart(rename = "first-name")]
@ -258,22 +260,7 @@ pub async fn camp_form(MultipartForm(form): MultipartForm<CampForm>) -> HttpResp
.subject(email_subject) .subject(email_subject)
.multipart(multi) .multipart(multi)
{ {
let sender = SmtpTransport::relay("mail.tfcconnection.org") let _ = send_email(m);
.ok()
.unwrap()
.credentials(Credentials::new(
"no-reply@mail.tfcconnection.org".to_owned(),
"r9f36mNZFtiW4f".to_owned(),
))
.authentication(vec![Mechanism::Plain])
.build();
match sender.send(&m) {
Ok(res) => log::info!(
"Successfully sent email to server with this response: {:?}",
res
),
Err(e) => log::error!("{e}"),
}
} else { } else {
log::info!("Email incorrect"); log::info!("Email incorrect");
} }

639
src/api/mt_form.rs
View file

@ -1,458 +1,269 @@
use std::fs; use std::fs;
use actix_multipart::form::{tempfile::TempFile, text::Text, MultipartForm}; use actix_multipart::form::{tempfile::TempFile, text::Text, MultipartForm};
use actix_rt::Runtime;
use actix_web::{post, HttpResponse}; use actix_web::{post, HttpResponse};
use color_eyre::Result;
use lettre::{ use lettre::{
message::{header::ContentType, Attachment, MultiPart, SinglePart}, message::{header::ContentType, Attachment, MultiPart, SinglePart},
transport::smtp::authentication::{Credentials, Mechanism}, transport::smtp::authentication::{Credentials, Mechanism},
Message, SmtpTransport, Transport, Message, SmtpTransport, Transport,
}; };
use markup::DynRender;
use maud::{html, PreEscaped, DOCTYPE};
use tracing::{error, info, warn};
#[derive(Debug, MultipartForm, Default)] #[derive(Debug, MultipartForm)]
struct MtForm { struct MtForm {
#[multipart(rename = "firstname")] #[multipart(rename = "firstname")]
first_name: Option<Text<String>>, first_name: Text<String>,
#[multipart(rename = "lastname")] #[multipart(rename = "lastname")]
last_name: Option<Text<String>>, last_name: Text<String>,
#[multipart(rename = "parentfirstname")] #[multipart(rename = "parentfirstname")]
parent_first_name: Option<Text<String>>, parent_first_name: Text<String>,
#[multipart(rename = "parentlastname")] #[multipart(rename = "parentlastname")]
parent_last_name: Option<Text<String>>, parent_last_name: Text<String>,
birthdate: Option<Text<String>>, birthdate: Text<String>,
gender: Option<Text<String>>, gender: Text<String>,
street: Option<Text<String>>, street: Text<String>,
city: Option<Text<String>>, city: Text<String>,
state: Option<Text<String>>, state: Text<String>,
zip: Option<Text<i32>>, zip: Text<i32>,
cellphone: Option<Text<String>>, cellphone: Text<String>,
parentphone: Option<Text<String>>, parentphone: Text<String>,
email: Option<Text<String>>, email: Text<String>,
parentemail: Option<Text<String>>, parentemail: Text<String>,
school: Option<Text<String>>, school: Text<String>,
grade: Option<Text<String>>, grade: Text<String>,
#[multipart(rename = "pastorfirstname")] #[multipart(rename = "pastorfirstname")]
pastor_first_name: Option<Text<String>>, pastor_first_name: Text<String>,
#[multipart(rename = "pastorlastname")] #[multipart(rename = "pastorlastname")]
pastor_last_name: Option<Text<String>>, pastor_last_name: Text<String>,
#[multipart(rename = "churchattendance")] #[multipart(rename = "churchattendance")]
church_attendance: Option<Text<String>>, church_attendance: Text<String>,
#[multipart(rename = "tfcgroup")] #[multipart(rename = "tfcgroup")]
tfc_group: Option<Text<String>>, tfc_group: Text<String>,
shirt: Option<Text<String>>, shirt: Text<String>,
trip: Option<Text<String>>, trip: Text<String>,
#[multipart(rename = "tripnotes")] #[multipart(rename = "tripnotes")]
trip_notes: Option<Text<String>>, trip_notes: Text<String>,
#[multipart(rename = "relationship-with-jesus")] #[multipart(rename = "relationship-with-jesus")]
relationship_with_jesus: Option<Text<String>>, relationship_with_jesus: Text<String>,
#[multipart(rename = "testimony")] #[multipart(rename = "testimony")]
testimony: Option<Text<String>>, testimony: Text<String>,
#[multipart(rename = "involvement-with-group")] #[multipart(rename = "involvement-with-group")]
involvement_with_group: Option<Text<String>>, involvement_with_group: Text<String>,
#[multipart(rename = "reasons-for-trip-choice")] #[multipart(rename = "reasons-for-trip-choice")]
reasons: Option<Text<String>>, reasons: Text<String>,
strengths: Option<Text<String>>, strengths: Text<String>,
weaknesses: Option<Text<String>>, weaknesses: Text<String>,
#[multipart(rename = "previous-trip-info")] #[multipart(rename = "previous-trip-info")]
previous_trip_info: Option<Text<String>>, previous_trip_info: Text<String>,
#[multipart(rename = "attitude-torward-work")] #[multipart(rename = "attitude-torward-work")]
attitude: Option<Text<String>>, attitude: Text<String>,
#[multipart(rename = "relevant-notes")] #[multipart(rename = "relevant-notes")]
relevant_notes: Option<Text<String>>, relevant_notes: Text<String>,
#[multipart(rename = "final-agreement")] #[multipart(rename = "final-agreement")]
final_agreement: Option<Text<String>>, final_agreement: Text<String>,
registration: Option<Text<String>>, registration: Text<String>,
#[multipart(rename = "image")] #[multipart(rename = "image")]
file: Option<TempFile>, file: TempFile,
}
impl MtForm {
async fn build_email(&self) -> PreEscaped<std::string::String> {
html! {
(DOCTYPE)
meta charset="utf-8";
html {
head {
title { (self.first_name.0) " " (self.last_name.0) " signed up for mission trip!" }
style {
"table { border-collapse: collapse; width: 100% }"
"td, th { padding: 8px }"
"td { text-align: left; width: 70%; word-wrap: break-word }"
"th { text-align: right; border-right: 1px solid #ddd }"
"tr { border-bottom: 1px solid #ddd }"
"h1 { text-align: center }"
}
}
body {
h1 { "Mission trip self for " (self.first_name.0) " " (self.last_name.0) "!" }
hr;
table {
tr {
th { "Name" }
td { (self.first_name.0) " " (self.last_name.0) }
}
tr {
th { "Parent" }
td { (self.parent_first_name.0) (self.parent_last_name.0) }
}
tr {
th { "Birthdate" }
td { (self.birthdate.0) }
}
tr {
th { "Gender" }
td { (self.gender.0) }
}
tr {
th { "Street" }
td { (self.street.0) }
}
tr {
th { "City" }
td { (self.city.0) }
}
tr {
th { "State" }
td { (self.state.0) }
}
tr {
th { "Zip" }
td { (self.zip.0) }
}
tr {
th { "Phone" }
td { (self.cellphone.0) }
}
tr {
th { "Parent Phone" }
td { (self.parentphone.0) }
}
tr {
th { "Email" }
td { (self.email.0) }
}
tr {
th { "Parent Email" }
td { (self.parentemail.0) }
}
tr {
th { "School" }
td { (self.school.0) }
}
tr {
th { "Grade" }
td { (self.grade.0) }
}
tr {
th { "Pastor" }
td { (self.pastor_first_name.0) (self.pastor_last_name.0) }
}
tr {
th { "Church Attendance" }
td { (self.church_attendance.0) }
}
tr {
th { "TFC Group" }
td { (self.tfc_group.0) }
}
tr {
th { "T-Shirt Size" }
td { (self.shirt.0) }
}
tr {
th { "Trip Choice" }
td { (self.trip.0) }
}
tr {
th { "Extra Trip Notes" }
td { (self.trip_notes.0) }
}
tr {
th { "Relationship with Jesus" }
td { (self.relationship_with_jesus.0) }
}
tr {
th { "Testimony" }
td { (self.testimony.0) }
}
tr {
th { "Involvement with TFC or Youth Group" }
td { (self.involvement_with_group.0) }
}
tr {
th { "Reasons for trip choice" }
td { (self.reasons.0) }
}
tr {
th { "Strengths" }
td { (self.strengths.0) }
}
tr {
th { "Weaknesses" }
td { (self.weaknesses.0) }
}
tr {
th { "Previous Trips" }
td { (self.previous_trip_info.0) }
}
tr {
th { "Attitude Torward Work" }
td { (self.attitude.0) }
}
tr {
th { "Other Relevant Info" }
td { (self.relevant_notes.0) }
}
tr {
th { "Final Agreement" }
td { (self.final_agreement.0) }
}
tr {
th { "Registration" }
td { (self.registration.0) }
}
}
}
}
}
}
} }
#[post("/mt-form")] #[post("/mt-form")]
pub async fn mt_form(MultipartForm(form): MultipartForm<MtForm>) -> HttpResponse { pub async fn mt_form(MultipartForm(form): MultipartForm<MtForm>) -> HttpResponse {
let first = form let first = form.first_name.clone();
.first_name let last = form.last_name.clone();
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
let last = form
.last_name
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
let email_subject = format!("{} {} signed up for mission trip!", first, last); let email_subject = format!("{} {} signed up for mission trip!", first, last);
let filename_noext = format!("{}_{}", first, last); let filename_noext = format!("{}_{}", first, last);
let parent = format!(
"{} {}",
form.parent_first_name
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone(),
form.parent_last_name
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone()
);
let birthdate = form
.birthdate
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
let gender = form
.gender
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
let street = form
.street
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
let city = form
.city
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
let state = form
.state
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
let zip = form.zip.as_ref().unwrap_or(&Text(0)).0;
let cellphone = form
.cellphone
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
let parentphone = form
.parentphone
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
let email = form
.email
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
let parentemail = form
.parentemail
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
let school = form
.school
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
let grade = form
.grade
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
let pastor = format!(
"{} {}",
form.pastor_first_name
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone(),
form.pastor_last_name
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone()
);
let church_attendance = form
.church_attendance
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
let tfc_group = form
.tfc_group
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
let shirt = form
.shirt
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
let trip = form
.trip
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
let trip_notes = form
.trip_notes
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
let relationship = form
.relationship_with_jesus
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
let testimony = form
.testimony
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
let involvement = form
.involvement_with_group
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
let reasons = form
.reasons
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
let strengths = form
.strengths
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
let weaknesses = form
.weaknesses
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
let previous_trip = form
.previous_trip_info
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
let attitude = form
.attitude
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
let relevant = form
.relevant_notes
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
let final_agreement = form
.final_agreement
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
let registration = form
.registration
.as_ref()
.unwrap_or(&Text(String::from("")))
.0
.clone();
log::info!("{first} {last} signed up for mission trip!"); log::info!("{first} {last} signed up for mission trip!");
let email = markup::new! { let email = form.build_email().await;
@markup::doctype() let mut path = String::from("");
html {
head {
title { @format!("{} {} signed up for mission trip!", first, last) }
style {
"table { border-collapse: collapse; width: 100% }"
"td, th { padding: 8px }"
"td { text-align: left; width: 70%; word-wrap: break-word }"
"th { text-align: right; border-right: 1px solid #ddd }"
"tr { border-bottom: 1px solid #ddd }"
"h1 { text-align: center }"
}
}
body {
h1 { @format!("Mission trip form for {} {}!", first, last) }
hr;
table {
tr {
th { "Name" }
td { @format!("{} {}", first, last) }
}
tr {
th { "Parent" }
td { @parent }
}
tr {
th { "Birthdate" }
td { @birthdate }
}
tr {
th { "Gender" }
td { @gender }
}
tr {
th { "Street" }
td { @street }
}
tr {
th { "City" }
td { @city }
}
tr {
th { "State" }
td { @state }
}
tr {
th { "Zip" }
td { @zip }
}
tr {
th { "Phone" }
td { @cellphone }
}
tr {
th { "Parent Phone" }
td { @parentphone }
}
tr {
th { "Email" }
td { @email }
}
tr {
th { "Parent Email" }
td { @parentemail }
}
tr {
th { "School" }
td { @school }
}
tr {
th { "Grade" }
td { @grade }
}
tr {
th { "Pastor" }
td { @pastor }
}
tr {
th { "Church Attendance" }
td { @church_attendance }
}
tr {
th { "TFC Group" }
td { @tfc_group }
}
tr {
th { "T-Shirt Size" }
td { @shirt }
}
tr {
th { "Trip Choice" }
td { @trip }
}
tr {
th { "Extra Trip Notes" }
td { @trip_notes }
}
tr {
th { "Relationship with Jesus" }
td { @relationship }
}
tr {
th { "Testimony" }
td { @testimony }
}
tr {
th { "Involvement with TFC or Youth Group" }
td { @involvement }
}
tr {
th { "Reasons for trip choice" }
td { @reasons }
}
tr {
th { "Strengths" }
td { @strengths }
}
tr {
th { "Weaknesses" }
td { @weaknesses }
}
tr {
th { "Previous Trips" }
td { @previous_trip }
}
tr {
th { "Attitude Torward Work" }
td { @attitude }
}
tr {
th { "Other Relevant Info" }
td { @relevant }
}
tr {
th { "Final Agreement" }
td { @final_agreement }
}
tr {
th { "Registration" }
td { @registration }
}
}
}
}
};
let mut path: Option<String> = Some(String::from(""));
let mut file_exists = false; let mut file_exists = false;
let mut filename = String::from(""); let mut filename = String::from("");
log::info!("{:?}", file_exists); info!("{:?}", file_exists);
if let Some(f) = form.file { if let Some(file) = form.file.file_name {
if let Some(file) = f.file_name { if let Some(ext) = file.rsplit('.').next() {
if let Some(ext) = file.rsplit('.').next() { filename = format!("{}.{}", filename_noext, ext);
filename = format!("{}.{}", filename_noext, ext); path = format!("./tmp/{}.{}", filename_noext, ext);
path = Some(format!("./tmp/{}.{}", filename_noext, ext)); } else {
} else { path = format!("./tmp/{}", file);
path = Some(format!("./tmp/{}", file)); }
} // let path = format!("./tmp/{}", file);
// let path = format!("./tmp/{}", file); info!("saving to {}", path);
log::info!("saving to {}", path.clone().unwrap()); match form.file.file.persist(&path) {
match f.file.persist(path.clone().unwrap()) { Ok(f) => {
Ok(f) => { info!("{:?}", f);
log::info!("{:?}", f); if f.metadata().unwrap().len() > 0 {
if f.metadata().unwrap().len() > 0 { file_exists = true;
file_exists = true;
}
} }
Err(e) => log::info!("{:?}: Probably a missing image", e),
} }
Err(e) => log::info!("{:?}: Probably a missing image", e),
} }
} }
let multi = if file_exists { let multi = if file_exists {
let filebody = fs::read(path.clone().unwrap_or_default()); let filebody = fs::read(path);
let content_type = ContentType::parse("image/jpg").unwrap(); let content_type = ContentType::parse("image/jpg").unwrap();
let attachment = Attachment::new(filename).body(filebody.unwrap(), content_type); let attachment = Attachment::new(filename).body(filebody.unwrap(), content_type);
log::info!("{:?}", attachment); info!("{:?}", attachment);
MultiPart::mixed() MultiPart::mixed()
.singlepart(SinglePart::html(email.to_string())) .singlepart(SinglePart::html(email.into_string()))
.singlepart(attachment) .singlepart(attachment)
} else { } else {
MultiPart::alternative_plain_html(String::from("Testing"), email.to_string()) MultiPart::alternative_plain_html(String::from("Testing"), email.into_string())
}; };
if let Ok(m) = Message::builder() if let Ok(m) = Message::builder()
@ -466,21 +277,9 @@ pub async fn mt_form(MultipartForm(form): MultipartForm<MtForm>) -> HttpResponse
.subject(email_subject) .subject(email_subject)
.multipart(multi) .multipart(multi)
{ {
let sender = SmtpTransport::relay("mail.tfcconnection.org") let _ = crate::email::send_email(m).await;
.ok()
.unwrap()
.credentials(Credentials::new(
"no-reply@mail.tfcconnection.org".to_owned(),
"r9f36mNZFtiW4f".to_owned(),
))
.authentication(vec![Mechanism::Plain])
.build();
match sender.send(&m) {
Ok(res) => log::info!("{:?}", res),
Err(e) => log::info!("{e}"),
}
} else { } else {
log::info!("Email incorrect"); error!("Email incorrect");
} }
HttpResponse::Ok().body("thankyou") HttpResponse::Ok().body("thankyou")

27
src/email.rs Normal file
View file

@ -0,0 +1,27 @@
use color_eyre::Result;
use lettre::{
transport::smtp::authentication::{Credentials, Mechanism},
Message, SmtpTransport, Transport,
};
use tracing::{error, info};
pub async fn send_email(message: Message) -> Result<()> {
let sender = SmtpTransport::relay("mail.tfcconnection.org")
.ok()
.unwrap()
.credentials(Credentials::new(
"no-reply@mail.tfcconnection.org".to_owned(),
"r9f36mNZFtiW4f".to_owned(),
))
.authentication(vec![Mechanism::Plain])
.build();
match sender.send(&message) {
Ok(res) => info!(
"Successfully sent email to server with this response: {:?}",
res
),
Err(e) => error!("There was an error sending the email: {e}"),
}
Ok(())
}

5
src/main.rs
View file

@ -1,4 +1,5 @@
mod api; mod api;
pub mod email;
use actix_files::Files; use actix_files::Files;
use actix_multipart::form::tempfile::TempFileConfig; use actix_multipart::form::tempfile::TempFileConfig;
@ -28,7 +29,9 @@ impl RootSpanBuilder for DomainRootSpanBuilder {
let info = request.connection_info(); let info = request.connection_info();
let ip = info.realip_remote_addr().expect("hi"); let ip = info.realip_remote_addr().expect("hi");
let location = request.path(); let location = request.path();
info!(?method, ip, location); if location.ends_with("/") {
info!(?method, ip, location);
}
tracing_actix_web::root_span!(request) tracing_actix_web::root_span!(request)
// let client_id: &str = todo!("Somehow extract it from the authorization header"); // let client_id: &str = todo!("Somehow extract it from the authorization header");