Started on frontend

5 files changed, 220 insertions, 0 deletions

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<Language, Properties>,
+}
+
+pub fn initialize() -> Result<Translations, RawUnexpected> {
+	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<String> {
+		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<Translations>) -> HttpResponse {
+	HttpResponse::Ok().json(
+		translations
+			.languages()
+			.into_iter()
+			.map(|l| l.as_str())
+			.collect::<Box<[&str]>>(),
+	)
+}
+
+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<Path>),
+}
+
+impl ResponseError for LoadScriptError {
+	fn status_code(&self) -> StatusCode {
+		match self {
+			Self::FileNotFound(..) => StatusCode::NOT_FOUND,
+		}
+	}
+}
+
+fn load(script: &str) -> Result<String, Expect<LoadScriptError>> {
+	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<Box<str>>) -> Result<HttpResponse, LoadScriptError> {
+	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<Path>),
+}
+
+impl ResponseError for LoadStyleError {
+	fn status_code(&self) -> StatusCode {
+		match self {
+			Self::FileNotFound(..) => StatusCode::NOT_FOUND,
+		}
+	}
+}
+
+pub fn load(stylesheet: &str) -> Result<String, Expect<LoadStyleError>> {
+	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<Box<str>>) -> Result<HttpResponse, LoadStyleError> {
+	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<String, Value>| -> tera::Result<Value> {
+		Ok(Value::String(language.to_string()))
+	})
+}
+
+fn make_msg(language: Language, translations: languages::Translations) -> impl Function {
+	Box::new(
+		move |args: &HashMap<String, Value>| -> tera::Result<Value> {
+			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<String, Value>| Ok(Value::String("foo".to_string())))
+}
+
+fn extend_tera(
+	tera: &Tera,
+	language: Language,
+	translations: languages::Translations,
+) -> Result<Tera, RawUnexpected> {
+	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<Tera> {
+	let tera = Tera::new("static/templates/*")?;
+	Ok(tera)
+}
+
+pub fn login_page(
+	tera: &Tera,
+	language: Language,
+	mut translations: languages::Translations,
+) -> Result<String, RawUnexpected> {
+	translations.refresh()?;
+	let mut tera = extend_tera(tera, language, translations)?;
+	tera.full_reload()?;
+	let context = tera::Context::new();
+	tera.render("login.html", &context).unexpect()
+}