From bfeb81270ca0da99ca02608fdecf593c585a7819 Mon Sep 17 00:00:00 2001 From: ddotthomas Date: Sat, 30 Dec 2023 19:19:22 -0700 Subject: [PATCH 01/12] fix: modify cache key with engines used for search --- src/server/routes/search.rs | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/src/server/routes/search.rs b/src/server/routes/search.rs index 9261051..fe07935 100644 --- a/src/server/routes/search.rs +++ b/src/server/routes/search.rs @@ -123,11 +123,24 @@ async fn results( config.safe_search, ); - let cache_key = format!( + let mut cache_key = format!( "http://{}:{}/search?q={}&page={}&safesearch={}", config.binding_ip, config.port, query, page, safe_search_level ); + // Modify the cache key adding each enabled search engine to the string + if let Some(cookie_value) = &cookie_value { + let mut engines: Vec = cookie_value + .engines + .iter() + .map(|s| String::from(*s)) + .collect::>(); + + // We sort the list of engine so the cache keys will match between users. The cookie's list of engines is unordered. + engines.sort(); + cache_key = cache_key + &(engines.join("")); + } + // fetch the cached results json. let cached_results = cache.cached_results(&cache_key).await; // check if fetched cache results was indeed fetched or it was an error and if so From 286bcf1bd359c827e5c7139eab2320a6c4bcc2bf Mon Sep 17 00:00:00 2001 From: ddotthomas Date: Sat, 30 Dec 2023 22:12:43 -0700 Subject: [PATCH 02/12] fix: added a config parse backup --- src/server/routes/search.rs | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/server/routes/search.rs b/src/server/routes/search.rs index fe07935..10f6982 100644 --- a/src/server/routes/search.rs +++ b/src/server/routes/search.rs @@ -139,6 +139,16 @@ async fn results( // We sort the list of engine so the cache keys will match between users. The cookie's list of engines is unordered. engines.sort(); cache_key = cache_key + &(engines.join("")); + } else { + let mut engines: Vec = config + .upstream_search_engines + .iter() + .filter(|map| *map.1) + .map(|map| String::from(&(*map.0))) + .collect(); + + engines.sort(); + cache_key = cache_key + &(engines.join("")); } // fetch the cached results json. From 4f4cb220ccb4706a8d60767f561954b5ede50d29 Mon Sep 17 00:00:00 2001 From: ddotthomas Date: Sat, 30 Dec 2023 22:18:15 -0700 Subject: [PATCH 03/12] fix: changed dereferencing --- src/server/routes/search.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/server/routes/search.rs b/src/server/routes/search.rs index 10f6982..25ddc9a 100644 --- a/src/server/routes/search.rs +++ b/src/server/routes/search.rs @@ -144,7 +144,7 @@ async fn results( .upstream_search_engines .iter() .filter(|map| *map.1) - .map(|map| String::from(&(*map.0))) + .map(|map| String::from(map.0)) .collect(); engines.sort(); From db1115f19edaf165cb1b813fc90a99599dec33b0 Mon Sep 17 00:00:00 2001 From: ddotthomas Date: Mon, 1 Jan 2024 19:36:18 -0700 Subject: [PATCH 04/12] fix: add comma separator and format macro --- src/server/routes/search.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/server/routes/search.rs b/src/server/routes/search.rs index 25ddc9a..35bd9ad 100644 --- a/src/server/routes/search.rs +++ b/src/server/routes/search.rs @@ -138,7 +138,7 @@ async fn results( // We sort the list of engine so the cache keys will match between users. The cookie's list of engines is unordered. engines.sort(); - cache_key = cache_key + &(engines.join("")); + cache_key = format!("{}{}", cache_key, engines.join(",")); } else { let mut engines: Vec = config .upstream_search_engines @@ -148,7 +148,7 @@ async fn results( .collect(); engines.sort(); - cache_key = cache_key + &(engines.join("")); + cache_key = format!("{}{}", cache_key, engines.join(",")); } // fetch the cached results json. From 86b0d3d6c9ca708aaaf6b0417d93188286daff62 Mon Sep 17 00:00:00 2001 From: ddotthomas Date: Tue, 2 Jan 2024 16:26:04 -0700 Subject: [PATCH 05/12] Moved parsing of cookie_value, config to cache_key --- src/server/routes/search.rs | 66 ++++++++++++++++++------------------- 1 file changed, 33 insertions(+), 33 deletions(-) diff --git a/src/server/routes/search.rs b/src/server/routes/search.rs index 908875a..e8e0153 100644 --- a/src/server/routes/search.rs +++ b/src/server/routes/search.rs @@ -6,7 +6,7 @@ use crate::{ handler::{file_path, FileType}, models::{ aggregation_models::SearchResults, - engine_models::{EngineError, EngineHandler}, + engine_models::EngineHandler, server_models::{Cookie, SearchParams}, }, results::aggregator::aggregate, @@ -126,27 +126,27 @@ async fn results( config.binding_ip, config.port, query, page, safe_search_level ); + let mut cookie_engines: Vec = vec![]; + let mut config_engines: Vec = config + .upstream_search_engines + .iter() + .filter_map(|(engine, enabled)| enabled.then_some(engine.clone())) + .collect(); + config_engines.sort(); + // Modify the cache key adding each enabled search engine to the string if let Some(cookie_value) = &cookie_value { - let mut engines: Vec = cookie_value + cookie_engines = cookie_value .engines .iter() .map(|s| String::from(*s)) .collect::>(); // We sort the list of engine so the cache keys will match between users. The cookie's list of engines is unordered. - engines.sort(); - cache_key = format!("{}{}", cache_key, engines.join(",")); + cookie_engines.sort(); + cache_key = format!("{}{}", cache_key, cookie_engines.join(",")); } else { - let mut engines: Vec = config - .upstream_search_engines - .iter() - .filter(|map| *map.1) - .map(|map| String::from(map.0)) - .collect(); - - engines.sort(); - cache_key = format!("{}{}", cache_key, engines.join(",")); + cache_key = format!("{}{}", cache_key, config_engines.join(",")); } // fetch the cached results json. @@ -175,9 +175,10 @@ async fn results( // parse the non-empty cookie and grab the user selected engines from the // UI and use that. let mut results: SearchResults = match cookie_value { - Some(cookie_value) => { - let engines: Vec = cookie_value - .engines + // If the cookie was used before + Some(_) => { + // Use the cookie_engines Strings from before to create the EngineHandlers + let engines: Vec = cookie_engines .iter() .filter_map(|name| EngineHandler::new(name).ok()) .collect(); @@ -202,23 +203,22 @@ async fn results( } } } - None => aggregate( - query, - page, - config.aggregator.random_delay, - config.debug, - &config - .upstream_search_engines - .clone() - .into_iter() - .filter_map(|(key, value)| value.then_some(key)) - .map(|engine| EngineHandler::new(&engine)) - .collect::, error_stack::Report>>( - )?, - config.request_timeout, - safe_search_level, - ) - .await?, + // Otherwise, use the config_engines to create the EngineHandlers + None => { + aggregate( + query, + page, + config.aggregator.random_delay, + config.debug, + &config_engines + .into_iter() + .filter_map(|engine| EngineHandler::new(&engine).ok()) + .collect::>(), + config.request_timeout, + safe_search_level, + ) + .await? + } }; if results.engine_errors_info().is_empty() && results.results().is_empty() From dde117e7e67c019fee8a301be6ed455bf65038a8 Mon Sep 17 00:00:00 2001 From: ddotthomas Date: Thu, 4 Jan 2024 11:05:09 -0700 Subject: [PATCH 06/12] modify: changed cache_key format data --- src/server/routes/search.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/server/routes/search.rs b/src/server/routes/search.rs index e8e0153..3f880f5 100644 --- a/src/server/routes/search.rs +++ b/src/server/routes/search.rs @@ -144,9 +144,9 @@ async fn results( // We sort the list of engine so the cache keys will match between users. The cookie's list of engines is unordered. cookie_engines.sort(); - cache_key = format!("{}{}", cache_key, cookie_engines.join(",")); + cache_key = format!("{cache_key}&engines={}", cookie_engines.join(",")); } else { - cache_key = format!("{}{}", cache_key, config_engines.join(",")); + cache_key = format!("{cache_key}&engines={}", config_engines.join(",")); } // fetch the cached results json. From 7d762b372609b4afe19b6c9b8484726858f2244c Mon Sep 17 00:00:00 2001 From: ddotthomas Date: Sun, 7 Jan 2024 16:29:39 -0700 Subject: [PATCH 07/12] refactor: moved settings parsing out of results --- src/models/server_models.rs | 23 +++++- src/server/routes/search.rs | 150 ++++++++++++------------------------ 2 files changed, 68 insertions(+), 105 deletions(-) diff --git a/src/models/server_models.rs b/src/models/server_models.rs index 4772b98..a13a7dd 100644 --- a/src/models/server_models.rs +++ b/src/models/server_models.rs @@ -2,6 +2,8 @@ //! engine website. use serde::Deserialize; +use super::parser_models::Style; + /// A named struct which deserializes all the user provided search parameters and stores them. #[derive(Deserialize)] pub struct SearchParams { @@ -19,13 +21,26 @@ pub struct SearchParams { /// A named struct which is used to deserialize the cookies fetched from the client side. #[allow(dead_code)] #[derive(Deserialize)] -pub struct Cookie<'a> { +pub struct Cookie { /// It stores the theme name used in the website. - pub theme: &'a str, + pub theme: String, /// It stores the colorscheme name used for the website theme. - pub colorscheme: &'a str, + pub colorscheme: String, /// It stores the user selected upstream search engines selected from the UI. - pub engines: Vec<&'a str>, + pub engines: Vec, /// It stores the user selected safe search level from the UI. pub safe_search_level: u8, } + +impl Cookie { + /// server_models::Cookie contructor function + pub fn build(style: &Style, mut engines: Vec, safe_search_level: u8) -> Self { + engines.sort(); + Self { + theme: style.theme.clone(), + colorscheme: style.colorscheme.clone(), + engines, + safe_search_level, + } + } +} diff --git a/src/server/routes/search.rs b/src/server/routes/search.rs index 3f880f5..edf8e1b 100644 --- a/src/server/routes/search.rs +++ b/src/server/routes/search.rs @@ -7,7 +7,7 @@ use crate::{ models::{ aggregation_models::SearchResults, engine_models::EngineHandler, - server_models::{Cookie, SearchParams}, + server_models::{self, SearchParams}, }, results::aggregator::aggregate, }; @@ -48,17 +48,37 @@ pub async fn search( .finish()); } - let get_results = |page| { - results( - &config, - &cache, - query, - page, - req.clone(), - ¶ms.safesearch, + // Closure to build a server_models::Cookie capturing local references + let build_cookie = || { + server_models::Cookie::build( + &config.style, + config + .upstream_search_engines + .clone() + .into_iter() + .filter_map(|engine_map| engine_map.1.then_some(engine_map.0)) + .collect(), + config.safe_search, ) }; + // Get search settings using the user's cookie or from the server's config + let search_settings: server_models::Cookie = match req.cookie("appCookie") { + Some(cookie_value) => { + if let Ok(cookie) = serde_json::from_str(cookie_value.value()) { + cookie + // If there's an issue parsing the cookie's value, default to the config + } else { + build_cookie() + } + } + // If there's no cookie saved, use the server's config + None => build_cookie(), + }; + + // Closure wrapping the results function capturing local references + let get_results = |page| results(&config, &cache, query, page, &search_settings); + // .max(1) makes sure that the page >= 0. let page = params.page.unwrap_or(1).max(1) - 1; @@ -105,50 +125,21 @@ async fn results( cache: &web::Data, query: &str, page: u32, - req: HttpRequest, - safe_search: &Option, + user_settings: &server_models::Cookie, ) -> Result> { // eagerly parse cookie value to evaluate safe search level - let cookie_value = req.cookie("appCookie"); + let safe_search_level = user_settings.safe_search_level; - let cookie_value: Option> = cookie_value - .as_ref() - .and_then(|cv| serde_json::from_str(cv.name_value().1).ok()); - - let safe_search_level = get_safesearch_level( - safe_search, - &cookie_value.as_ref().map(|cv| cv.safe_search_level), - config.safe_search, + let cache_key = format!( + "http://{}:{}/search?q={}&page={}&safesearch={}&engines={}", + config.binding_ip, + config.port, + query, + page, + safe_search_level, + user_settings.engines.join(",") ); - let mut cache_key = format!( - "http://{}:{}/search?q={}&page={}&safesearch={}", - config.binding_ip, config.port, query, page, safe_search_level - ); - - let mut cookie_engines: Vec = vec![]; - let mut config_engines: Vec = config - .upstream_search_engines - .iter() - .filter_map(|(engine, enabled)| enabled.then_some(engine.clone())) - .collect(); - config_engines.sort(); - - // Modify the cache key adding each enabled search engine to the string - if let Some(cookie_value) = &cookie_value { - cookie_engines = cookie_value - .engines - .iter() - .map(|s| String::from(*s)) - .collect::>(); - - // We sort the list of engine so the cache keys will match between users. The cookie's list of engines is unordered. - cookie_engines.sort(); - cache_key = format!("{cache_key}&engines={}", cookie_engines.join(",")); - } else { - cache_key = format!("{cache_key}&engines={}", config_engines.join(",")); - } - // fetch the cached results json. let cached_results = cache.cached_results(&cache_key).await; // check if fetched cache results was indeed fetched or it was an error and if so @@ -174,43 +165,16 @@ async fn results( // default selected upstream search engines from the config file otherwise // parse the non-empty cookie and grab the user selected engines from the // UI and use that. - let mut results: SearchResults = match cookie_value { - // If the cookie was used before - Some(_) => { - // Use the cookie_engines Strings from before to create the EngineHandlers - let engines: Vec = cookie_engines - .iter() - .filter_map(|name| EngineHandler::new(name).ok()) - .collect(); - - match engines.is_empty() { - false => { - aggregate( - query, - page, - config.aggregator.random_delay, - config.debug, - &engines, - config.request_timeout, - safe_search_level, - ) - .await? - } - true => { - let mut search_results = SearchResults::default(); - search_results.set_no_engines_selected(); - search_results - } - } - } - // Otherwise, use the config_engines to create the EngineHandlers - None => { + let mut results: SearchResults = match user_settings.engines.is_empty() { + false => { aggregate( query, page, config.aggregator.random_delay, config.debug, - &config_engines + &user_settings + .engines + .clone() .into_iter() .filter_map(|engine| EngineHandler::new(&engine).ok()) .collect::>(), @@ -219,6 +183,11 @@ async fn results( ) .await? } + true => { + let mut search_results = SearchResults::default(); + search_results.set_no_engines_selected(); + search_results + } }; if results.engine_errors_info().is_empty() && results.results().is_empty() @@ -259,24 +228,3 @@ fn is_match_from_filter_list( Ok(false) } - -/// A helper function which returns the safe search level based on the url params -/// and cookie value. -/// -/// # Argurments -/// -/// * `safe_search` - Safe search level from the url. -/// * `cookie` - User's cookie -/// * `default` - Safe search level to fall back to -fn get_safesearch_level(safe_search: &Option, cookie: &Option, default: u8) -> u8 { - match safe_search { - Some(ss) => { - if *ss >= 3 { - default - } else { - *ss - } - } - None => cookie.unwrap_or(default), - } -} From 6e9250c03a1de25568ed37992a624eb8769fe20c Mon Sep 17 00:00:00 2001 From: ddotthomas Date: Mon, 8 Jan 2024 09:19:36 -0700 Subject: [PATCH 08/12] fix: safe search url parameter ignored --- src/server/routes/search.rs | 35 +++++++++++++++++++++++++++++------ 1 file changed, 29 insertions(+), 6 deletions(-) diff --git a/src/server/routes/search.rs b/src/server/routes/search.rs index edf8e1b..4e3d309 100644 --- a/src/server/routes/search.rs +++ b/src/server/routes/search.rs @@ -63,19 +63,21 @@ pub async fn search( }; // Get search settings using the user's cookie or from the server's config - let search_settings: server_models::Cookie = match req.cookie("appCookie") { + let mut search_settings: server_models::Cookie = match req.cookie("appCookie") { Some(cookie_value) => { - if let Ok(cookie) = serde_json::from_str(cookie_value.value()) { - cookie - // If there's an issue parsing the cookie's value, default to the config - } else { - build_cookie() + match serde_json::from_str(cookie_value.value()) { + Ok(cookie) => cookie, + // If there's an issue parsing the cookie's value, default to the config + Err(_) => build_cookie(), } } // If there's no cookie saved, use the server's config None => build_cookie(), }; + search_settings.safe_search_level = + get_safesearch_level(¶ms.safesearch, config.safe_search); + // Closure wrapping the results function capturing local references let get_results = |page| results(&config, &cache, query, page, &search_settings); @@ -228,3 +230,24 @@ fn is_match_from_filter_list( Ok(false) } + +/// A helper function which returns the safe search level based on the url params +/// and cookie value. +/// +/// # Argurments +/// +/// * `safe_search` - Safe search level from the url. +/// * `cookie` - User's cookie +/// * `default` - Safe search level to fall back to +fn get_safesearch_level(safe_search: &Option, default: u8) -> u8 { + match safe_search { + Some(ss) => { + if *ss >= 3 { + default + } else { + *ss + } + } + None => default, + } +} From d912bff94e912d77d7bfbdcf327f7adff514c45a Mon Sep 17 00:00:00 2001 From: ddotthomas Date: Mon, 8 Jan 2024 11:46:21 -0700 Subject: [PATCH 09/12] change: revert Cookie Strings back to &str --- src/models/server_models.rs | 14 +++++++------- src/server/routes/search.rs | 16 +++++++++------- 2 files changed, 16 insertions(+), 14 deletions(-) diff --git a/src/models/server_models.rs b/src/models/server_models.rs index a13a7dd..8b19463 100644 --- a/src/models/server_models.rs +++ b/src/models/server_models.rs @@ -21,24 +21,24 @@ pub struct SearchParams { /// A named struct which is used to deserialize the cookies fetched from the client side. #[allow(dead_code)] #[derive(Deserialize)] -pub struct Cookie { +pub struct Cookie<'a> { /// It stores the theme name used in the website. - pub theme: String, + pub theme: &'a str, /// It stores the colorscheme name used for the website theme. - pub colorscheme: String, + pub colorscheme: &'a str, /// It stores the user selected upstream search engines selected from the UI. pub engines: Vec, /// It stores the user selected safe search level from the UI. pub safe_search_level: u8, } -impl Cookie { +impl<'a> Cookie<'a> { /// server_models::Cookie contructor function - pub fn build(style: &Style, mut engines: Vec, safe_search_level: u8) -> Self { + pub fn build(style: &'a Style, mut engines: Vec, safe_search_level: u8) -> Self { engines.sort(); Self { - theme: style.theme.clone(), - colorscheme: style.colorscheme.clone(), + theme: &style.theme, + colorscheme: &style.colorscheme, engines, safe_search_level, } diff --git a/src/server/routes/search.rs b/src/server/routes/search.rs index 4e3d309..cc16486 100644 --- a/src/server/routes/search.rs +++ b/src/server/routes/search.rs @@ -62,9 +62,11 @@ pub async fn search( ) }; + let cookie = req.cookie("appCookie"); + // Get search settings using the user's cookie or from the server's config - let mut search_settings: server_models::Cookie = match req.cookie("appCookie") { - Some(cookie_value) => { + let mut search_settings: server_models::Cookie<'_> = match cookie { + Some(ref cookie_value) => { match serde_json::from_str(cookie_value.value()) { Ok(cookie) => cookie, // If there's an issue parsing the cookie's value, default to the config @@ -127,10 +129,10 @@ async fn results( cache: &web::Data, query: &str, page: u32, - user_settings: &server_models::Cookie, + search_settings: &server_models::Cookie<'_>, ) -> Result> { // eagerly parse cookie value to evaluate safe search level - let safe_search_level = user_settings.safe_search_level; + let safe_search_level = search_settings.safe_search_level; let cache_key = format!( "http://{}:{}/search?q={}&page={}&safesearch={}&engines={}", @@ -139,7 +141,7 @@ async fn results( query, page, safe_search_level, - user_settings.engines.join(",") + search_settings.engines.join(",") ); // fetch the cached results json. @@ -167,14 +169,14 @@ async fn results( // default selected upstream search engines from the config file otherwise // parse the non-empty cookie and grab the user selected engines from the // UI and use that. - let mut results: SearchResults = match user_settings.engines.is_empty() { + let mut results: SearchResults = match search_settings.engines.is_empty() { false => { aggregate( query, page, config.aggregator.random_delay, config.debug, - &user_settings + &search_settings .engines .clone() .into_iter() From 80e950de3bc091e25e2e3a66a7967b48770a24e3 Mon Sep 17 00:00:00 2001 From: ddotthomas Date: Wed, 10 Jan 2024 14:14:14 -0700 Subject: [PATCH 10/12] refactor: changed Cookie to use Cow to facilitate using references when building --- src/models/server_models.rs | 16 ++++---- src/server/routes/search.rs | 77 ++++++++++++++++--------------------- 2 files changed, 43 insertions(+), 50 deletions(-) diff --git a/src/models/server_models.rs b/src/models/server_models.rs index 8b19463..eca252e 100644 --- a/src/models/server_models.rs +++ b/src/models/server_models.rs @@ -1,5 +1,7 @@ //! This module provides the models to parse cookies and search parameters from the search //! engine website. +use std::borrow::Cow; + use serde::Deserialize; use super::parser_models::Style; @@ -23,23 +25,23 @@ pub struct SearchParams { #[derive(Deserialize)] pub struct Cookie<'a> { /// It stores the theme name used in the website. - pub theme: &'a str, + pub theme: Cow<'a, str>, /// It stores the colorscheme name used for the website theme. - pub colorscheme: &'a str, + pub colorscheme: Cow<'a, str>, /// It stores the user selected upstream search engines selected from the UI. - pub engines: Vec, + pub engines: Cow<'a, Vec>>, /// It stores the user selected safe search level from the UI. pub safe_search_level: u8, } impl<'a> Cookie<'a> { /// server_models::Cookie contructor function - pub fn build(style: &'a Style, mut engines: Vec, safe_search_level: u8) -> Self { + pub fn build(style: &'a Style, mut engines: Vec>, safe_search_level: u8) -> Self { engines.sort(); Self { - theme: &style.theme, - colorscheme: &style.colorscheme, - engines, + theme: Cow::Borrowed(&style.theme), + colorscheme: Cow::Borrowed(&style.colorscheme), + engines: Cow::Owned(engines), safe_search_level, } } diff --git a/src/server/routes/search.rs b/src/server/routes/search.rs index cc16486..9d66452 100644 --- a/src/server/routes/search.rs +++ b/src/server/routes/search.rs @@ -14,6 +14,7 @@ use crate::{ use actix_web::{get, http::header::ContentType, web, HttpRequest, HttpResponse}; use regex::Regex; use std::{ + borrow::Cow, fs::File, io::{BufRead, BufReader, Read}, }; @@ -48,37 +49,30 @@ pub async fn search( .finish()); } - // Closure to build a server_models::Cookie capturing local references - let build_cookie = || { - server_models::Cookie::build( - &config.style, - config - .upstream_search_engines - .clone() - .into_iter() - .filter_map(|engine_map| engine_map.1.then_some(engine_map.0)) - .collect(), - config.safe_search, - ) - }; - let cookie = req.cookie("appCookie"); // Get search settings using the user's cookie or from the server's config - let mut search_settings: server_models::Cookie<'_> = match cookie { - Some(ref cookie_value) => { - match serde_json::from_str(cookie_value.value()) { - Ok(cookie) => cookie, - // If there's an issue parsing the cookie's value, default to the config - Err(_) => build_cookie(), - } - } - // If there's no cookie saved, use the server's config - None => build_cookie(), - }; + let mut search_settings: server_models::Cookie<'_> = cookie + .and_then(|cookie_value| serde_json::from_str(cookie_value.value()).ok()) + .unwrap_or_else(|| { + server_models::Cookie::build( + &config.style, + config + .upstream_search_engines + .iter() + .filter_map(|(engine, enabled)| { + enabled.then_some(Cow::Borrowed(engine.as_str())) + }) + .collect(), + config.safe_search, + ) + }); - search_settings.safe_search_level = - get_safesearch_level(¶ms.safesearch, config.safe_search); + get_safesearch_level( + &mut search_settings.safe_search_level, + ¶ms.safesearch, + config.safe_search, + ); // Closure wrapping the results function capturing local references let get_results = |page| results(&config, &cache, query, page, &search_settings); @@ -178,8 +172,7 @@ async fn results( config.debug, &search_settings .engines - .clone() - .into_iter() + .iter() .filter_map(|engine| EngineHandler::new(&engine).ok()) .collect::>(), config.request_timeout, @@ -233,23 +226,21 @@ fn is_match_from_filter_list( Ok(false) } -/// A helper function which returns the safe search level based on the url params -/// and cookie value. +/// A helper function to modify the safe search level based on the url params. +/// The `safe_search` is the one in the user's cookie or +/// the default set by the server config if the cookie was missing. /// /// # Argurments /// -/// * `safe_search` - Safe search level from the url. -/// * `cookie` - User's cookie -/// * `default` - Safe search level to fall back to -fn get_safesearch_level(safe_search: &Option, default: u8) -> u8 { - match safe_search { - Some(ss) => { - if *ss >= 3 { - default - } else { - *ss - } +/// * `url_level` - Safe search level from the url. +/// * `safe_search` - User's cookie, or the safe search level set by the server +/// * `config_level` - Safe search level to fall back to +fn get_safesearch_level(safe_search: &mut u8, url_level: &Option, config_level: u8) { + if let Some(search_level) = url_level { + if *search_level >= 3 { + *safe_search = config_level + } else { + *safe_search = *search_level; } - None => default, } } From ca96a76958b71ee100894f6e570e8af7d191eef0 Mon Sep 17 00:00:00 2001 From: ddotthomas Date: Thu, 11 Jan 2024 11:58:09 -0700 Subject: [PATCH 11/12] change: renamed get_safesearch_level variables --- src/server/routes/search.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/server/routes/search.rs b/src/server/routes/search.rs index 9d66452..c176e65 100644 --- a/src/server/routes/search.rs +++ b/src/server/routes/search.rs @@ -236,11 +236,11 @@ fn is_match_from_filter_list( /// * `safe_search` - User's cookie, or the safe search level set by the server /// * `config_level` - Safe search level to fall back to fn get_safesearch_level(safe_search: &mut u8, url_level: &Option, config_level: u8) { - if let Some(search_level) = url_level { - if *search_level >= 3 { + if let Some(url_level) = url_level { + if *url_level >= 3 { *safe_search = config_level } else { - *safe_search = *search_level; + *safe_search = *url_level; } } } From 31c9c676eed2a85515ec353df022f6befb038b5a Mon Sep 17 00:00:00 2001 From: ddotthomas Date: Fri, 12 Jan 2024 09:51:31 -0700 Subject: [PATCH 12/12] Change get_safe_search_level logic back --- src/server/routes/search.rs | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/src/server/routes/search.rs b/src/server/routes/search.rs index c176e65..a1c2cf3 100644 --- a/src/server/routes/search.rs +++ b/src/server/routes/search.rs @@ -68,8 +68,8 @@ pub async fn search( ) }); - get_safesearch_level( - &mut search_settings.safe_search_level, + search_settings.safe_search_level = get_safesearch_level( + &Some(search_settings.safe_search_level), ¶ms.safesearch, config.safe_search, ); @@ -235,12 +235,15 @@ fn is_match_from_filter_list( /// * `url_level` - Safe search level from the url. /// * `safe_search` - User's cookie, or the safe search level set by the server /// * `config_level` - Safe search level to fall back to -fn get_safesearch_level(safe_search: &mut u8, url_level: &Option, config_level: u8) { - if let Some(url_level) = url_level { - if *url_level >= 3 { - *safe_search = config_level - } else { - *safe_search = *url_level; +fn get_safesearch_level(cookie_level: &Option, url_level: &Option, config_level: u8) -> u8 { + match url_level { + Some(url_level) => { + if *url_level >= 3 { + config_level + } else { + *url_level + } } + None => cookie_level.unwrap_or(config_level), } }