reformulate 0.4.0

reformulate is a standalone server that listens for web form data submissions.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

mod mailer;
use mailer::{default_subject_line, send_email};
mod spam;
use spam::{check_for_spam, check_stop_forum_spam};
mod strings;
use env_logger::Env;
use serde::Deserialize;
use strings::{REJECT_MSG, SUCCESS_MSG, VERSION, WELCOME_MSG};
use validator::Validate;
mod mail_template;

use actix_web::{
    error, get,
    middleware::Logger,
    post,
    web::{self, Redirect},
    App, Either, HttpResponse, HttpServer, Responder,
};

fn redirect_default() -> bool {
    false
}
/// Form submission
#[derive(Debug, Deserialize, Validate)]
struct Submission {
    #[serde(alias = "fullname")]
    #[serde(alias = "fullName")]
    full_name: String,
    #[validate(email(
        message = "Invalid email address provided. Please check email and try again."
    ))]
    email: String,
    #[serde(default = "default_subject_line")]
    subject: String,
    message: String,
    #[serde(alias = "site")]
    #[serde(alias = "website")]
    #[serde(alias = "location")]
    from_site: String,
    #[serde(default = "redirect_default")]
    redirect: bool,
}

type FormSubmission = Either<web::Json<Submission>, web::Form<Submission>>;
type FormResponse = Either<HttpResponse, Redirect>;

#[get("/")]
async fn hello() -> impl Responder {
    HttpResponse::Ok().body(format!("{WELCOME_MSG}\n{VERSION}"))
}

#[post("/")]
async fn submit(form: FormSubmission) -> Result<FormResponse, error::Error> {
    let (validated, email, full_name, subject, message, from_site, redirect) = match form {
        Either::Left(submission) => (
            submission.validate(),
            submission.email.trim().to_owned(),
            submission.full_name.to_owned(),
            submission.subject.to_owned(),
            submission.message.to_owned(),
            submission.from_site.to_owned(),
            submission.redirect,
        ),
        Either::Right(submission) => (
            submission.validate(),
            submission.email.trim().to_owned(),
            submission.full_name.to_owned(),
            submission.subject.to_owned(),
            submission.message.to_owned(),
            submission.from_site.to_owned(),
            submission.redirect,
        ),
    };

    if let Err(error) = validated {
        Err(error::ErrorBadRequest(error.to_string()))
    } else {
        check_for_spam(&message, REJECT_MSG)?;
        check_stop_forum_spam(&email, REJECT_MSG).await?;

        send_email(&email, &full_name, &subject, &message, &from_site)
            .map(|_| {
                if redirect {
                    Either::Right(Redirect::to(from_site.to_string()))
                } else {
                    Either::Left(HttpResponse::Ok().body(SUCCESS_MSG))
                }
            })
            .map_err(error::ErrorBadRequest)
    }
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    env_logger::init_from_env(Env::default().default_filter_or("info"));

    HttpServer::new(|| {
        App::new()
            .wrap(Logger::default())
            .wrap(Logger::new("%a %{User-Agent}i"))
            .service(hello)
            .service(submit)
    })
    .bind(("0.0.0.0", 8000))?
    .run()
    .await
}