();
+
+ let _ = use_infinite_scroll_with_options(
+ el,
+ move |_| async move {
+ if !res.loading().get() && res().is_some() {
+ set_page.update(|page| *page += 1);
+ }
+ res.and_then(move |_| {
+ set_all.update(|dat| dat.extend(res().unwrap().unwrap()));
+ });
+ /*if !res.loading().get() {
+ set_page.update(|page| *page += 1);
+ } else if res().is_some() {
+ set_all.update(|dat| dat.extend(res().unwrap().unwrap()));
+ // println!("{:?}", all().len())
+ }*/
+ },
+ UseInfiniteScrollOptions::default().distance(10.0),
+ );
+
+ view! {
+
"Home"
+
+ ().unwrap());
+ }
+
+ prop:value=size
+ type="range"
+ min="0.5"
+ max="2"
+ step="0.5"
+ value="1"
+ />
+
+
+
+ }
+}
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct PicStruct {
+ key: String,
+ width: i32,
+ height: i32,
+ url: String,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+struct Wallpaper {
+ file_name: String,
+ info: String,
+ date_added: String,
+ height: u64,
+ width: u64,
+ path: String,
+ thumbs: Vec
,
+}
+
+#[derive(Debug, Serialize)]
+struct Name<'a> {
+ first: &'a str,
+ last: &'a str,
+}
+
+#[derive(Debug, Serialize)]
+struct Person<'a> {
+ title: &'a str,
+ name: Name<'a>,
+ marketing: bool,
+}
+
+#[derive(Debug, Serialize)]
+struct Responsibility {
+ marketing: bool,
+}
+
+#[derive(Debug, Deserialize)]
+struct Record {
+ #[allow(dead_code)]
+ id: i32,
+}
+
+use std::env;
+
+#[server(GetPics, "/api")]
+pub async fn get_pics2(page: i32, size: f64) -> Result, ServerFnError> {
+ use image::GenericImageView;
+ use imageinfo::ImageInfo;
+ use std::fs;
+ use std::path::PathBuf;
+
+ let query = "
+ SELECT * FROM wallpapers LIMIT 10;
+ ";
+
+ let db = Surreal::new::("127.0.0.1:8000")
+ .await
+ .expect("Couldnt connect to db server");
+ // Select a specific namespace / database
+ db.use_ns("test")
+ .use_db("test")
+ .await
+ .expect("Couldnt find db");
+ //let papers: Vec = db.select("wallpapers").await.expect("Err");
+ //println!("{papers:#?}");
+
+ let mut res = db.query(query).await?;
+ let pap: Vec = res.take(0)?;
+ println!("{pap:#?}");
+
+ let mut pics = Vec::new();
+
+ let folder_path = "./public";
+
+ // Define the number of pictures per page
+ let pics_per_page = 10;
+
+ // Calculate the index to start from based on the page number
+ let start_index = (page) * pics_per_page;
+ let end_index = start_index + pics_per_page;
+
+ // manage a vector with all the image paths
+ let mut image_file_paths = Vec::::new();
+ for entry in fs::read_dir(folder_path)? {
+ let entry = entry?;
+ let file_path = entry.path();
+ let file_name_str = file_path.file_name().unwrap_or_default().to_str().unwrap();
+ if size == 0.5 {
+ //skip 1024 and 512
+ if file_name_str.contains("512x512") || file_name_str.contains("1024x1024") {
+ continue;
+ }
+ } else if size == 1.0 {
+ if file_name_str.contains("256x256") || file_name_str.contains("1024x1024") {
+ println!("sdfasdf");
+ continue;
+ }
+ } else if size == 1.5 {
+ if file_name_str.contains("256x256") || file_name_str.contains("512x512") {
+ continue;
+ }
+ }
+ image_file_paths.push(file_path.clone());
+ }
+
+ for (i, file_path) in image_file_paths.iter().enumerate() {
+ if file_path.is_file() {
+ if i < start_index as usize {
+ continue;
+ }
+ let file = std::fs::File::open(file_path)?;
+ let mut bufreader = std::io::BufReader::new(&file);
+ let exifreader = exif::Reader::new();
+ let exif = exifreader.read_from_container(&mut bufreader)?;
+ for f in exif.fields() {
+ println!(
+ "{} {} {}",
+ f.tag,
+ f.ifd_num,
+ f.display_value().with_unit(&exif)
+ );
+ }
+ let file_name = file_path.file_name().unwrap_or_default();
+ let file_name_str = file_name.to_str().unwrap();
+ // Check if the file has a supported image extension
+ if let Some(extension) = file_path.extension() {
+ if let Some(extension_str) = extension.to_str() {
+ if image::ImageFormat::from_extension(extension_str).is_some() {
+ // Process the image
+ let img = image::open(&file_path).expect("Failed to open image");
+ let (x, y) = img.dimensions();
+
+ pics.push(PicStruct {
+ key: file_name_str.to_string(), // Could not be unique if two images were created at exactly
+ // the same time
+ width: x as i32,
+ height: y as i32,
+ url: file_name.to_string_lossy().into(),
+ });
+ if i + 1 >= end_index as usize {
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // Send different picture resolutions depending on selected size
+ // sizes 256 512 1024
+
+ // Iterate over the entries in the folder
+ /*for (index, entry) in fs::read_dir(folder_path)
+ .expect("Failed to read directory")
+ .enumerate()
+ {
+ if let Ok(entry) = entry {
+ if index < start_index as usize {
+ // Skip pictures before the start index
+ continue;
+ }
+
+ let file_path = entry.path();
+ let file_name = file_path.file_name().unwrap_or_default();
+ let file_name_str = file_name.to_str().unwrap();
+ // Skip the wrong sizes
+ if size == 0.5 {
+ //skip 1024 and 512
+ if file_name_str.contains("512x512") || file_name_str.contains("1024x1024") {
+ continue;
+ }
+ } else if size == 1.0 {
+ if file_name_str.contains("256x256") || file_name_str.contains("1024x1024") {
+ continue;
+ }
+ } else if size == 1.5 {
+ if file_name_str.contains("256x256") || file_name_str.contains("512x512") {
+ continue;
+ }
+ }
+
+ // Check if the entry is a file
+ if file_path.is_file() {
+ // Check if the file has a supported image extension
+ if let Some(extension) = file_path.extension() {
+ if let Some(extension_str) = extension.to_str() {
+ if image::ImageFormat::from_extension(extension_str).is_some() {
+ // Process the image
+ let img = image::open(&file_path).expect("Failed to open image");
+ let (x, y) = img.dimensions();
+
+ pics.push(PicStruct {
+ key: file_name_str.to_string(), // Could not be unique if two images were created at exactly
+ // the same time
+ width: x as i32,
+ height: y as i32,
+ url: file_name.to_string_lossy().into(),
+ });
+
+ // Break if we have reached the end index
+ if index + 1 >= end_index as usize {
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+ }*/
+ println!("{:#?}", pics);
+
+ Ok(pics)
+}
+
+#[component]
+fn Info(show: ReadSignal, set_show: WriteSignal) -> impl IntoView {
+ view! {
+
+
+
+
+
+
+
+
+ }
+}
+
+#[component]
+fn Pic(width: i32, height: i32, url: String, scale: ReadSignal) -> impl IntoView {
+ let (showInfo, set_showInfo) = create_signal(false);
+
+ view! {
+
+
+ }
+}
+
diff --git a/flake.lock b/flake.lock
new file mode 100644
index 0000000..ca421bb
--- /dev/null
+++ b/flake.lock
@@ -0,0 +1,44 @@
+{
+ "nodes": {
+ "nixpkgs": {
+ "locked": {
+ "lastModified": 1704420045,
+ "narHash": "sha256-C36QmoJd5tdQ5R9MC1jM7fBkZW9zBUqbUCsgwS6j4QU=",
+ "owner": "nixos",
+ "repo": "nixpkgs",
+ "rev": "c1be43e8e837b8dbee2b3665a007e761680f0c3d",
+ "type": "github"
+ },
+ "original": {
+ "owner": "nixos",
+ "ref": "nixos-23.11",
+ "repo": "nixpkgs",
+ "type": "github"
+ }
+ },
+ "nixpkgs-unstable": {
+ "locked": {
+ "lastModified": 1704538339,
+ "narHash": "sha256-1734d3mQuux9ySvwf6axRWZRBhtcZA9Q8eftD6EZg6U=",
+ "owner": "nixos",
+ "repo": "nixpkgs",
+ "rev": "46ae0210ce163b3cba6c7da08840c1d63de9c701",
+ "type": "github"
+ },
+ "original": {
+ "owner": "nixos",
+ "ref": "nixos-unstable",
+ "repo": "nixpkgs",
+ "type": "github"
+ }
+ },
+ "root": {
+ "inputs": {
+ "nixpkgs": "nixpkgs",
+ "nixpkgs-unstable": "nixpkgs-unstable"
+ }
+ }
+ },
+ "root": "root",
+ "version": 7
+}
diff --git a/flake.nix b/flake.nix
new file mode 100644
index 0000000..b247af3
--- /dev/null
+++ b/flake.nix
@@ -0,0 +1,53 @@
+{
+ inputs.nixpkgs.url = "github:nixos/nixpkgs/nixos-23.11";
+ inputs.nixpkgs-unstable.url = "github:nixos/nixpkgs/nixos-unstable";
+
+ outputs = {
+ self,
+ nixpkgs,
+ ...
+ }: let
+ pkgs = import nixpkgs {
+ system = "x86_64-linux";
+ };
+ in {
+ devShells.x86_64-linux = {
+ default = pkgs.mkShell {
+ buildInputs = with pkgs; [
+ clang
+ # Replace llvmPackages with llvmPackages_X, where X is the latest LLVM version (at the time of writing, 16)
+ cargo-leptos
+ rustup
+ nodejs
+ pkg-config
+ openssl
+ nodejs
+ ];
+ RUSTC_VERSION = pkgs.lib.readFile ./rust-toolchain;
+ # https://github.com/rust-lang/rust-bindgen#environment-variables
+ LIBCLANG_PATH = pkgs.lib.makeLibraryPath [pkgs.llvmPackages_latest.libclang.lib];
+ shellHook = ''
+ export PATH=$PATH:''${CARGO_HOME:-~/.cargo}/bin
+ export PATH=$PATH:''${RUSTUP_HOME:-~/.rustup}/toolchains/$RUSTC_VERSION-x86_64-unknown-linux-gnu/bin/
+ '';
+ # Add precompiled library to rustc search path
+ RUSTFLAGS = builtins.map (a: ''-L ${a}/lib'') [
+ # add libraries here (e.g. pkgs.libvmi)
+ ];
+ # Add glibc, clang, glib and other headers to bindgen search path
+ BINDGEN_EXTRA_CLANG_ARGS =
+ # Includes with normal include path
+ (builtins.map (a: ''-I"${a}/include"'') [
+ # add dev libraries here (e.g. pkgs.libvmi.dev)
+ pkgs.glibc.dev
+ ])
+ # Includes with special directory paths
+ ++ [
+ ''-I"${pkgs.llvmPackages_latest.libclang.lib}/lib/clang/${pkgs.llvmPackages_latest.libclang.version}/include"''
+ ''-I"${pkgs.glib.dev}/include/glib-2.0"''
+ ''-I${pkgs.glib.out}/lib/glib-2.0/include/''
+ ];
+ };
+ };
+ };
+}
diff --git a/src/app.rs b/src/app.rs
index 3d3e49b..0e5eaa0 100644
--- a/src/app.rs
+++ b/src/app.rs
@@ -157,95 +157,82 @@ pub async fn get_pics2(page: i32, size: f64) -> Result, ServerFnE
use imageinfo::ImageInfo;
use std::fs;
use std::path::PathBuf;
-
- let query = "
- SELECT * FROM wallpapers LIMIT 10;
- ";
-
+ // Database setup
+ let query = "SELECT * FROM wallpapers LIMIT 10;";
let db = Surreal::new::("127.0.0.1:8000")
.await
- .expect("Couldnt connect to db server");
- // Select a specific namespace / database
+ .expect("Couldn't connect to db server");
db.use_ns("test")
.use_db("test")
.await
- .expect("Couldnt find db");
- //let papers: Vec = db.select("wallpapers").await.expect("Err");
- //println!("{papers:#?}");
+ .expect("Couldn't find db");
let mut res = db.query(query).await?;
let pap: Vec = res.take(0)?;
- println!("{pap:#?}");
let mut pics = Vec::new();
-
- let folder_path = "./public";
-
- // Define the number of pictures per page
+ let folder_path = PathBuf::from("./public/wallpaper-gen-data");
let pics_per_page = 10;
- // Calculate the index to start from based on the page number
let start_index = (page) * pics_per_page;
let end_index = start_index + pics_per_page;
- // manage a vector with all the image paths
let mut image_file_paths = Vec::::new();
- for entry in fs::read_dir(folder_path)? {
+
+ for entry in fs::read_dir(&folder_path)? {
let entry = entry?;
- let file_path = entry.path();
- let file_name_str = file_path.file_name().unwrap_or_default().to_str().unwrap();
- if size == 0.5 {
- //skip 1024 and 512
- if file_name_str.contains("512x512") || file_name_str.contains("1024x1024") {
- continue;
- }
- } else if size == 1.0 {
- if file_name_str.contains("256x256") || file_name_str.contains("1024x1024") {
- println!("sdfasdf");
- continue;
- }
- } else if size == 1.5 {
- if file_name_str.contains("256x256") || file_name_str.contains("512x512") {
- continue;
+ let subfolder_path = entry.path();
+
+ if subfolder_path.is_dir() {
+ if let Some(subfolder_name) = subfolder_path.file_name().and_then(|n| n.to_str()) {
+ let mut final_path = subfolder_path.clone();
+
+ let file_name = match size {
+ 0.5 => format!("{}-thumb-256x146.png", subfolder_name),
+ 1.0 => format!("{}-thumb-512x293.png", subfolder_name),
+ 1.5 => format!("{}-thumb-1024x585.png", subfolder_name),
+ _ => continue,
+ };
+
+ final_path.push(file_name);
+ println!("{}", final_path.as_os_str().to_str().unwrap());
+ image_file_paths.push(final_path);
}
}
- image_file_paths.push(file_path.clone());
}
for (i, file_path) in image_file_paths.iter().enumerate() {
+ if i < start_index as usize {
+ continue;
+ }
+
if file_path.is_file() {
- if i < start_index as usize {
- continue;
- }
let file = std::fs::File::open(file_path)?;
let mut bufreader = std::io::BufReader::new(&file);
+
let exifreader = exif::Reader::new();
- let exif = exifreader.read_from_container(&mut bufreader)?;
- for f in exif.fields() {
- println!(
- "{} {} {}",
- f.tag,
- f.ifd_num,
- f.display_value().with_unit(&exif)
- );
- }
+ let exif = match exifreader.read_from_container(&mut bufreader) {
+ Ok(exif) => Some(exif),
+ Err(_) => None, // Handle cases where EXIF data isn't available
+ };
+
let file_name = file_path.file_name().unwrap_or_default();
- let file_name_str = file_name.to_str().unwrap();
- // Check if the file has a supported image extension
+ let file_name_str = file_name.to_str().unwrap_or_default();
+
if let Some(extension) = file_path.extension() {
if let Some(extension_str) = extension.to_str() {
if image::ImageFormat::from_extension(extension_str).is_some() {
- // Process the image
- let img = image::open(&file_path).expect("Failed to open image");
+ // Re-create the BufReader for image processing since it may have been consumed
+ let img = image::open(file_path).expect("Failed to open image");
let (x, y) = img.dimensions();
pics.push(PicStruct {
- key: file_name_str.to_string(), // Could not be unique if two images were created at exactly
- // the same time
+ key: file_name_str.to_string(),
width: x as i32,
height: y as i32,
url: file_name.to_string_lossy().into(),
});
+
if i + 1 >= end_index as usize {
break;
}
@@ -255,69 +242,6 @@ pub async fn get_pics2(page: i32, size: f64) -> Result, ServerFnE
}
}
- // Send different picture resolutions depending on selected size
- // sizes 256 512 1024
-
- // Iterate over the entries in the folder
- /*for (index, entry) in fs::read_dir(folder_path)
- .expect("Failed to read directory")
- .enumerate()
- {
- if let Ok(entry) = entry {
- if index < start_index as usize {
- // Skip pictures before the start index
- continue;
- }
-
- let file_path = entry.path();
- let file_name = file_path.file_name().unwrap_or_default();
- let file_name_str = file_name.to_str().unwrap();
- // Skip the wrong sizes
- if size == 0.5 {
- //skip 1024 and 512
- if file_name_str.contains("512x512") || file_name_str.contains("1024x1024") {
- continue;
- }
- } else if size == 1.0 {
- if file_name_str.contains("256x256") || file_name_str.contains("1024x1024") {
- continue;
- }
- } else if size == 1.5 {
- if file_name_str.contains("256x256") || file_name_str.contains("512x512") {
- continue;
- }
- }
-
- // Check if the entry is a file
- if file_path.is_file() {
- // Check if the file has a supported image extension
- if let Some(extension) = file_path.extension() {
- if let Some(extension_str) = extension.to_str() {
- if image::ImageFormat::from_extension(extension_str).is_some() {
- // Process the image
- let img = image::open(&file_path).expect("Failed to open image");
- let (x, y) = img.dimensions();
-
- pics.push(PicStruct {
- key: file_name_str.to_string(), // Could not be unique if two images were created at exactly
- // the same time
- width: x as i32,
- height: y as i32,
- url: file_name.to_string_lossy().into(),
- });
-
- // Break if we have reached the end index
- if index + 1 >= end_index as usize {
- break;
- }
- }
- }
- }
- }
- }
- }*/
- println!("{:#?}", pics);
-
Ok(pics)
}