From e38854c7db0fe6f006304d7f638b6aa190fc2d87 Mon Sep 17 00:00:00 2001 From: mrw1593 Date: Mon, 15 May 2023 21:42:47 -0400 Subject: Started on frontend --- src/resources/languages.rs | 67 ++++++++++++++++++++++++++++++++++++++++++++++ src/resources/mod.rs | 4 +++ src/resources/scripts.rs | 37 +++++++++++++++++++++++++ src/resources/style.rs | 53 ++++++++++++++++++++++++++++++++++++ src/resources/templates.rs | 59 ++++++++++++++++++++++++++++++++++++++++ 5 files changed, 220 insertions(+) create mode 100644 src/resources/languages.rs create mode 100644 src/resources/mod.rs create mode 100644 src/resources/scripts.rs create mode 100644 src/resources/style.rs create mode 100644 src/resources/templates.rs (limited to 'src/resources') diff --git a/src/resources/languages.rs b/src/resources/languages.rs new file mode 100644 index 0000000..8ef7553 --- /dev/null +++ b/src/resources/languages.rs @@ -0,0 +1,67 @@ +use std::collections::HashMap; +use std::path::PathBuf; + +use actix_web::{get, web, HttpResponse, Scope}; +use exun::RawUnexpected; +use ini::{Ini, Properties}; +use raise::yeet; +use unic_langid::subtags::Language; + +#[derive(Debug, Clone, PartialEq)] +pub struct Translations { + languages: HashMap, +} + +pub fn initialize() -> Result { + let mut translations = Translations { + languages: HashMap::new(), + }; + translations.refresh()?; + Ok(translations) +} + +impl Translations { + pub fn languages(&self) -> Box<[Language]> { + self.languages.keys().cloned().collect() + } + + pub fn get_message(&self, language: Language, key: &str) -> Option { + Some(self.languages.get(&language)?.get(key)?.to_owned()) + } + + pub fn refresh(&mut self) -> Result<(), RawUnexpected> { + let mut languages = HashMap::with_capacity(1); + for entry in PathBuf::from("static/languages").read_dir()? { + let entry = entry?; + if entry.file_type()?.is_dir() { + continue; + } + + let path = entry.path(); + let path = path.to_string_lossy(); + let Some(language) = path.as_bytes().get(0..2) else { yeet!(RawUnexpected::msg(format!("{} not long enough to be a language name", path))) }; + let language = Language::from_bytes(language)?; + let messages = Ini::load_from_file(entry.path())?.general_section().clone(); + + languages.insert(language, messages); + } + + self.languages = languages; + Ok(()) + } +} + +#[get("")] +pub async fn all_languages(translations: web::Data) -> HttpResponse { + HttpResponse::Ok().json( + translations + .languages() + .into_iter() + .map(|l| l.as_str()) + .collect::>(), + ) +} + +pub fn languages() -> Scope { + web::scope("/languages").service(all_languages) +} diff --git a/src/resources/mod.rs b/src/resources/mod.rs new file mode 100644 index 0000000..9251d2c --- /dev/null +++ b/src/resources/mod.rs @@ -0,0 +1,4 @@ +pub mod languages; +pub mod scripts; +pub mod style; +pub mod templates; diff --git a/src/resources/scripts.rs b/src/resources/scripts.rs new file mode 100644 index 0000000..3e2d869 --- /dev/null +++ b/src/resources/scripts.rs @@ -0,0 +1,37 @@ +use std::path::{Path, PathBuf}; + +use actix_web::{get, http::StatusCode, web, HttpResponse, ResponseError}; +use exun::{Expect, ResultErrorExt}; +use raise::yeet; +use serde::Serialize; +use thiserror::Error; + +#[derive(Debug, Clone, Error, Serialize)] +pub enum LoadScriptError { + #[error("The requested script does not exist")] + FileNotFound(Box), +} + +impl ResponseError for LoadScriptError { + fn status_code(&self) -> StatusCode { + match self { + Self::FileNotFound(..) => StatusCode::NOT_FOUND, + } + } +} + +fn load(script: &str) -> Result> { + let path = PathBuf::from(format!("static/scripts/{}.js", script)); + if !path.exists() { + yeet!(LoadScriptError::FileNotFound(path.into()).into()); + } + let js = std::fs::read_to_string(format!("static/scripts/{}.js", script)).unexpect()?; + Ok(js) +} + +#[get("/{script}.js")] +pub async fn get_js(script: web::Path>) -> Result { + let js = load(&script).map_err(|e| e.unwrap())?; + let response = HttpResponse::Ok().content_type("text/javascript").body(js); + Ok(response) +} diff --git a/src/resources/style.rs b/src/resources/style.rs new file mode 100644 index 0000000..2777a82 --- /dev/null +++ b/src/resources/style.rs @@ -0,0 +1,53 @@ +use std::path::{Path, PathBuf}; + +use actix_web::{get, http::StatusCode, web, HttpResponse, ResponseError}; +use exun::{Expect, ResultErrorExt}; +use grass::OutputStyle; +use raise::yeet; +use serde::Serialize; +use thiserror::Error; + +fn output_style() -> OutputStyle { + if cfg!(debug_assertions) { + OutputStyle::Expanded + } else { + OutputStyle::Compressed + } +} + +fn options() -> grass::Options<'static> { + grass::Options::default() + .load_path("static/style") + .style(output_style()) +} + +#[derive(Debug, Clone, Error, Serialize)] +pub enum LoadStyleError { + #[error("The requested stylesheet was not found")] + FileNotFound(Box), +} + +impl ResponseError for LoadStyleError { + fn status_code(&self) -> StatusCode { + match self { + Self::FileNotFound(..) => StatusCode::NOT_FOUND, + } + } +} + +pub fn load(stylesheet: &str) -> Result> { + let options = options(); + let path = PathBuf::from(format!("static/style/{}.scss", stylesheet)); + if !path.exists() { + yeet!(LoadStyleError::FileNotFound(path.into()).into()); + } + let css = grass::from_path(format!("static/style/{}.scss", stylesheet), &options).unexpect()?; + Ok(css) +} + +#[get("/{stylesheet}.css")] +pub async fn get_css(stylesheet: web::Path>) -> Result { + let css = load(&stylesheet).map_err(|e| e.unwrap())?; + let response = HttpResponse::Ok().content_type("text/css").body(css); + Ok(response) +} diff --git a/src/resources/templates.rs b/src/resources/templates.rs new file mode 100644 index 0000000..43d6b67 --- /dev/null +++ b/src/resources/templates.rs @@ -0,0 +1,59 @@ +use std::collections::HashMap; + +use exun::{RawUnexpected, ResultErrorExt}; +use raise::yeet; +use tera::{Function, Tera, Value}; +use unic_langid::subtags::Language; + +use super::languages; + +fn make_lang(language: Language) -> impl Function { + Box::new(move |_: &HashMap| -> tera::Result { + Ok(Value::String(language.to_string())) + }) +} + +fn make_msg(language: Language, translations: languages::Translations) -> impl Function { + Box::new( + move |args: &HashMap| -> tera::Result { + let Some(key) = args.get("key") else { yeet!("No parameter 'key' provided".into()) }; + let Some(key) = key.as_str() else { yeet!(format!("{} is not a string", key).into()) }; + let Some(value) = translations.get_message(language, key) else { yeet!(format!("{} does not exist", key).into()) }; + Ok(Value::String(value)) + }, + ) +} + +fn make_base_url() -> impl Function { + Box::new(|_: &HashMap| Ok(Value::String("foo".to_string()))) +} + +fn extend_tera( + tera: &Tera, + language: Language, + translations: languages::Translations, +) -> Result { + let mut new_tera = initialize()?; + new_tera.extend(tera)?; + new_tera.register_function("lang", make_lang(language)); + new_tera.register_function("msg", make_msg(language, translations)); + new_tera.register_function("baseUrl", make_base_url()); + Ok(new_tera) +} + +pub fn initialize() -> tera::Result { + let tera = Tera::new("static/templates/*")?; + Ok(tera) +} + +pub fn login_page( + tera: &Tera, + language: Language, + mut translations: languages::Translations, +) -> Result { + translations.refresh()?; + let mut tera = extend_tera(tera, language, translations)?; + tera.full_reload()?; + let context = tera::Context::new(); + tera.render("login.html", &context).unexpect() +} -- cgit v1.2.3