Update to Rust 2024 edition

Formatted code.

src/files.rs

@@ -7,18 +7,18 @@ use std::sync::Mutex;
 
 use ::anyhow;
 use actix::{Handler, Message};
-use anyhow::{anyhow, Context};
+use anyhow::{Context, anyhow};
 
 use crate::data::{Claims, FilesRequest, FilterMode, PhotosResponse, SortType};
-use crate::{create_thumbnails, AppState};
+use crate::{AppState, create_thumbnails};
 use actix_web::web::Data;
 use actix_web::{
-    web::{self, Query},
     HttpRequest, HttpResponse,
+    web::{self, Query},
 };
 use log::{debug, error, info, trace};
-use opentelemetry::trace::{Span, Status, TraceContextExt, Tracer};
 use opentelemetry::KeyValue;
+use opentelemetry::trace::{Span, Status, TraceContextExt, Tracer};
 
 use crate::data::SortType::NameAsc;
 use crate::error::IntoHttpError;
@@ -144,103 +144,108 @@ pub async fn list_photos<TagD: TagDao, FS: FileSystemAccess>(
         }
     }
 
-    if let Ok(files) = file_system.get_files_for_path(search_path) {
-        info!("Found {:?} files in path: {:?}", files.len(), search_path);
+    match file_system.get_files_for_path(search_path) {
+        Ok(files) => {
+            info!("Found {:?} files in path: {:?}", files.len(), search_path);
 
-        let photos = files
-            .iter()
-            .filter(|&f| {
-                f.metadata().map_or_else(
-                    |e| {
-                        error!("Failed getting file metadata: {:?}", e);
-                        f.extension().is_some()
-                    },
-                    |md| md.is_file(),
-                )
+            let photos = files
+                .iter()
+                .filter(|&f| {
+                    f.metadata().map_or_else(
+                        |e| {
+                            error!("Failed getting file metadata: {:?}", e);
+                            f.extension().is_some()
+                        },
+                        |md| md.is_file(),
+                    )
+                })
+                .map(|path: &PathBuf| {
+                    let relative = path.strip_prefix(&app_state.base_path).unwrap();
+                    relative.to_path_buf()
+                })
+                .map(|f| f.to_str().unwrap().to_string())
+                .map(|file_name| {
+                    let mut tag_dao = tag_dao.lock().expect("Unable to get TagDao");
+                    let file_tags = tag_dao
+                        .get_tags_for_path(&span_context, &file_name)
+                        .unwrap_or_default();
+
+                    (file_name, file_tags)
+                })
+                .filter(|(_, file_tags)| {
+                    if let Some(tag_ids) = &req.tag_ids {
+                        let tag_ids = tag_ids
+                            .split(',')
+                            .filter_map(|t| t.parse().ok())
+                            .collect::<Vec<i32>>();
+
+                        let excluded_tag_ids = &req
+                            .exclude_tag_ids
+                            .clone()
+                            .unwrap_or_default()
+                            .split(',')
+                            .filter_map(|t| t.parse().ok())
+                            .collect::<Vec<i32>>();
+
+                        let filter_mode = &req.tag_filter_mode.unwrap_or(FilterMode::Any);
+                        let excluded = file_tags.iter().any(|t| excluded_tag_ids.contains(&t.id));
+
+                        return !excluded
+                            && match filter_mode {
+                                FilterMode::Any => {
+                                    file_tags.iter().any(|t| tag_ids.contains(&t.id))
+                                }
+                                FilterMode::All => tag_ids
+                                    .iter()
+                                    .all(|id| file_tags.iter().any(|tag| &tag.id == id)),
+                            };
+                    }
+
+                    true
+                })
+                .map(|(file_name, tags)| FileWithTagCount {
+                    file_name,
+                    tag_count: tags.len() as i64,
+                })
+                .collect::<Vec<FileWithTagCount>>();
+
+            let mut response_files = photos
+                .clone()
+                .into_iter()
+                .map(|f| f.file_name)
+                .collect::<Vec<String>>();
+            if let Some(sort_type) = req.sort {
+                debug!("Sorting files: {:?}", sort_type);
+                response_files = sort(photos, sort_type)
+            }
+
+            let dirs = files
+                .iter()
+                .filter(|&f| f.metadata().map_or(false, |md| md.is_dir()))
+                .map(|path: &PathBuf| {
+                    let relative = path.strip_prefix(&app_state.base_path).unwrap();
+                    relative.to_path_buf()
+                })
+                .map(|f| f.to_str().unwrap().to_string())
+                .collect::<Vec<String>>();
+
+            span_context
+                .span()
+                .set_attribute(KeyValue::new("file_count", files.len().to_string()));
+            span_context.span().set_status(Status::Ok);
+
+            HttpResponse::Ok().json(PhotosResponse {
+                photos: response_files,
+                dirs,
             })
-            .map(|path: &PathBuf| {
-                let relative = path.strip_prefix(&app_state.base_path).unwrap();
-                relative.to_path_buf()
-            })
-            .map(|f| f.to_str().unwrap().to_string())
-            .map(|file_name| {
-                let mut tag_dao = tag_dao.lock().expect("Unable to get TagDao");
-                let file_tags = tag_dao
-                    .get_tags_for_path(&span_context, &file_name)
-                    .unwrap_or_default();
-
-                (file_name, file_tags)
-            })
-            .filter(|(_, file_tags)| {
-                if let Some(tag_ids) = &req.tag_ids {
-                    let tag_ids = tag_ids
-                        .split(',')
-                        .filter_map(|t| t.parse().ok())
-                        .collect::<Vec<i32>>();
-
-                    let excluded_tag_ids = &req
-                        .exclude_tag_ids
-                        .clone()
-                        .unwrap_or_default()
-                        .split(',')
-                        .filter_map(|t| t.parse().ok())
-                        .collect::<Vec<i32>>();
-
-                    let filter_mode = &req.tag_filter_mode.unwrap_or(FilterMode::Any);
-                    let excluded = file_tags.iter().any(|t| excluded_tag_ids.contains(&t.id));
-
-                    return !excluded
-                        && match filter_mode {
-                            FilterMode::Any => file_tags.iter().any(|t| tag_ids.contains(&t.id)),
-                            FilterMode::All => tag_ids
-                                .iter()
-                                .all(|id| file_tags.iter().any(|tag| &tag.id == id)),
-                        };
-                }
-
-                true
-            })
-            .map(|(file_name, tags)| FileWithTagCount {
-                file_name,
-                tag_count: tags.len() as i64,
-            })
-            .collect::<Vec<FileWithTagCount>>();
-
-        let mut response_files = photos
-            .clone()
-            .into_iter()
-            .map(|f| f.file_name)
-            .collect::<Vec<String>>();
-        if let Some(sort_type) = req.sort {
-            debug!("Sorting files: {:?}", sort_type);
-            response_files = sort(photos, sort_type)
         }
-
-        let dirs = files
-            .iter()
-            .filter(|&f| f.metadata().map_or(false, |md| md.is_dir()))
-            .map(|path: &PathBuf| {
-                let relative = path.strip_prefix(&app_state.base_path).unwrap();
-                relative.to_path_buf()
-            })
-            .map(|f| f.to_str().unwrap().to_string())
-            .collect::<Vec<String>>();
-
-        span_context
-            .span()
-            .set_attribute(KeyValue::new("file_count", files.len().to_string()));
-        span_context.span().set_status(Status::Ok);
-
-        HttpResponse::Ok().json(PhotosResponse {
-            photos: response_files,
-            dirs,
-        })
-    } else {
-        error!("Bad photos request: {}", req.path);
-        span_context
-            .span()
-            .set_status(Status::error("Invalid path"));
-        HttpResponse::BadRequest().finish()
+        _ => {
+            error!("Bad photos request: {}", req.path);
+            span_context
+                .span()
+                .set_status(Status::error("Invalid path"));
+            HttpResponse::BadRequest().finish()
+        }
     }
 }
 
@@ -505,12 +510,12 @@ mod tests {
 
     mod api {
         use super::*;
-        use actix_web::{web::Query, HttpResponse};
+        use actix_web::{HttpResponse, web::Query};
 
         use crate::{
+            AppState,
             data::{Claims, PhotosResponse},
             testhelpers::BodyReader,
-            AppState,
         };
 
         use crate::database::test::in_memory_db_connection;
@@ -561,14 +566,15 @@ mod tests {
 
             assert!(body.photos.contains(&String::from("photo.jpg")));
             assert!(body.dirs.contains(&String::from("test-dir")));
-            assert!(body
-                .photos
-                .iter()
-                .filter(|filename| !filename.ends_with(".png")
-                    && !filename.ends_with(".jpg")
-                    && !filename.ends_with(".jpeg"))
-                .collect::<Vec<&String>>()
-                .is_empty());
+            assert!(
+                body.photos
+                    .iter()
+                    .filter(|filename| !filename.ends_with(".png")
+                        && !filename.ends_with(".jpg")
+                        && !filename.ends_with(".jpeg"))
+                    .collect::<Vec<&String>>()
+                    .is_empty()
+            );
         }
 
         #[actix_rt::test]