Add support for video duration, sorting, and entity updates

Introduce a duration field to videos with database migration and UI integration. Enhance search functionalities with sorting options and unreviewed video filters. Implement update endpoints for people and tags to enable renaming, ensuring name uniqueness validation.

Author: devclef

frontend/src/api/client.ts

@@ -22,6 +22,7 @@ export interface Video {
   file_size?: number;
   thumbnail_path?: string;
   rating?: number;
+  duration?: number;
   created_at: string;
   updated_at: string;
 }
@@ -60,6 +61,8 @@ export interface VideoSearchParams {
   limit?: number;
   offset?: number;
   unreviewed?: boolean;
+  sort_by?: string;
+  sort_order?: string;
 }
 
 export interface Tag {

frontend/src/components/SearchFilters.tsx

@@ -33,6 +33,8 @@ const SearchFilters: React.FC<SearchFiltersProps> = ({ onFilterChange }) => {
   const [selectedPeople, setSelectedPeople] = useState<SelectOption[]>([]);
   const [selectedRating, setSelectedRating] = useState<string>('');
   const [isUnreviewed, setIsUnreviewed] = useState<boolean>(false);
+  const [sortBy, setSortBy] = useState<string>('');
+  const [sortOrder, setSortOrder] = useState<string>('DESC');
   const [loading, setLoading] = useState(true);
 
   const bgColor = useColorModeValue('white', 'gray.800');
@@ -76,7 +78,9 @@ const SearchFilters: React.FC<SearchFiltersProps> = ({ onFilterChange }) => {
       tags: selectedTags.map(tag => tag.value),
       people: selectedPeople.map(person => person.value),
       rating: selectedRating ? parseInt(selectedRating, 10) : undefined,
-      unreviewed: isUnreviewed || undefined
+      unreviewed: isUnreviewed || undefined,
+      sort_by: sortBy || undefined,
+      sort_order: sortOrder || undefined
     });
   };
 
@@ -86,11 +90,15 @@ const SearchFilters: React.FC<SearchFiltersProps> = ({ onFilterChange }) => {
     setSelectedPeople([]);
     setSelectedRating('');
     setIsUnreviewed(false);
+    setSortBy('');
+    setSortOrder('DESC');
     onFilterChange({
       tags: undefined,
       people: undefined,
       rating: undefined,
-      unreviewed: undefined
+      unreviewed: undefined,
+      sort_by: undefined,
+      sort_order: undefined
     });
   };
 
@@ -172,6 +180,35 @@ const SearchFilters: React.FC<SearchFiltersProps> = ({ onFilterChange }) => {
           </Box>
         </SimpleGrid>
 
+        <SimpleGrid columns={{ base: 1, md: 2 }} spacing={4} mt={4}>
+          <Box>
+            <Heading size="sm" mb={2}>Sort By</Heading>
+            <ChakraSelect
+              value={sortBy}
+              onChange={(e) => setSortBy(e.target.value)}
+              placeholder="Default (Created Date)"
+            >
+              <option value="">Default (Created Date)</option>
+              <option value="duration">Duration</option>
+              <option value="title">Title</option>
+              <option value="rating">Rating</option>
+              <option value="file_size">File Size</option>
+              <option value="created_date">Created Date</option>
+            </ChakraSelect>
+          </Box>
+
+          <Box>
+            <Heading size="sm" mb={2}>Sort Order</Heading>
+            <ChakraSelect
+              value={sortOrder}
+              onChange={(e) => setSortOrder(e.target.value)}
+            >
+              <option value="ASC">Ascending</option>
+              <option value="DESC">Descending</option>
+            </ChakraSelect>
+          </Box>
+        </SimpleGrid>
+
         <Box mt={4}>
           <Checkbox
             isChecked={isUnreviewed}

frontend/src/components/VideoCard.tsx

@@ -40,8 +40,28 @@ const VideoCard: React.FC<VideoCardProps> = ({ video }) => {
   // Format date
   const formatDate = (dateString?: string): string => {
     if (!dateString) return 'Unknown date';
-    const date = new Date(dateString);
-    return date.toLocaleDateString();
+    try {
+      const date = new Date(dateString);
+      if (isNaN(date.getTime())) return 'Unknown date';
+      return date.toLocaleDateString();
+    } catch (e) {
+      return 'Unknown date';
+    }
+  };
+
+  // Format duration
+  const formatDuration = (seconds?: number): string => {
+    if (!seconds) return '';
+
+    const hours = Math.floor(seconds / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const remainingSeconds = seconds % 60;
+
+    if (hours > 0) {
+      return `${hours}:${minutes.toString().padStart(2, '0')}:${remainingSeconds.toString().padStart(2, '0')}`;
+    } else {
+      return `${minutes}:${remainingSeconds.toString().padStart(2, '0')}`;
+    }
   };
 
   // Render rating stars
@@ -99,9 +119,10 @@ const VideoCard: React.FC<VideoCardProps> = ({ video }) => {
           {formatDate(video.created_date)}
         </Text>
 
-        <Text fontSize="sm" color="gray.500" noOfLines={1}>
-          {formatFileSize(video.file_size)}
-        </Text>
+        <Flex fontSize="sm" color="gray.500" noOfLines={1} justifyContent="space-between">
+          <Text>{formatFileSize(video.file_size)}</Text>
+          {video.duration && <Text>{formatDuration(video.duration)}</Text>}
+        </Flex>
 
         {video.tags.length > 0 && (
           <Flex mt={3} flexWrap="wrap" gap={2}>

migrations/20250522000000_add_duration_column.sql

@@ -0,0 +1,7 @@
+-- Add duration column to videos table
+-- Up migration
+
+ALTER TABLE videos ADD COLUMN duration INTEGER;
+
+-- Down migration
+-- ALTER TABLE videos DROP COLUMN duration;

src/models/video.rs

@@ -14,6 +14,7 @@ pub struct Video {
     pub file_size: Option<i64>,
     pub thumbnail_path: Option<String>,
     pub rating: Option<i32>,
+    pub duration: Option<i64>,
     pub created_at: String,
     pub updated_at: String,
 }
@@ -57,6 +58,9 @@ pub struct VideoSearchParams {
     pub rating: Option<i32>,
     pub limit: Option<i64>,
     pub offset: Option<i64>,
+    pub unreviewed: Option<bool>,
+    pub sort_by: Option<String>,
+    pub sort_order: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -78,6 +82,7 @@ impl Video {
             file_size: None,
             thumbnail_path: None,
             rating: None,
+            duration: None,
             created_at: now.clone(),
             updated_at: now,
         }

src/routes/person.rs

@@ -1,6 +1,6 @@
 use axum::{
     extract::{Path, State},
-    routing::{get, post, delete},
+    routing::{get, post, delete, put},
     Json, Router,
 };
 
@@ -16,6 +16,7 @@ pub fn router(app_state: AppState) -> Router {
         .route("/usage", get(get_person_usage))
         .route("/cleanup", post(cleanup_unused_people))
         .route("/{id}", get(get_person))
+        .route("/{id}", put(update_person))
         .route("/{id}", delete(delete_person))
         .with_state(app_state)
 }
@@ -44,6 +45,16 @@ async fn create_person(
     Ok(Json(person))
 }
 
+async fn update_person(
+    State(state): State<AppState>,
+    Path(id): Path<String>,
+    Json(new_name): Json<String>,
+) -> Result<Json<crate::models::Person>> {
+    let person_service = PersonService::new(state.db.clone());
+    let person = person_service.update(&id, &new_name).await?;
+    Ok(Json(person))
+}
+
 async fn delete_person(
     State(state): State<AppState>,
     Path(id): Path<String>,

src/routes/tag.rs

@@ -1,6 +1,6 @@
 use axum::{
     extract::{Path, State},
-    routing::{get, post, delete},
+    routing::{get, post, delete, put},
     Json, Router,
 };
 
@@ -16,6 +16,7 @@ pub fn router(app_state: AppState) -> Router {
         .route("/usage", get(get_tag_usage))
         .route("/cleanup", post(cleanup_unused_tags))
         .route("/{id}", get(get_tag))
+        .route("/{id}", put(update_tag))
         .route("/{id}", delete(delete_tag))
         .with_state(app_state)
 }
@@ -44,6 +45,16 @@ async fn create_tag(
     Ok(Json(tag))
 }
 
+async fn update_tag(
+    State(state): State<AppState>,
+    Path(id): Path<String>,
+    Json(new_name): Json<String>,
+) -> Result<Json<crate::models::Tag>> {
+    let tag_service = TagService::new(state.db.clone());
+    let tag = tag_service.update(&id, &new_name).await?;
+    Ok(Json(tag))
+}
+
 async fn delete_tag(
     State(state): State<AppState>,
     Path(id): Path<String>,

src/services/person.rs

@@ -109,6 +109,40 @@ impl PersonService {
         Ok(person)
     }
 
+    pub async fn update(&self, id: &str, new_name: &str) -> Result<Person> {
+        // Check if person exists
+        let person = self.find_by_id(id).await?;
+
+        // Check if the new name already exists
+        let existing = sqlx::query_as::<_, Person>("SELECT * FROM people WHERE name = ? AND id != ?")
+            .bind(new_name)
+            .bind(id)
+            .fetch_optional(&self.db)
+            .await
+            .map_err(AppError::Database)?;
+
+        if existing.is_some() {
+            return Err(AppError::BadRequest(format!(
+                "Person with name '{}' already exists",
+                new_name
+            )));
+        }
+
+        // Update person
+        sqlx::query("UPDATE people SET name = ? WHERE id = ?")
+            .bind(new_name)
+            .bind(id)
+            .execute(&self.db)
+            .await
+            .map_err(AppError::Database)?;
+
+        info!("Updated person: {} -> {} ({})", person.name, new_name, id);
+
+        // Return updated person
+        let updated_person = self.find_by_id(id).await?;
+        Ok(updated_person)
+    }
+
     pub async fn delete(&self, id: &str) -> Result<()> {
         // Check if person exists
         let person = self.find_by_id(id).await?;

src/services/tag.rs

@@ -109,6 +109,40 @@ impl TagService {
         Ok(tag)
     }
 
+    pub async fn update(&self, id: &str, new_name: &str) -> Result<Tag> {
+        // Check if tag exists
+        let tag = self.find_by_id(id).await?;
+
+        // Check if the new name already exists
+        let existing = sqlx::query_as::<_, Tag>("SELECT * FROM tags WHERE name = ? AND id != ?")
+            .bind(new_name)
+            .bind(id)
+            .fetch_optional(&self.db)
+            .await
+            .map_err(AppError::Database)?;
+
+        if existing.is_some() {
+            return Err(AppError::BadRequest(format!(
+                "Tag with name '{}' already exists",
+                new_name
+            )));
+        }
+
+        // Update tag
+        sqlx::query("UPDATE tags SET name = ? WHERE id = ?")
+            .bind(new_name)
+            .bind(id)
+            .execute(&self.db)
+            .await
+            .map_err(AppError::Database)?;
+
+        info!("Updated tag: {} -> {} ({})", tag.name, new_name, id);
+
+        // Return updated tag
+        let updated_tag = self.find_by_id(id).await?;
+        Ok(updated_tag)
+    }
+
     pub async fn delete(&self, id: &str) -> Result<()> {
         // Check if tag exists
         let tag = self.find_by_id(id).await?;