Cargo formatting

src/files.rs

@@ -65,83 +65,84 @@ pub async fn list_photos<TagD: TagDao, FS: FileSystemAccess>(
 
     let search_recursively = req.recursive.unwrap_or(false);
     if let Some(tag_ids) = &req.tag_ids
-        && search_recursively {
-            let filter_mode = &req.tag_filter_mode.unwrap_or(FilterMode::Any);
-            info!(
-                "Searching for tags: {}. With path: '{}' and filter mode: {:?}",
-                tag_ids, search_path, filter_mode
-            );
+        && search_recursively
+    {
+        let filter_mode = &req.tag_filter_mode.unwrap_or(FilterMode::Any);
+        info!(
+            "Searching for tags: {}. With path: '{}' and filter mode: {:?}",
+            tag_ids, search_path, filter_mode
+        );
 
-            let mut dao = tag_dao.lock().expect("Unable to get TagDao");
-            let tag_ids = tag_ids
-                .split(',')
-                .filter_map(|t| t.parse().ok())
-                .collect::<Vec<i32>>();
+        let mut dao = tag_dao.lock().expect("Unable to get TagDao");
+        let tag_ids = tag_ids
+            .split(',')
+            .filter_map(|t| t.parse().ok())
+            .collect::<Vec<i32>>();
 
-            let exclude_tag_ids = req
-                .exclude_tag_ids
-                .clone()
-                .unwrap_or_default()
-                .split(',')
-                .filter_map(|t| t.parse().ok())
-                .collect::<Vec<i32>>();
+        let exclude_tag_ids = req
+            .exclude_tag_ids
+            .clone()
+            .unwrap_or_default()
+            .split(',')
+            .filter_map(|t| t.parse().ok())
+            .collect::<Vec<i32>>();
 
-            return match filter_mode {
-                FilterMode::Any => {
-                    dao.get_files_with_any_tag_ids(tag_ids.clone(), exclude_tag_ids, &span_context)
-                }
-                FilterMode::All => {
-                    dao.get_files_with_all_tag_ids(tag_ids.clone(), exclude_tag_ids, &span_context)
-                }
+        return match filter_mode {
+            FilterMode::Any => {
+                dao.get_files_with_any_tag_ids(tag_ids.clone(), exclude_tag_ids, &span_context)
+            }
+            FilterMode::All => {
+                dao.get_files_with_all_tag_ids(tag_ids.clone(), exclude_tag_ids, &span_context)
             }
-            .context(format!(
-                "Failed to get files with tag_ids: {:?} with filter_mode: {:?}",
-                tag_ids, filter_mode
-            ))
-            .inspect(|files| {
-                info!(
-                    "Found {:?} tagged files, filtering down by search path {:?}",
-                    files.len(),
-                    search_path
-                )
-            })
-            .map(|tagged_files| {
-                tagged_files
-                    .into_iter()
-                    .filter(|f| {
-                        // When searching at the root, everything matches recursively
-                        if search_path.trim() == "" {
-                            return true;
-                        }
-
-                        f.file_name.starts_with(&format!(
-                            "{}/",
-                            search_path.strip_suffix('/').unwrap_or_else(|| search_path)
-                        ))
-                    })
-                    .collect::<Vec<FileWithTagCount>>()
-            })
-            .map(|files| sort(files, req.sort.unwrap_or(NameAsc)))
-            .inspect(|files| debug!("Found {:?} files", files.len()))
-            .map(|tagged_files: Vec<String>| {
-                info!(
-                    "Found {:?} tagged files: {:?}",
-                    tagged_files.len(),
-                    tagged_files
-                );
-                span_context
-                    .span()
-                    .set_attribute(KeyValue::new("file_count", tagged_files.len().to_string()));
-                span_context.span().set_status(Status::Ok);
-
-                HttpResponse::Ok().json(PhotosResponse {
-                    photos: tagged_files,
-                    dirs: vec![],
-                })
-            })
-            .into_http_internal_err()
-            .unwrap_or_else(|e| e.error_response());
         }
+        .context(format!(
+            "Failed to get files with tag_ids: {:?} with filter_mode: {:?}",
+            tag_ids, filter_mode
+        ))
+        .inspect(|files| {
+            info!(
+                "Found {:?} tagged files, filtering down by search path {:?}",
+                files.len(),
+                search_path
+            )
+        })
+        .map(|tagged_files| {
+            tagged_files
+                .into_iter()
+                .filter(|f| {
+                    // When searching at the root, everything matches recursively
+                    if search_path.trim() == "" {
+                        return true;
+                    }
+
+                    f.file_name.starts_with(&format!(
+                        "{}/",
+                        search_path.strip_suffix('/').unwrap_or_else(|| search_path)
+                    ))
+                })
+                .collect::<Vec<FileWithTagCount>>()
+        })
+        .map(|files| sort(files, req.sort.unwrap_or(NameAsc)))
+        .inspect(|files| debug!("Found {:?} files", files.len()))
+        .map(|tagged_files: Vec<String>| {
+            info!(
+                "Found {:?} tagged files: {:?}",
+                tagged_files.len(),
+                tagged_files
+            );
+            span_context
+                .span()
+                .set_attribute(KeyValue::new("file_count", tagged_files.len().to_string()));
+            span_context.span().set_status(Status::Ok);
+
+            HttpResponse::Ok().json(PhotosResponse {
+                photos: tagged_files,
+                dirs: vec![],
+            })
+        })
+        .into_http_internal_err()
+        .unwrap_or_else(|e| e.error_response());
+    }
 
     match file_system.get_files_for_path(search_path) {
         Ok(files) => {