Add sorting by a File's Tag Count

src/files.rs

@@ -19,9 +19,9 @@ use log::{debug, error, info, trace};
 use crate::data::{Claims, FilesRequest, FilterMode, PhotosResponse, SortType};
 use crate::{create_thumbnails, AppState};
 
-use crate::data::SortType::{NameAsc};
+use crate::data::SortType::NameAsc;
 use crate::error::IntoHttpError;
-use crate::tags::TagDao;
+use crate::tags::{FileWithTagCount, TagDao};
 use crate::video::StreamActor;
 use path_absolutize::*;
 use rand::prelude::SliceRandom;
@@ -68,6 +68,13 @@ pub async fn list_photos<TagD: TagDao, FS: FileSystemAccess>(
                 "Failed to get files with tag_ids: {:?} with filter_mode: {:?}",
                 tag_ids, filter_mode
             ))
+            .inspect(|files| {
+                debug!(
+                    "Found {:?} tagged files, filtering down by search path {:?}",
+                    files.len(),
+                    search_path
+                )
+            })
             .map(|tagged_files| {
                 tagged_files
                     .into_iter()
@@ -77,12 +84,12 @@ pub async fn list_photos<TagD: TagDao, FS: FileSystemAccess>(
                             return true;
                         }
 
-                        f.starts_with(&format!(
+                        f.file_name.starts_with(&format!(
                             "{}/",
                             search_path.strip_suffix('/').unwrap_or_else(|| search_path)
                         ))
                     })
-                    .collect::<Vec<String>>()
+                    .collect::<Vec<FileWithTagCount>>()
             })
             .map(|files| sort(files, req.sort.unwrap_or(NameAsc)))
             .inspect(|files| debug!("Found {:?} files", files.len()))
@@ -106,7 +113,7 @@ pub async fn list_photos<TagD: TagDao, FS: FileSystemAccess>(
     if let Ok(files) = file_system.get_files_for_path(search_path) {
         debug!("Valid search path: {:?}", search_path);
 
-        let mut photos = files
+        let photos = files
             .iter()
             .filter(|&f| {
                 f.metadata().map_or_else(
@@ -122,8 +129,14 @@ pub async fn list_photos<TagD: TagDao, FS: FileSystemAccess>(
                 relative.to_path_buf()
             })
             .map(|f| f.to_str().unwrap().to_string())
-            .filter(|file_path| {
-                if let (Some(tag_ids), Ok(mut tag_dao)) = (&req.tag_ids, tag_dao.lock()) {
+            .map(|file_name| {
+                let mut tag_dao = tag_dao.lock().expect("Unable to get TagDao");
+                let file_tags = tag_dao.get_tags_for_path(&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())
@@ -138,7 +151,6 @@ pub async fn list_photos<TagD: TagDao, FS: FileSystemAccess>(
                         .collect::<Vec<i32>>();
 
                     let filter_mode = &req.tag_filter_mode.unwrap_or(FilterMode::Any);
-                    let file_tags = tag_dao.get_tags_for_path(file_path).unwrap_or_default();
                     let excluded = file_tags.iter().any(|t| excluded_tag_ids.contains(&t.id));
 
                     return !excluded
@@ -152,11 +164,20 @@ pub async fn list_photos<TagD: TagDao, FS: FileSystemAccess>(
 
                 true
             })
-            .collect::<Vec<String>>();
+            .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);
-            photos = sort(photos, sort_type)
+            response_files = sort(photos, sort_type)
         }
 
         let dirs = files
@@ -169,25 +190,37 @@ pub async fn list_photos<TagD: TagDao, FS: FileSystemAccess>(
             .map(|f| f.to_str().unwrap().to_string())
             .collect::<Vec<String>>();
 
-        HttpResponse::Ok().json(PhotosResponse { photos, dirs })
+        HttpResponse::Ok().json(PhotosResponse {
+            photos: response_files,
+            dirs,
+        })
     } else {
         error!("Bad photos request: {}", req.path);
         HttpResponse::BadRequest().finish()
     }
 }
 
-fn sort(mut files: Vec<String>, sort_type: SortType) -> Vec<String> {
+fn sort(mut files: Vec<FileWithTagCount>, sort_type: SortType) -> Vec<String> {
     match sort_type {
         SortType::Shuffle => files.shuffle(&mut thread_rng()),
         SortType::NameAsc => {
-            files.sort();
+            files.sort_by(|l, r| l.file_name.cmp(&r.file_name));
         }
         SortType::NameDesc => {
-            files.sort_by(|l, r| r.cmp(l));
+            files.sort_by(|l, r| r.file_name.cmp(&l.file_name));
+        }
+        SortType::TagCountAsc => {
+            files.sort_by(|l, r| l.tag_count.cmp(&r.tag_count));
+        }
+        SortType::TagCountDesc => {
+            files.sort_by(|l, r| r.tag_count.cmp(&l.tag_count));
         }
     }
 
     files
+        .iter()
+        .map(|f| f.file_name.clone())
+        .collect::<Vec<String>>()
 }
 
 pub fn list_files(dir: &Path) -> io::Result<Vec<PathBuf>> {
@@ -396,10 +429,7 @@ mod tests {
             if self.err {
                 Err(anyhow!("Error for test"))
             } else if let Some(files) = self.files.get(path) {
-                Ok(files
-                    .iter()
-                    .map(PathBuf::from)
-                    .collect::<Vec<PathBuf>>())
+                Ok(files.iter().map(PathBuf::from).collect::<Vec<PathBuf>>())
             } else {
                 Ok(Vec::new())
             }