diff options
Diffstat (limited to '')
| -rw-r--r-- | src/actix_ructe.rs | 10 | ||||
| -rw-r--r-- | src/build.rs | 10 | ||||
| -rw-r--r-- | src/main.rs | 221 |
3 files changed, 241 insertions, 0 deletions
diff --git a/src/actix_ructe.rs b/src/actix_ructe.rs new file mode 100644 index 0000000..e6ba0db --- /dev/null +++ b/src/actix_ructe.rs @@ -0,0 +1,10 @@ +macro_rules! render { + ($template:path) => {{ + let mut buf = Vec::new(); + $template(&mut buf).map(|()| buf) + }}; + ($template:path, $($arg:expr),* $(,)*) => {{ + let mut buf = Vec::new(); + $template(&mut buf, $($arg),*).map(|()| buf) + }}; +} diff --git a/src/build.rs b/src/build.rs new file mode 100644 index 0000000..46d590c --- /dev/null +++ b/src/build.rs @@ -0,0 +1,10 @@ +use ructe::{Result, Ructe}; + +fn main() -> Result<()> { + let mut ructe = Ructe::from_env()?; + ructe + .statics()? + .add_files("./static")? + .add_sass_file("./style.scss")?; + ructe.compile_templates("templates") +} diff --git a/src/main.rs b/src/main.rs new file mode 100644 index 0000000..eb7f0e8 --- /dev/null +++ b/src/main.rs @@ -0,0 +1,221 @@ +#[macro_use] +mod actix_ructe; + +use std::time::{Duration, SystemTime}; + +use actix_web::body::{BoxBody, EitherBody, MessageBody}; +use actix_web::dev::ServiceResponse; +use actix_web::http::{header, StatusCode}; +use actix_web::middleware::{ErrorHandlerResponse, ErrorHandlers}; +use actix_web::{get, post, web, App, HttpResponse, HttpServer, Responder, ResponseError}; +use bcrypt::{hash, verify, DEFAULT_COST}; +use serde::Deserialize; +use sqlx::{postgres::PgPoolOptions, Pool, Postgres}; +use templates::statics::StaticFile; + +static FAR: Duration = Duration::from_secs(180 * 24 * 60 * 60); + +type Result<T> = std::result::Result<T, PinussyError>; + +#[derive(Clone)] +struct Pinussy { + db: Pool<Postgres>, +} + +#[actix_web::main] +async fn main() -> std::io::Result<()> { + let pool = PgPoolOptions::new() + .max_connections(5) + .connect("postgres://pinussy:pinussy@localhost/pinussy") + .await + .unwrap(); + + sqlx::migrate!("./migrations").run(&pool).await.unwrap(); + + let pinussy = Pinussy { db: pool }; + + HttpServer::new(move || { + App::new() + .wrap( + ErrorHandlers::new() + .handler(StatusCode::NOT_FOUND, render_404) + .handler(StatusCode::INTERNAL_SERVER_ERROR, render_500), + ) + .app_data(web::Data::new(pinussy.clone())) + .service(web::resource("/static/{filename}").to(static_file)) + .service(home) + .service(get_login) + .service(post_login) + .service(get_signup) + .service(post_signup) + .service(get_users) + // .service(get_pins) + // .service(post_pin) + // .service(get_pin) + // .service(post_board) + // .service(get_board) + }) + .bind(("127.0.0.1", 8080))? + .run() + .await +} + +#[get("/")] +async fn home() -> HttpResponse { + HttpResponse::Ok().body("Hello world!") +} + +#[get("/signup")] +async fn get_signup() -> HttpResponse { + HttpResponse::Ok().body(render!(templates::signup_html).unwrap()) +} + +#[derive(Deserialize)] +struct SignupForm { + username: String, + password: String, +} + +#[post("/signup")] +async fn post_signup( + state: web::Data<Pinussy>, + form: web::Form<SignupForm>, +) -> Result<HttpResponse> { + let password_hash = hash(&form.password, DEFAULT_COST)?; + sqlx::query!( + "insert into users(username, password) values ($1, $2)", + &form.username, + password_hash + ) + .execute(&state.db) + .await?; + Ok(HttpResponse::Ok().body(render!(templates::signup_html).unwrap())) +} + +#[get("/login")] +async fn get_login() -> HttpResponse { + HttpResponse::Ok().body(render!(templates::login_html).unwrap()) +} + +#[derive(Deserialize)] +struct LoginForm { + username: String, + password: String, + rememberme: bool, +} + +#[post("/login")] +async fn post_login(form: web::Form<LoginForm>) -> Result<HttpResponse> { + Ok(HttpResponse::Ok().body(render!(templates::login_html).unwrap())) +} + +#[derive(sqlx::Type)] +#[sqlx(type_name = "privacy", rename_all = "lowercase")] +enum Privacy { + Private, + Unlisted, + Public, +} + +#[derive(sqlx::FromRow)] +pub struct User { + id: i32, + username: String, + password: String, + email: Option<String>, + bio: Option<String>, + site: Option<String>, + privacy: Privacy, + admin: bool, +} + +#[get("/users")] +async fn get_users(state: web::Data<Pinussy>) -> Result<HttpResponse> { + let users: Vec<User> = sqlx::query_as("select * from users") + .fetch_all(&state.db) + .await + .unwrap(); + println!("lol"); + Ok(HttpResponse::Ok().body(render!(templates::users_html, users).unwrap())) +} + +async fn static_file(path: web::Path<String>) -> HttpResponse { + let name = &path.into_inner(); + if let Some(data) = StaticFile::get(name) { + let far_expires = SystemTime::now() + FAR; + HttpResponse::Ok() + .insert_header(header::Expires(far_expires.into())) + .insert_header(header::ContentType(data.mime.clone())) + .body(data.content) + } else { + HttpResponse::NotFound() + .reason("No such static file.") + .finish() + } +} + +fn render_404(res: ServiceResponse) -> actix_web::Result<ErrorHandlerResponse<BoxBody>> { + Ok(error_response( + res, + StatusCode::NOT_FOUND, + "The resource you requested can't be found.", + )) +} + +fn render_500(res: ServiceResponse) -> actix_web::Result<ErrorHandlerResponse<BoxBody>> { + Ok(error_response( + res, + StatusCode::INTERNAL_SERVER_ERROR, + "Sorry, Something went wrong. This is probably not your fault.", + )) +} + +fn error_response( + mut res: ServiceResponse, + status_code: StatusCode, + message: &str, +) -> ErrorHandlerResponse<BoxBody> { + res.headers_mut().insert( + header::CONTENT_TYPE, + header::HeaderValue::from_static(mime::TEXT_HTML_UTF_8.as_ref()), + ); + ErrorHandlerResponse::Response(res.map_body(|_head, _body| { + EitherBody::right(MessageBody::boxed( + render!(templates::error_html, status_code, message).unwrap(), + )) + })) +} + +#[derive(Debug)] +enum PinussyError { + Database(sqlx::Error), + Bcrypt, +} + +impl From<sqlx::Error> for PinussyError { + fn from(e: sqlx::Error) -> Self { + Self::Database(e) + } +} + +impl From<bcrypt::BcryptError> for PinussyError { + fn from(e: bcrypt::BcryptError) -> Self { + Self::Bcrypt + } +} + +impl std::fmt::Display for PinussyError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "{:?}", self) + } +} + +impl std::error::Error for PinussyError {} + +impl ResponseError for PinussyError { + fn error_response(&self) -> HttpResponse<BoxBody> { + HttpResponse::new(self.status_code()) + } +} + +include!(concat!(env!("OUT_DIR"), "/templates.rs")); |