- // Left gradient chunk
-
-
-
-
-
-
-
-
-
- // Right gradient chunk
-
-
- // Left gradient chunk
-
-
-
- }
- .into_any()
- } else {
- view! {
-
- // Background color gradient
-
-
-
- // Right gradient chunk
-
-
-
-
-
-
- }
- .into_any()
+pub fn StyledHeader(#[prop(into)] items: Signal
-
-
+ //
}
}
/// Function header without styling
#[component]
-pub fn Header(items: HeaderItems) -> impl IntoView {
- let HeaderItems { left, middle, right } = items;
+pub fn Header(#[prop(into)] items: Signal
+
+
// Left side of header
}
}
#[component]
-fn Items(items: Vec
-
// Expanding space in the middle
-
// Right side of header
-
{items}
}
}
diff --git a/crates/ascend/src/components/problem.rs b/crates/ascend/src/components/problem.rs
new file mode 100644
index 0000000..dd462c6
--- /dev/null
+++ b/crates/ascend/src/components/problem.rs
@@ -0,0 +1,51 @@
+use crate::models::HoldRole;
+use crate::models::{self};
+use leptos::prelude::*;
+
+#[component]
+#[tracing::instrument(skip_all)]
+pub fn Problem(#[prop(into)] dim: Signal
+
+ }
+}
+
+#[component]
+#[tracing::instrument(skip_all)]
+fn Hold(#[prop(into)] role: Signal{holds}
+
-
}
}
#[component]
-fn Ready(data: InitialData) -> impl leptos::IntoView {
+fn Ready(wall: models::Wall) -> impl IntoView {
tracing::debug!("ready");
let mut holds = vec![];
- for hold in data.wall.holds.values().cloned() {
- holds.push(view! {
-
-
+ "Loading..." }
+ }>
+ {move || Suspend::new(async move {
+ let wall = wall.await;
+ view! {
+
+ {move || -> Result<_, ServerFnError> {
+ let wall = wall.clone()?;
+ Ok(view! {
+ }
+ })}
+
@@ -68,7 +95,7 @@ fn Ready(data: InitialData) -> impl leptos::IntoView {
}
#[component]
-fn Hold(hold: models::Hold) -> impl leptos::IntoView {
+fn Hold(wall_uid: models::WallUid, hold: models::Hold) -> impl IntoView {
let hold_position = hold.position;
let file_input_ref = NodeRef::::new();
@@ -82,7 +109,7 @@ fn Hold(hold: models::Hold) -> impl leptos::IntoView {
let hold = Signal::derive(move || {
let refreshed = upload.value().get().map(Result::unwrap);
- refreshed.unwrap_or(hold.clone())
+ refreshed.map(RonEncoded::into_inner).unwrap_or(hold.clone())
});
// Callback to handle file selection
@@ -108,7 +135,11 @@ fn Hold(hold: models::Hold) -> impl leptos::IntoView {
file_contents,
};
- upload.dispatch(SetImage { hold_position, image });
+ upload.dispatch(SetImage {
+ wall_uid,
+ hold_position,
+ image,
+ });
}) as Box);
file_reader.set_onload(Some(on_load.as_ref().unchecked_ref()));
@@ -117,8 +148,8 @@ fn Hold(hold: models::Hold) -> impl leptos::IntoView {
let img = move || {
hold.read().image.as_ref().map(|img| {
- let src = format!("/files/holds/{}", img.filename);
- view! { 
}
+ let srcset = img.srcset();
+ view! { ![]()
}
})
};
@@ -138,51 +169,77 @@ fn Hold(hold: models::Hold) -> impl leptos::IntoView {
}
}
-#[derive(Debug, Serialize, Deserialize, Clone)]
-pub struct InitialData {
- wall: Wall,
-}
-
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Image {
file_name: String,
file_contents: Vec,
}
-#[server]
-async fn load_initial_data() -> Result, ServerFnError> {
- use crate::server::state::State;
+#[server(
+ name = SetImage,
+ input = Cbor,
+ output = Ron,
+)]
+#[tracing::instrument(skip(image), err)]
+async fn set_image(wall_uid: WallUid, hold_position: HoldPosition, image: Image) -> Result, ServerFnError> {
+ use image::ImageDecoder;
+ use std::collections::BTreeMap;
+ use std::path::Path;
- let state = expect_context::();
-
- let wall = state.persistent.with(|s| s.wall.clone()).await;
- Ok(RonCodec::new(InitialData { wall }))
-}
-
-#[server(name = SetImage, input = Cbor)]
-#[tracing::instrument(skip(image))]
-async fn set_image(hold_position: HoldPosition, image: Image) -> Result {
tracing::info!("Setting image, {}, {} bytes", image.file_name, image.file_contents.len());
- use crate::server::state::State;
+ let db = expect_context::();
- // TODO: Fix file extension presumption, and possibly use uuid
- let filename = format!("row{}_col{}.jpg", hold_position.row, hold_position.col);
- tokio::fs::create_dir_all("datastore/public/holds").await?;
- tokio::fs::write(format!("datastore/public/holds/{filename}"), image.file_contents).await?;
+ let image = tokio::task::spawn_blocking(move || -> Result {
+ let mut decoder = image::ImageReader::new(std::io::Cursor::new(image.file_contents))
+ .with_guessed_format()?
+ .into_decoder()?;
+ let orientation = decoder.orientation()?;
+ let mut img = image::DynamicImage::from_decoder(decoder)?;
+ img.apply_orientation(orientation);
- let state = expect_context::();
- state
- .persistent
- .update(|s| {
- if let Some(hold) = s.wall.holds.get_mut(&hold_position) {
- hold.image = Some(models::Image { filename });
- }
+ let holds_dir = Path::new("datastore/public/holds");
+ std::fs::create_dir_all(holds_dir)?;
+
+ let targets = [(50, 50), (150, 150), (300, 300), (400, 400)];
+
+ let uid = models::ImageUid::create();
+ let mut resolutions = BTreeMap::new();
+ for (width, height) in targets {
+ let resized = img.resize_to_fill(width, height, image::imageops::FilterType::Lanczos3);
+
+ let filename = format!("hold_row{}_col{}_{width}x{height}_{uid}.webp", hold_position.row, hold_position.col);
+ let path = holds_dir.join(&filename);
+ let mut file = std::fs::OpenOptions::new().write(true).append(false).create_new(true).open(&path)?;
+ resized.write_to(&mut file, image::ImageFormat::WebP)?;
+
+ let res = models::ImageResolution {
+ width: width.into(),
+ height: height.into(),
+ };
+ resolutions.insert(res, models::ImageFilename { filename });
+ }
+
+ // TODO: Clean up old image?
+
+ Ok(models::Image { uid, resolutions })
+ })
+ .await??;
+
+ let hold = db
+ .write(move |txn| {
+ use redb::ReadableTable;
+ let mut walls = txn.open_table(crate::server::db::current::TABLE_WALLS)?;
+ let mut wall = walls.get(wall_uid)?.expect("todo").value();
+
+ let hold = wall.holds.get_mut(&hold_position).expect("hold");
+ hold.image = Some(image);
+ let hold = hold.clone();
+ walls.insert(wall_uid, wall)?;
+
+ Ok(hold)
})
.await?;
- // Return updated hold
- let hold = state.persistent.with(|s| s.wall.holds.get(&hold_position).cloned().unwrap()).await;
-
- Ok(hold)
+ Ok(RonEncoded::new(hold))
}
diff --git a/crates/ascend/src/pages/routes.rs b/crates/ascend/src/pages/routes.rs
index 94208aa..4d8b4e7 100644
--- a/crates/ascend/src/pages/routes.rs
+++ b/crates/ascend/src/pages/routes.rs
@@ -1,18 +1,35 @@
-use crate::codec::ron::RonCodec;
+use crate::components;
use crate::components::header::HeaderItem;
use crate::components::header::HeaderItems;
use crate::components::header::StyledHeader;
+use crate::models;
+use crate::models::WallUid;
+use leptos::Params;
use leptos::prelude::*;
-use serde::Deserialize;
-use serde::Serialize;
-use std::ops::Deref;
+use leptos_router::params::Params;
+
+#[derive(Params, PartialEq, Clone)]
+struct RouteParams {
+ // Is never None
+ wall_uid: Option,
+}
#[component]
-pub fn Routes() -> impl leptos::IntoView {
- let load = async move {
- // TODO: What to do about this unwrap?
- load_initial_data().await.unwrap()
- };
+#[tracing::instrument(skip_all)]
+pub fn Routes() -> impl IntoView {
+ tracing::debug!("Enter");
+
+ let params = leptos_router::hooks::use_params::();
+ let wall_uid = Signal::derive(move || {
+ params
+ .get()
+ .expect("gets wall_uid from URL")
+ .wall_uid
+ .expect("wall_uid param is never None")
+ });
+
+ let wall = crate::resources::wall_by_uid(wall_uid);
+ let problems = crate::resources::problems_for_wall(wall_uid);
let header_items = HeaderItems {
left: vec![HeaderItem {
@@ -26,27 +43,70 @@ pub fn Routes() -> impl leptos::IntoView {
right: vec![],
};
- leptos::view! {
+ let suspend = move || {
+ Suspend::new(async move {
+ let wall = wall.await;
+ let problems = problems.await;
+
+ let v = move || -> Result<_, ServerFnError> {
+ let wall = wall.clone()?;
+ let problems = problems.clone()?;
+
+ let wall_dimensions = models::WallDimensions {
+ rows: wall.rows,
+ cols: wall.cols,
+ };
+ let problems_sample = move || problems.iter().take(10).cloned().collect::>();
+
+ Ok(view! {
+ {v} }
+ })
+ };
+
+ view! {
, #[prop(into)] problem: Signal) -> impl IntoView {
+ tracing::debug!("Enter");
+
+ view! {
+ ::new());
let onclick = move |_mouse_event| {
- import_from_mini_moonboard.dispatch(ImportFromMiniMoonboard {});
+ import_from_mini_moonboard.dispatch(ImportFromMiniMoonboard { wall_uid });
};
view! {
@@ -55,31 +115,18 @@ fn Ready(data: InitialData) -> impl leptos::IntoView {
}
}
-#[derive(Debug, Serialize, Deserialize, Clone)]
-pub struct InitialData {}
-
-#[server]
-async fn load_initial_data() -> Result, ServerFnError> {
- // use crate::server::state::State;
- // let state = expect_context::();
-
- // TODO: provide info on current routes set
-
- Ok(RonCodec::new(InitialData {}))
-}
-
#[server(name = ImportFromMiniMoonboard)]
#[tracing::instrument]
-async fn import_from_mini_moonboard() -> Result<(), ServerFnError> {
+async fn import_from_mini_moonboard(wall_uid: WallUid) -> Result<(), ServerFnError> {
use crate::server::config::Config;
- use crate::server::state::State;
+ use crate::server::db::Database;
tracing::info!("Importing mini moonboard problems");
let config = expect_context::();
- let state = expect_context::();
+ let db = expect_context::();
- crate::server::operations::import_mini_moonboard_problems(&config, &state).await?;
+ crate::server::operations::import_mini_moonboard_problems(&config, db, wall_uid).await?;
// TODO: Return information about what was done
Ok(())
diff --git a/crates/ascend/src/pages/wall.rs b/crates/ascend/src/pages/wall.rs
index 3624947..5930e84 100644
--- a/crates/ascend/src/pages/wall.rs
+++ b/crates/ascend/src/pages/wall.rs
@@ -1,24 +1,62 @@
-use crate::codec::ron::RonCodec;
+use crate::codec::ron::RonEncoded;
use crate::components::button::Button;
use crate::components::header::HeaderItem;
use crate::components::header::HeaderItems;
use crate::components::header::StyledHeader;
use crate::models;
use crate::models::HoldRole;
+use leptos::Params;
use leptos::prelude::*;
-use leptos::reactive::graph::ReactiveNode;
-use serde::Deserialize;
-use serde::Serialize;
-use std::ops::Deref;
+use leptos_router::params::Params;
+
+#[derive(Params, PartialEq, Clone)]
+struct RouteParams {
+ wall_uid: Option,
+}
#[component]
-pub fn Wall() -> impl leptos::IntoView {
- let load = async move {
- // TODO: What to do about this unwrap?
- load_initial_data().await.unwrap()
- };
+#[tracing::instrument(skip_all)]
+pub fn Wall() -> impl IntoView {
+ tracing::debug!("Enter");
- let header_items = HeaderItems {
+ let params = leptos_router::hooks::use_params::();
+ let wall_uid = Signal::derive(move || {
+ params
+ .get()
+ .expect("gets wall_uid from URL")
+ .wall_uid
+ .expect("wall_uid param is never None")
+ });
+
+ let wall = crate::resources::wall_by_uid(wall_uid);
+
+ let problem_action = Action::new(move |&(wall_uid, problem_uid): &(models::WallUid, models::ProblemUid)| async move {
+ tracing::info!("fetching");
+ crate::server_functions::get_problem(wall_uid, problem_uid)
+ .await
+ .map(RonEncoded::into_inner)
+ });
+ let problem_signal = Signal::derive(move || {
+ let v = problem_action.value().read_only().get();
+ tracing::debug!("val: {:?}", v);
+ v.and_then(Result::ok)
+ });
+
+ Effect::new(move |_prev_value| {
+ problem_action.value().write_only().set(None);
+ match wall.get() {
+ Some(Ok(wall)) => {
+ if let Some(problem_uid) = wall.random_problem() {
+ tracing::debug!("dispatching from effect");
+ problem_action.dispatch((wall.uid, problem_uid));
+ }
+ }
+ Some(Err(_err)) => {}
+ None => {}
+ }
+ });
+
+ let header_items = move || HeaderItems {
left: vec![],
middle: vec![HeaderItem {
text: "ASCEND".to_string(),
@@ -27,67 +65,87 @@ pub fn Wall() -> impl leptos::IntoView {
right: vec![
HeaderItem {
text: "Routes".to_string(),
- link: Some("/wall/routes".to_string()),
+ link: Some(format!("/wall/{}/routes", wall_uid.get())),
},
HeaderItem {
text: "Holds".to_string(),
- link: Some("/wall/edit".to_string()),
+ link: Some(format!("/wall/{}/edit", wall_uid.get())),
},
],
};
leptos::view! {
);
- let problem_fetcher = LocalResource::new(move || async move {
- tracing::info!("Loading random problem");
- let problem = get_random_problem().await.expect("cannot get random problem");
- if problem.is_none() {
- tracing::info!("No problem returned by server in response to request for random problem");
- }
- current_problem_writer.set(problem.into_inner());
- });
+#[tracing::instrument(skip_all)]
+fn Grid(wall: models::Wall, problem: Signal>) -> impl IntoView {
+ tracing::debug!("Enter");
let mut cells = vec![];
- for (&hold_position, hold) in &data.wall.holds {
- let role = move || current_problem.get().and_then(|problem| problem.holds.get(&hold_position).copied());
+ for (&hold_position, hold) in &wall.holds {
+ let role = move || problem.get().and_then(|p| p.holds.get(&hold_position).copied());
let role = Signal::derive(role);
-
let cell = view! {
+
+ })
+ };
+
+ view! {
-
-
+ {move || view! { "loading" }>{suspend}
{move || problem.get().name.clone()}
+ } +} + +#[component] +#[tracing::instrument(skip_all)] +fn Import(wall_uid: WallUid) -> impl IntoView { tracing::debug!("ready"); let import_from_mini_moonboard = Action::from(ServerAction::
-
}
}
#[component]
-fn Ready(data: InitialData) -> impl leptos::IntoView {
- tracing::debug!("ready");
-
- let (current_problem, current_problem_writer) = signal(None::
-
-
+ "Loading..." }
+ }>
+ {move || Suspend::new(async move {
+ tracing::info!("executing Suspend future");
+ let wall = wall.await?;
+ let v = view! {
+
+
+ };
+ Ok::<_, ServerFnError>(v)
+ })}
+
+
+
+
+
+
+ + {move || problem_signal.get().map(|p| p.name.clone())} +
++ {move || problem_signal.get().map(|p| p.set_by.clone())} +
+
- // Render the wall
- >) -> impl leptos::IntoView {
+#[tracing::instrument(skip_all)]
+fn Hold(hold: models::Hold, role: Signal>) -> impl IntoView {
+ tracing::trace!("Enter");
let class = move || {
let role_classes = match role.get() {
Some(HoldRole::Start) => Some("outline outline-offset-2 outline-green-500"),
@@ -106,45 +164,10 @@ fn Hold(hold: models::Hold, #[prop(into)] role: Signal>) -> imp
};
let img = hold.image.map(|img| {
- let src = format!("/files/holds/{}", img.filename);
- view! { }
+ let srcset = img.srcset();
+ view! { ![]()
}
});
+ tracing::trace!("view");
view! { , ServerFnError> {
- use crate::server::state::State;
-
- let state = expect_context::();
-
- let wall = state.persistent.with(|s| s.wall.clone()).await;
- Ok(RonCodec::new(InitialData { wall }))
-}
-
-#[server]
-async fn get_random_problem() -> Result>, ServerFnError> {
- use crate::server::state::State;
- use rand::seq::IteratorRandom;
-
- let state = expect_context::();
-
- let problem = state
- .persistent
- .with(|s| {
- let problems = &s.problems.problems;
- let rng = &mut rand::thread_rng();
- problems.iter().choose(rng).cloned()
- })
- .await;
-
- tracing::debug!("Returning randomized problem: {problem:?}");
-
- Ok(RonCodec::new(problem))
-}
diff --git a/crates/ascend/src/server.rs b/crates/ascend/src/server.rs
index c28e5e8..a870fab 100644
--- a/crates/ascend/src/server.rs
+++ b/crates/ascend/src/server.rs
@@ -4,21 +4,16 @@ use cli::Cli;
use config::Config;
use confik::Configuration;
use confik::EnvSource;
-use persistence::Persistent;
-use state::PersistentState;
-use state::State;
use std::path::Path;
-use std::path::PathBuf;
use tower_http::services::ServeDir;
use tracing::level_filters::LevelFilter;
use type_toppings::ResultExt;
mod cli;
pub mod config;
+pub mod db;
mod migrations;
pub mod operations;
-pub mod persistence;
-pub mod state;
pub const STATE_FILE: &str = "datastore/private/state.ron";
@@ -43,12 +38,6 @@ pub async fn main() {
match cli.command {
Command::Serve => serve(cli).await.unwrap_or_report(),
- Command::ResetState => {
- let s = PersistentState::default();
- let p = Path::new(STATE_FILE);
- tracing::info!("Resetting state to default: {}", p.display());
- Persistent::persist(p, &s).await.unwrap_or_report();
- }
}
}
@@ -57,32 +46,34 @@ async fn serve(cli: Cli) -> Result<(), Error> {
use crate::app::App;
use crate::app::shell;
use axum::Router;
- use leptos::prelude::*;
use leptos_axum::LeptosRoutes;
use leptos_axum::generate_route_list;
- migrations::run_migrations().await;
+ tracing::debug!("Creating DB");
+ let db = db::Database::create()?;
+
+ migrations::run_migrations(&db).await.map_err(Error::Migration)?;
// Setting get_configuration(None) means we'll be using cargo-leptos's env values
// For deployment these variables are:
//
// Alternately a file can be specified such as Some("Cargo.toml")
// The file would need to be included with the executable when moved to deployment
- let leptos_conf_file = get_configuration(None).unwrap_or_report();
+ let leptos_conf_file = leptos::config::get_configuration(None).unwrap_or_report();
let leptos_options = leptos_conf_file.leptos_options;
let addr = leptos_options.site_addr;
let routes = generate_route_list(App);
let config = load_config(cli)?;
- let server_state = load_state().await?;
+ tracing::debug!("Creating app router");
let app = Router::new()
.leptos_routes_with_context(
&leptos_options,
routes,
move || {
- provide_context(server_state.clone());
- provide_context(config.clone())
+ leptos::prelude::provide_context::(db.clone());
+ leptos::prelude::provide_context::(config.clone())
},
{
let leptos_options = leptos_options.clone();
@@ -93,7 +84,9 @@ async fn serve(cli: Cli) -> Result<(), Error> {
.fallback(leptos_axum::file_and_error_handler(shell))
.with_state(leptos_options);
+ tracing::debug!("Binding TCP listener");
let listener = tokio::net::TcpListener::bind(&addr).await?;
+
tracing::info!("Listening on http://{addr}");
axum::serve(listener, app.into_make_service()).await?;
@@ -106,22 +99,6 @@ fn file_service(path: impl AsRef) -> ServeDir {
ServeDir::new(path)
}
-#[tracing::instrument]
-async fn load_state() -> Result {
- tracing::info!("Loading state");
-
- let p = PathBuf::from(STATE_FILE);
-
- let persistent = if p.try_exists()? {
- Persistent::::load(&p).await?
- } else {
- tracing::info!("No state found at {STATE_FILE}, creating default state");
- Persistent::::new(PersistentState::default(), p)
- };
-
- Ok(State { persistent })
-}
-
fn load_config(cli: Cli) -> Result {
let mut builder = config::Config::builder();
if cli
@@ -139,11 +116,14 @@ fn load_config(cli: Cli) -> Result {
#[display("Server crash: {_variant}")]
pub enum Error {
Io(std::io::Error),
- Persistence(persistence::Error),
+
Parser(moonboard_parser::Error),
#[display("Failed migration")]
+ #[from(ignore)]
Migration(Box),
Confik(confik::Error),
+
+ Database(redb::Error),
}
diff --git a/crates/ascend/src/server/cli.rs b/crates/ascend/src/server/cli.rs
index 4b25089..3405709 100644
--- a/crates/ascend/src/server/cli.rs
+++ b/crates/ascend/src/server/cli.rs
@@ -15,9 +15,6 @@ pub struct Cli {
pub enum Command {
#[default]
Serve,
-
- /// Resets state, replacing it with defaults
- ResetState,
}
fn default_config_location() -> camino::Utf8PathBuf {
diff --git a/crates/ascend/src/server/db.rs b/crates/ascend/src/server/db.rs
new file mode 100644
index 0000000..ddc03b8
--- /dev/null
+++ b/crates/ascend/src/server/db.rs
@@ -0,0 +1,107 @@
+use bincode::Bincode;
+use redb::ReadTransaction;
+use redb::TableDefinition;
+use redb::WriteTransaction;
+use serde::Deserialize;
+use serde::Serialize;
+use std::path::PathBuf;
+use std::sync::Arc;
+
+mod bincode;
+
+const DB_FILE: &str = "datastore/private/ascend.redb";
+
+#[derive(Debug, Clone)]
+pub struct Database {
+ db: Arc,
+}
+
+impl Database {
+ #[tracing::instrument(skip_all, err)]
+ pub fn create() -> Result {
+ let file = PathBuf::from(DB_FILE);
+
+ // Create parent dirs
+ if let Some(parent_dir) = file.parent() {
+ std::fs::create_dir_all(parent_dir)?;
+ }
+
+ let db = redb::Database::create(file)?;
+ Ok(Self { db: Arc::new(db) })
+ }
+
+ #[tracing::instrument(skip_all, err)]
+ pub async fn read(&self, f: impl FnOnce(&'_ ReadTransaction) -> Result) -> Result {
+ tokio::task::block_in_place(|| {
+ let dbtx = self.db.begin_read()?;
+ f(&dbtx)
+ })
+ }
+
+ #[tracing::instrument(skip_all, err)]
+ pub async fn write(&self, f: impl FnOnce(&'_ WriteTransaction) -> Result) -> Result {
+ tokio::task::block_in_place(|| {
+ let dbtx = self.db.begin_write()?;
+ let res = f(&dbtx)?;
+ dbtx.commit()?;
+ Ok(res)
+ })
+ }
+
+ #[tracing::instrument(skip_all)]
+ pub async fn get_version(&self) -> Result, DatabaseOperationError> {
+ self.read(|dbtx| dbtx.open_table(TABLE_VERSION)?.get(()).map(|o| o.map(|v| v.value())).map_err(Into::into))
+ .await
+ }
+}
+
+#[derive(Debug, derive_more::Error, derive_more::Display, derive_more::From)]
+#[display("DB operation error: {_variant}")]
+pub enum DatabaseOperationError {
+ #[display("redb error")]
+ #[from(forward)]
+ Redb(#[error(source)] redb::Error),
+
+ #[from(ignore)]
+ Custom(#[error(source)] Box),
+}
+impl DatabaseOperationError {
+ pub fn custom(err: impl std::error::Error + Send + Sync + 'static) -> Self {
+ Self::Custom(Box::new(err))
+ }
+}
+
+pub const TABLE_VERSION: TableDefinition<(), Bincode> = TableDefinition::new("version");
+#[derive(Serialize, Deserialize, Debug, derive_more::Display)]
+#[display("{version}")]
+pub struct Version {
+ pub version: u64,
+}
+impl Version {
+ pub fn current() -> Version {
+ Version { version: current::VERSION }
+ }
+}
+
+pub use v2 as current;
+
+pub mod v2 {
+ use crate::models;
+ use crate::server::db::bincode::Bincode;
+ use redb::TableDefinition;
+
+ pub const VERSION: u64 = 2;
+
+ pub const TABLE_ROOT: TableDefinition<(), Bincode> = TableDefinition::new("root");
+ pub const TABLE_WALLS: TableDefinition, Bincode> = TableDefinition::new("walls");
+ pub const TABLE_PROBLEMS: TableDefinition, Bincode> =
+ TableDefinition::new("problems");
+}
+
+pub mod v1 {
+ use crate::models;
+ use crate::server::db::bincode::Bincode;
+ use redb::TableDefinition;
+
+ pub const TABLE_ROOT: TableDefinition<(), Bincode> = TableDefinition::new("root");
+}
diff --git a/crates/ascend/src/server/db/bincode.rs b/crates/ascend/src/server/db/bincode.rs
new file mode 100644
index 0000000..0b3529e
--- /dev/null
+++ b/crates/ascend/src/server/db/bincode.rs
@@ -0,0 +1,52 @@
+use redb::Value;
+
+/// Wrapper type to handle keys and values using bincode serialization
+#[derive(Debug)]
+pub struct Bincode(pub T);
+
+impl Value for Bincode
+where
+ T: std::fmt::Debug + serde::Serialize + for<'a> serde::Deserialize<'a>,
+{
+ type SelfType<'a>
+ = T
+ where
+ Self: 'a;
+
+ type AsBytes<'a>
+ = Vec
+ where
+ Self: 'a;
+
+ fn fixed_width() -> Option {
+ None
+ }
+
+ fn from_bytes<'a>(data: &'a [u8]) -> Self::SelfType<'a>
+ where
+ Self: 'a,
+ {
+ bincode::deserialize(data).unwrap()
+ }
+
+ fn as_bytes<'a, 'b: 'a>(value: &'a Self::SelfType<'b>) -> Self::AsBytes<'a>
+ where
+ Self: 'a,
+ Self: 'b,
+ {
+ bincode::serialize(value).unwrap()
+ }
+
+ fn type_name() -> redb::TypeName {
+ redb::TypeName::new(&format!("Bincode<{}>", std::any::type_name::()))
+ }
+}
+
+impl redb::Key for Bincode
+where
+ T: std::fmt::Debug + serde::Serialize + serde::de::DeserializeOwned + Ord,
+{
+ fn compare(data1: &[u8], data2: &[u8]) -> std::cmp::Ordering {
+ Self::from_bytes(data1).cmp(&Self::from_bytes(data2))
+ }
+}
diff --git a/crates/ascend/src/server/migrations.rs b/crates/ascend/src/server/migrations.rs
index 7c8e26f..5ddec99 100644
--- a/crates/ascend/src/server/migrations.rs
+++ b/crates/ascend/src/server/migrations.rs
@@ -1,20 +1,218 @@
-use crate::server::STATE_FILE;
+use super::db;
+use super::db::Database;
+use crate::models;
+use image::ImageDecoder;
+use redb::ReadableTable;
+use redb::ReadableTableMetadata;
+use std::collections::BTreeMap;
+use std::collections::BTreeSet;
+use std::path::Path;
use std::path::PathBuf;
use type_toppings::ResultExt;
-#[tracing::instrument]
-pub async fn run_migrations() {
- migrate_state_file().await;
+#[tracing::instrument(skip_all, err)]
+pub async fn run_migrations(db: &Database) -> Result<(), Box> {
+ migrate_from_ron_to_redb(db).await?;
+ init_at_current_version(db).await?;
+ migrate_to_v2(db).await?;
+ Ok(())
}
-/// State file moved to datastore/private
-#[tracing::instrument]
-async fn migrate_state_file() {
- let m = PathBuf::from("state.ron");
- if m.try_exists().expect_or_report_with(|| format!("Failed to read {}", m.display())) {
- tracing::warn!("MIGRATING STATE FILE");
- let p = PathBuf::from(STATE_FILE);
- tokio::fs::create_dir_all(p.parent().unwrap()).await.unwrap_or_report();
- tokio::fs::rename(m, &p).await.unwrap_or_report();
+/// Use redb DB instead of Ron state file
+#[tracing::instrument(skip_all, err)]
+async fn migrate_from_ron_to_redb(db: &Database) -> Result<(), Box> {
+ let ron_state_file_path = PathBuf::from(super::STATE_FILE);
+
+ if ron_state_file_path
+ .try_exists()
+ .expect_or_report_with(|| format!("Failed to read {}", ron_state_file_path.display()))
+ {
+ tracing::warn!("MIGRATING");
+
+ let ron_state: models::v1::PersistentState = {
+ let content = tokio::fs::read_to_string(&ron_state_file_path).await?;
+ ron::from_str(&content)?
+ };
+
+ db.write(|txn| {
+ let mut version_table = txn.open_table(db::TABLE_VERSION)?;
+ assert!(version_table.is_empty()?);
+ version_table.insert((), db::Version { version: 1 })?;
+
+ let mut root_table = txn.open_table(db::v1::TABLE_ROOT)?;
+ assert!(root_table.is_empty()?);
+
+ let persistent_state = models::v1::PersistentState {
+ version: ron_state.version,
+ wall: ron_state.wall,
+ problems: ron_state.problems,
+ };
+
+ root_table.insert((), persistent_state)?;
+ Ok(())
+ })
+ .await?;
+
+ tracing::info!("Removing ron state");
+ tokio::fs::remove_file(ron_state_file_path).await?;
}
+
+ Ok(())
+}
+
+// TODO: Move out, is not really a migration
+#[tracing::instrument(skip_all, err)]
+async fn init_at_current_version(db: &Database) -> Result<(), Box> {
+ db.write(|txn| {
+ let mut version_table = txn.open_table(db::TABLE_VERSION)?;
+ let is_missing_version = version_table.get(())?.is_none();
+ if is_missing_version {
+ let v = db::Version::current();
+ tracing::warn!("INITIALIZING DATABASE AT VERSION {v}");
+ version_table.insert((), v)?;
+
+ // Root table
+ {
+ let mut table = txn.open_table(db::current::TABLE_ROOT)?;
+ assert!(table.is_empty()?);
+ table.insert((), models::Root { walls: BTreeSet::new() })?;
+ }
+
+ // Walls table
+ {
+ // Opening the table creates the table
+ let table = txn.open_table(db::current::TABLE_WALLS)?;
+ assert!(table.is_empty()?);
+ }
+
+ // Problems table
+ {
+ // Opening the table creates the table
+ let table = txn.open_table(db::current::TABLE_PROBLEMS)?;
+ assert!(table.is_empty()?);
+ }
+ }
+
+ Ok(())
+ })
+ .await?;
+
+ Ok(())
+}
+
+#[tracing::instrument(skip_all, err)]
+async fn migrate_to_v2(db: &Database) -> Result<(), Box> {
+ use super::db;
+
+ db.write(|txn| {
+ let mut version_table = txn.open_table(db::TABLE_VERSION)?;
+ let version = version_table.get(())?.unwrap().value().version;
+ if version == 1 {
+ tracing::warn!("MIGRATING");
+ version_table.insert((), db::Version { version: 2 })?;
+
+ let root_table_v1 = txn.open_table(db::v1::TABLE_ROOT)?;
+ let root_v1 = root_table_v1.get(())?.unwrap().value();
+ drop(root_table_v1);
+ txn.delete_table(db::v1::TABLE_ROOT)?;
+
+ let models::v1::PersistentState { version: _, wall, problems } = root_v1;
+
+ // we'll reimport them instead of a lossy conversion.
+ drop(problems);
+
+ let mut walls = BTreeSet::new();
+ let wall_uid = models::v2::WallUid(uuid::Uuid::new_v4());
+ let holds = wall
+ .holds
+ .into_iter()
+ .map(|(hold_position, hold)| -> Result<_, Box> {
+ let image = hold
+ .image
+ .map(|i| -> Result<_, Box> {
+ let holds_dir = Path::new("datastore/public/holds");
+
+ let p = holds_dir.join(i.filename);
+ tracing::info!("reading {}", p.display());
+ let file_contents = std::fs::read(p)?;
+
+ let mut decoder = image::ImageReader::new(std::io::Cursor::new(file_contents))
+ .with_guessed_format()?
+ .into_decoder()?;
+ let orientation = decoder.orientation()?;
+ let mut img = image::DynamicImage::from_decoder(decoder)?;
+ img.apply_orientation(orientation);
+
+ std::fs::create_dir_all(holds_dir)?;
+
+ let targets = [(50, 50), (150, 150), (300, 300), (400, 400)];
+
+ let uid = models::ImageUid::create();
+ let mut resolutions = BTreeMap::new();
+ for (width, height) in targets {
+ tracing::info!("resizing to {width}x{height}");
+ let resized = img.resize_to_fill(width, height, image::imageops::FilterType::Lanczos3);
+
+ let filename = format!("hold_row{}_col{}_{width}x{height}_{uid}.webp", hold_position.row, hold_position.col);
+ let path = holds_dir.join(&filename);
+ tracing::info!("opening {}", path.display());
+ let mut file = std::fs::OpenOptions::new().write(true).append(false).create_new(true).open(&path)?;
+ resized.write_to(&mut file, image::ImageFormat::WebP)?;
+
+ let res = models::ImageResolution {
+ width: width.into(),
+ height: height.into(),
+ };
+ resolutions.insert(res, models::ImageFilename { filename });
+ }
+
+ Ok(models::Image { uid, resolutions })
+ })
+ .transpose()?;
+
+ Ok((
+ models::v1::HoldPosition {
+ row: hold_position.row,
+ col: hold_position.col,
+ },
+ models::v2::Hold {
+ position: models::v1::HoldPosition {
+ row: hold.position.row,
+ col: hold.position.col,
+ },
+ image,
+ },
+ ))
+ })
+ .collect::>()
+ .unwrap();
+
+ let wall_v2 = models::v2::Wall {
+ uid: wall_uid,
+ rows: wall.rows,
+ cols: wall.cols,
+ holds,
+ problems: BTreeSet::new(),
+ };
+
+ walls.insert(wall_v2.uid);
+ let root_v2 = models::v2::Root { walls };
+
+ let mut root_table_v2 = txn.open_table(db::v2::TABLE_ROOT)?;
+ root_table_v2.insert((), root_v2)?;
+ drop(root_table_v2);
+
+ let mut walls_table = txn.open_table(db::v2::TABLE_WALLS)?;
+ walls_table.insert(wall_v2.uid, wall_v2)?;
+ drop(walls_table);
+
+ let problems_table = txn.open_table(db::v2::TABLE_PROBLEMS)?;
+ drop(problems_table);
+ }
+
+ Ok(())
+ })
+ .await?;
+
+ Ok(())
}
diff --git a/crates/ascend/src/server/operations.rs b/crates/ascend/src/server/operations.rs
index 54063ec..13e294b 100644
--- a/crates/ascend/src/server/operations.rs
+++ b/crates/ascend/src/server/operations.rs
@@ -1,15 +1,18 @@
//! Server lib module to host re-usable server operations.
+use super::db::Database;
+use crate::models;
use crate::models::HoldPosition;
use crate::models::HoldRole;
-use crate::models::Problem;
use crate::server::config::Config;
-use crate::server::persistence;
-use crate::server::state::State;
+use crate::server::db;
+use redb::ReadableTable;
use std::collections::BTreeMap;
-#[tracing::instrument(skip(state))]
-pub(crate) async fn import_mini_moonboard_problems(config: &Config, state: &State) -> Result<(), Error> {
+#[tracing::instrument(skip_all)]
+pub(crate) async fn import_mini_moonboard_problems(config: &Config, db: Database, wall_uid: models::WallUid) -> Result<(), Error> {
+ use moonboard_parser::mini_moonboard;
+
let mut problems = Vec::new();
let file_name = "problems Mini MoonBoard 2020 40.json";
@@ -17,10 +20,12 @@ pub(crate) async fn import_mini_moonboard_problems(config: &Config, state: &Stat
tracing::info!("Parsing mini moonboard problems from {file_path}");
- let mini_moonboard = moonboard_parser::mini_moonboard::parse(file_path.as_std_path()).await?;
- for problem in mini_moonboard.problems {
+ let set_by = "mini-mb-2020-parser";
+
+ let mini_moonboard = mini_moonboard::parse(file_path.as_std_path()).await?;
+ for mini_mb_problem in mini_moonboard.problems {
let mut holds = BTreeMap::::new();
- for mv in problem.moves {
+ for mv in mini_mb_problem.moves {
let row = mv.description.row();
let col = mv.description.column();
let hold_position = HoldPosition { row, col };
@@ -33,16 +38,44 @@ pub(crate) async fn import_mini_moonboard_problems(config: &Config, state: &Stat
};
holds.insert(hold_position, role);
}
- let route = Problem { holds };
- problems.push(route);
+
+ let name = mini_mb_problem.name;
+
+ let method = match mini_mb_problem.method {
+ mini_moonboard::Method::FeetFollowHands => models::Method::FeetFollowHands,
+ mini_moonboard::Method::Footless => models::Method::Footless,
+ mini_moonboard::Method::FootlessPlusKickboard => models::Method::FootlessPlusKickboard,
+ };
+
+ let problem_id = models::ProblemUid::create();
+
+ let problem = models::Problem {
+ uid: problem_id,
+ name,
+ set_by: set_by.to_owned(),
+ holds,
+ method,
+ date_added: chrono::Utc::now(),
+ };
+ problems.push(problem);
}
- state
- .persistent
- .update(|s| {
- s.problems.problems.extend(problems);
- })
- .await?;
+ db.write(|txn| {
+ let mut walls_table = txn.open_table(db::current::TABLE_WALLS)?;
+ let mut problems_table = txn.open_table(db::current::TABLE_PROBLEMS)?;
+
+ let mut wall = walls_table.get(wall_uid)?.unwrap().value();
+ wall.problems.extend(problems.iter().map(|p| p.uid));
+ walls_table.insert(wall_uid, wall)?;
+
+ for problem in problems {
+ let key = (wall_uid, problem.uid);
+ problems_table.insert(key, problem)?;
+ }
+
+ Ok(())
+ })
+ .await?;
Ok(())
}
@@ -50,5 +83,6 @@ pub(crate) async fn import_mini_moonboard_problems(config: &Config, state: &Stat
#[derive(Debug, derive_more::Error, derive_more::Display, derive_more::From)]
pub enum Error {
Parser(moonboard_parser::Error),
- Persistence(persistence::Error),
+ Tokio(tokio::task::JoinError),
+ DbOperation(crate::server::db::DatabaseOperationError),
}
diff --git a/crates/ascend/src/server/persistence.rs b/crates/ascend/src/server/persistence.rs
deleted file mode 100644
index 6104857..0000000
--- a/crates/ascend/src/server/persistence.rs
+++ /dev/null
@@ -1,134 +0,0 @@
-use serde::Serialize;
-use serde::de::DeserializeOwned;
-use std::path::Path;
-use std::path::PathBuf;
-use std::sync::Arc;
-use tokio::sync::Mutex;
-
-#[derive(Debug, Clone)]
-pub struct Persistent {
- state: Arc>,
- file_path: PathBuf,
-}
-
-impl Persistent {
- #[tracing::instrument(skip(state))]
- pub fn new(state: T, file_path: PathBuf) -> Self {
- Self {
- state: Arc::new(Mutex::new(state)),
- file_path,
- }
- }
-
- /// Instantiates state from file system
- #[tracing::instrument]
- pub async fn load(file_path: &Path) -> Result
- where
- T: DeserializeOwned,
- {
- let content = tokio::fs::read_to_string(&file_path).await.map_err(|source| Error::Read {
- file_path: file_path.to_owned(),
- source,
- })?;
-
- let t = ron::from_str(&content).map_err(|source| Error::Deserialize {
- file_path: file_path.to_owned(),
- source,
- })?;
-
- let persistent = Self {
- state: Arc::new(Mutex::new(t)),
- file_path: file_path.to_owned(),
- };
-
- Ok(persistent)
- }
-
- // TODO: This is pretty poor - clones the entire state on access
- /// Returns state
- #[tracing::instrument(skip(self))]
- pub async fn get(&self) -> T
- where
- T: Clone,
- {
- let state = self.state.lock().await;
- state.clone()
- }
-
- /// Returns state passed through given function
- #[tracing::instrument(skip_all)]
- pub async fn with(&self, f: F) -> R
- where
- F: FnOnce(&T) -> R,
- {
- let state = self.state.lock().await;
- f(&state)
- }
-
- /// Updates and persists state
- #[tracing::instrument(skip_all)]
- pub async fn update(&self, f: F) -> Result<(), Error>
- where
- F: FnOnce(&mut T),
- T: Serialize,
- {
- let mut state = self.state.lock().await;
- f(&mut state);
- Self::persist(&self.file_path, &state).await?;
- Ok(())
- }
-
- /// Sets and persists state
- #[tracing::instrument(skip_all)]
- pub async fn set(&self, new_state: T) -> Result<(), Error>
- where
- T: Serialize,
- {
- self.update(move |state| {
- *state = new_state;
- })
- .await
- }
-
- /// Persist.
- ///
- /// Implicitly called by `set` and `update`.
- #[tracing::instrument(skip_all, err)]
- pub async fn persist(file_path: &Path, state: &T) -> Result<(), Error>
- where
- T: Serialize,
- {
- tracing::debug!("Persisting state");
- let serialized = ron::ser::to_string_pretty(state, ron::ser::PrettyConfig::default()).map_err(|source| Error::Serialize { source })?;
- if let Some(parent) = file_path.parent() {
- tokio::fs::create_dir_all(parent).await.map_err(|source| Error::CreateDir {
- source,
- dir: parent.to_owned(),
- })?;
- }
- tokio::fs::write(file_path, serialized).await.map_err(|source| Error::Write {
- file_path: file_path.to_owned(),
- source,
- })?;
- Ok(())
- }
-}
-
-#[derive(Debug, derive_more::Error, derive_more::Display)]
-#[display("Persistent state error: {_variant}")]
-pub enum Error {
- #[display("Failed to read file: {}", file_path.display())]
- Read { file_path: PathBuf, source: std::io::Error },
-
- #[display("Failed to deserialize state from file: {}", file_path.display())]
- Deserialize { file_path: PathBuf, source: ron::error::SpannedError },
-
- #[display("Failed to serialize state")]
- Serialize { source: ron::Error },
-
- #[display("Failed to write file: {}", file_path.display())]
- Write { file_path: PathBuf, source: std::io::Error },
-
- #[display("Failed to create directory: {}", dir.display())]
- CreateDir { dir: PathBuf, source: std::io::Error },
-}
diff --git a/crates/ascend/src/server/state.rs b/crates/ascend/src/server/state.rs
deleted file mode 100644
index cdf6def..0000000
--- a/crates/ascend/src/server/state.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-//! Server state
-
-const STATE_VERSION: u64 = 1;
-
-use super::persistence::Persistent;
-use crate::models;
-use crate::models::Wall;
-use serde::Deserialize;
-use serde::Serialize;
-use smart_default::SmartDefault;
-use std::collections::BTreeSet;
-
-#[derive(Clone, Debug)]
-pub struct State {
- pub persistent: Persistent,
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug, SmartDefault)]
-pub struct PersistentState {
- /// State schema version
- #[default(STATE_VERSION)]
- pub version: u64,
-
- pub wall: Wall,
- pub problems: Problems,
-}
-
-#[derive(Serialize, Deserialize, Clone, Debug, Default)]
-pub struct Problems {
- pub problems: BTreeSet,
-}
diff --git a/crates/ascend/src/server_functions.rs b/crates/ascend/src/server_functions.rs
new file mode 100644
index 0000000..fa2249e
--- /dev/null
+++ b/crates/ascend/src/server_functions.rs
@@ -0,0 +1,162 @@
+use crate::codec::ron::Ron;
+use crate::codec::ron::RonEncoded;
+use crate::models;
+use leptos::server;
+use server_fn::ServerFnError;
+
+#[server(
+ input = Ron,
+ output = Ron,
+ custom = RonEncoded
+)]
+#[tracing::instrument(skip_all, err(Debug))]
+pub async fn get_walls() -> Result>, ServerFnError> {
+ use crate::server::db::Database;
+ use leptos::prelude::expect_context;
+ use redb::ReadableTable;
+ tracing::debug!("Enter");
+
+ let db = expect_context::();
+
+ let walls = db
+ .read(|txn| {
+ let walls_table = txn.open_table(crate::server::db::current::TABLE_WALLS)?;
+ let walls: Vec = walls_table.iter()?.map(|r| r.map(|(_, v)| v.value())).collect::>()?;
+ Ok(walls)
+ })
+ .await?;
+
+ tracing::debug!("Exit");
+
+ Ok(RonEncoded::new(walls))
+}
+
+#[server(
+ input = Ron,
+ output = Ron,
+ custom = RonEncoded
+)]
+#[tracing::instrument(skip_all, err(Debug))]
+pub(crate) async fn get_wall(wall_uid: models::WallUid) -> Result, ServerFnError> {
+ use crate::server::db::Database;
+ use crate::server::db::DatabaseOperationError;
+ use leptos::prelude::expect_context;
+ tracing::debug!("Enter");
+
+ #[derive(Debug, derive_more::Error, derive_more::Display)]
+ enum Error {
+ #[display("Wall not found: {_0:?}")]
+ NotFound(#[error(not(source))] models::WallUid),
+ }
+
+ let db = expect_context::();
+
+ let wall = db
+ .read(|txn| {
+ let walls_table = txn.open_table(crate::server::db::current::TABLE_WALLS)?;
+ let wall = walls_table
+ .get(wall_uid)?
+ .ok_or(Error::NotFound(wall_uid))
+ .map_err(DatabaseOperationError::custom)?
+ .value();
+ Ok(wall)
+ })
+ .await?;
+
+ tracing::debug!("ok");
+
+ Ok(RonEncoded::new(wall))
+}
+
+#[server(
+ input = Ron,
+ output = Ron,
+ custom = RonEncoded
+)]
+#[tracing::instrument(err(Debug))]
+pub(crate) async fn get_problems_for_wall(wall_uid: models::WallUid) -> Result>, ServerFnError> {
+ use crate::server::db::Database;
+ use crate::server::db::DatabaseOperationError;
+ use leptos::prelude::expect_context;
+ tracing::debug!("Enter");
+
+ #[derive(Debug, derive_more::Error, derive_more::Display, derive_more::From)]
+ enum Error {
+ #[display("Wall not found: {_0:?}")]
+ WallNotFound(#[error(not(source))] models::WallUid),
+
+ DatabaseOperation(DatabaseOperationError),
+ }
+
+ async fn inner(wall_uid: models::WallUid) -> Result, Error> {
+ let db = expect_context::();
+
+ let problems = db
+ .read(|txn| {
+ let walls_table = txn.open_table(crate::server::db::current::TABLE_WALLS)?;
+ tracing::debug!("getting wall");
+ let wall = walls_table
+ .get(wall_uid)?
+ .ok_or(Error::WallNotFound(wall_uid))
+ .map_err(DatabaseOperationError::custom)?
+ .value();
+ tracing::debug!("got wall");
+ drop(walls_table);
+
+ tracing::debug!("open problems table");
+ let problems_table = txn.open_table(crate::server::db::current::TABLE_PROBLEMS)?;
+ tracing::debug!("opened problems table");
+
+ let mut problems = Vec::new();
+ for &problem_uid in &wall.problems {
+ if let Some(problem) = problems_table.get((wall_uid, problem_uid))? {
+ problems.push(problem.value());
+ }
+ }
+ Ok(problems)
+ })
+ .await?;
+
+ Ok(problems)
+ }
+
+ let problems = inner(wall_uid).await.map_err(error_reporter::Report::new).map_err(ServerFnError::new)?;
+
+ tracing::debug!("ok");
+
+ Ok(RonEncoded::new(problems))
+}
+
+#[server(
+ input = Ron,
+ output = Ron,
+ custom = RonEncoded
+)]
+#[tracing::instrument(skip_all, err(Debug))]
+pub(crate) async fn get_problem(wall_uid: models::WallUid, problem_uid: models::ProblemUid) -> Result, ServerFnError> {
+ use crate::server::db::Database;
+ use crate::server::db::DatabaseOperationError;
+ use leptos::prelude::expect_context;
+ tracing::debug!("Enter");
+
+ #[derive(Debug, derive_more::Error, derive_more::Display)]
+ enum Error {
+ #[display("Problem not found: {_0:?}")]
+ NotFound(#[error(not(source))] models::ProblemUid),
+ }
+
+ let db = expect_context::();
+ let problem = db
+ .read(|txn| {
+ let table = txn.open_table(crate::server::db::current::TABLE_PROBLEMS)?;
+ let problem = table
+ .get((wall_uid, problem_uid))?
+ .ok_or(Error::NotFound(problem_uid))
+ .map_err(DatabaseOperationError::custom)?
+ .value();
+ Ok(problem)
+ })
+ .await?;
+
+ Ok(RonEncoded::new(problem))
+}
diff --git a/flake.lock b/flake.lock
index 62e8c5d..1cc7198 100644
--- a/flake.lock
+++ b/flake.lock
@@ -10,11 +10,11 @@
]
},
"locked": {
- "lastModified": 1729251766,
- "narHash": "sha256-/tOGBbFKgIii6L0VZdJ2MFdhzTt0BtEsAFbWITXeIxA=",
+ "lastModified": 1739793388,
+ "narHash": "sha256-mf0FJ7JJi5gTUFz0SyWF8bqqonxoFD2DG9D785uyYJM=",
"owner": "plul",
"repo": "basecamp",
- "rev": "aae7006aec576140aadf3fdea4ed7eae904dda14",
+ "rev": "f0f702ef6d5e8446eb8cd64e56fe1fe3cfbc677d",
"type": "github"
},
"original": {
@@ -25,11 +25,11 @@
},
"nixpkgs": {
"locked": {
- "lastModified": 1736420959,
- "narHash": "sha256-dMGNa5UwdtowEqQac+Dr0d2tFO/60ckVgdhZU9q2E2o=",
+ "lastModified": 1738797219,
+ "narHash": "sha256-KRwX9Z1XavpgeSDVM/THdFd6uH8rNm/6R+7kIbGa+2s=",
"owner": "NixOS",
"repo": "nixpkgs",
- "rev": "32af3611f6f05655ca166a0b1f47b57c762b5192",
+ "rev": "1da52dd49a127ad74486b135898da2cef8c62665",
"type": "github"
},
"original": {
@@ -53,11 +53,11 @@
]
},
"locked": {
- "lastModified": 1736649126,
- "narHash": "sha256-XCw5sv/ePsroqiF3lJM6Y2X9EhPdHeE47gr3Q8b0UQw=",
+ "lastModified": 1738895285,
+ "narHash": "sha256-4Ukr4reJfQ67c6QqIxbX47wnPIGxE8BXCAEPu1C3MFM=",
"owner": "oxalica",
"repo": "rust-overlay",
- "rev": "162ab0edc2936508470199b2e8e6c444a2535019",
+ "rev": "85f3aed5f4b8eb312c6e8fe8c476bac248aed75f",
"type": "github"
},
"original": {
diff --git a/flake.nix b/flake.nix
index 14bbba8..7d584f0 100644
--- a/flake.nix
+++ b/flake.nix
@@ -75,12 +75,7 @@
};
nixosModules.default =
- {
- config,
- pkgs,
- lib,
- ...
- }:
+ { config, lib, ... }:
let
cfg = config.services.ascend;
in
diff --git a/justfile b/justfile
index b625400..8c6650e 100644
--- a/justfile
+++ b/justfile
@@ -9,19 +9,19 @@ fmt:
bc-fmt
serve:
- RUST_LOG=debug RUST_BACKTRACE=1 cargo leptos watch -- serve
+ RUST_BACKTRACE=1 cargo leptos watch -- serve
-build-release:
- rm -rf dist
- mkdir dist
- cargo leptos build --release -vv
- cp target/release/ascend dist/
- cp -r target/site dist/
+# build-release:
+# rm -rf dist
+# mkdir dist
+# cargo leptos build --release -vv
+# cp target/release/ascend dist/
+# cp -r target/site dist/
-run-release:
- #!/usr/bin/env bash
- cd dist
- LEPTOS_SITE_ROOT="site" LEPTOS_SITE_ADDR="127.0.0.1:1337" ./ascend serve
+# run-release:
+# #!/usr/bin/env bash
+# cd dist
+# LEPTOS_SITE_ROOT="site" LEPTOS_SITE_ADDR="127.0.0.1:1337" ./ascend serve
reset-state:
cargo run --features ssr -- reset-state
@@ -42,3 +42,9 @@ prod-deploy:
prod-logs:
ssh 192.168.1.3 'journalctl --unit ascend.service'
+
+leptos-discord:
+ xdg-open "https://discord.com/channels/1031524867910148188/1031524868883218474"
+
+leptos-issues:
+ xdg-open "https://github.com/leptos-rs/leptos/issues"
diff --git a/todo.md b/todo.md
new file mode 100644
index 0000000..b048e86
--- /dev/null
+++ b/todo.md
@@ -0,0 +1,12 @@
+- save images with a uuid
+- downscale images
+- associate routes with wall
+- group routes by pattern (pattern family has shift/mirror variations)
+- generate pattern families of variations when importing problems
+- implement pattern challenge (start an "adventure mode" based on a pattern family)
+- Record problem success (enum: flash, send, no-send)
+- implement routes page to show all routes for a given wall
+- implement favorite routes feature
+- use wall id in URL.
+- decide on routes vs problems terminology
+- decide on holds vs wall-edit terminology
{cells}
-
-
-
-
+
}
}
#[component]
-fn Hold(hold: models::Hold, #[prop(into)] role: Signal
+ {cells}
+
{img}
}
}
-
-#[derive(Serialize, Deserialize, Clone)]
-pub struct InitialData {
- wall: models::Wall,
-}
-
-#[server]
-async fn load_initial_data() -> Result