Persistent query params (#902)

* fix(frontend): do not pass default tab as search params default

* feat(frontend): basic component to save search params

* refactor(frontend): function to get whether workout is active

* feat(frontend): better cookie support

* fix(frontend): change position of affix

* refactor(frontend): extract common query param

* feat(frontend): enhanced hook for query param

* feat(frontend): utility to respect new params

* refactor(frontend): functions to enhance redirect

* fix(frontend): do not include non-encodeable stuff in query params

* feat(frontend): use more predictable cookie names

* fix(frontend): use new strategy to enhance queries

* feat(frontend): allow persisting for exercises list

* feat(frontend): more intelligent workout selection

* feat(frontend): add tooltip to affix

* feat(frontend): remove useless query params

* refactor(frontend): change name of module

* refactor(frontend): do not expose timer atom directly

* feat(frontend): basic atom for measurements drawer

* chore(frontend): import from new module

* feat(frontend): add log when login for oidc fails

* feat(frontend): allow opening measurements from anywhere

* feat(frontend): log when register fails

* chore(frontend): add more logging

* feat(frontend): use enhanced query params on media list page

* feat(frontend): use enhanced query params on person list page

* feat(frontend): also remember query params

* fix(frontend): get measurements creation working

* build(ts): upgrade deps

* fix(frontend): order of loader returns

* fix(frontend): layout of filter off icon

* chore(backend): order of attributes

* feat(frontend): add new preference param

* feat(database): migration to add new general preference

* chore(backend): order of attributes

* feat(frontend): new preference

* feat(frontend): respect new user preference

* feat(frontend): new schema for measurement creation

* Revert "feat(frontend): new schema for measurement creation"

This reverts commit 151f43b.

* refactor(backend): do not create custom items from media_tracker

* chore(backend): remove useless field from this

Author: IgnisDa

apps/backend/src/importer/audiobookshelf.rs

@@ -14,10 +14,7 @@ use crate::{
     entities::metadata,
     importer::{ImportFailStep, ImportFailedItem, ImportResult},
     miscellaneous::{audiobookshelf_models, itunes_podcast_episode_by_name},
-    models::media::{
-        CommitMediaInput, ImportOrExportItemIdentifier, ImportOrExportMediaItem,
-        ImportOrExportMediaItemSeen,
-    },
+    models::media::{CommitMediaInput, ImportOrExportMediaItem, ImportOrExportMediaItemSeen},
     providers::google_books::GoogleBooksService,
     utils::get_base_http_client,
 };
@@ -159,10 +156,9 @@ where
             media.push(ImportOrExportMediaItem {
                 lot,
                 source,
-                source_id: metadata.title,
-                identifier: "".to_string(),
-                internal_identifier: Some(ImportOrExportItemIdentifier::NeedsDetails(identifier)),
+                identifier,
                 seen_history,
+                source_id: metadata.title,
                 collections: vec![],
                 reviews: vec![],
             })

apps/backend/src/importer/generic_json.rs

@@ -7,7 +7,7 @@ use itertools::Itertools;
 use crate::{
     fitness::resolver::ExerciseService,
     importer::{DeployJsonImportInput, ImportResult},
-    models::{media::ImportOrExportItemIdentifier, CompleteExport},
+    models::CompleteExport,
 };
 
 pub async fn import(
@@ -22,9 +22,6 @@ pub async fn import(
         .unwrap_or_default()
         .iter_mut()
         .map(|m| {
-            m.internal_identifier = Some(ImportOrExportItemIdentifier::NeedsDetails(
-                m.identifier.clone(),
-            ));
             m.seen_history.iter_mut().for_each(|s| {
                 s.provider_watched_on = Some(ImportSource::GenericJson.to_string());
             });

apps/backend/src/importer/goodreads.rs

@@ -11,8 +11,8 @@ use serde::Deserialize;
 use crate::{
     importer::{DeployGenericCsvImportInput, ImportFailStep, ImportFailedItem, ImportResult},
     models::media::{
-        ImportOrExportItemIdentifier, ImportOrExportItemRating, ImportOrExportItemReview,
-        ImportOrExportMediaItem, ImportOrExportMediaItemSeen,
+        ImportOrExportItemRating, ImportOrExportItemReview, ImportOrExportMediaItem,
+        ImportOrExportMediaItemSeen,
     },
     providers::google_books::GoogleBooksService,
 };
@@ -127,8 +127,7 @@ pub async fn import(
                 source_id: record.title.clone(),
                 lot,
                 source,
-                identifier: "".to_string(),
-                internal_identifier: Some(ImportOrExportItemIdentifier::NeedsDetails(identifier)),
+                identifier,
                 seen_history,
                 reviews,
                 collections,

apps/backend/src/importer/igdb.rs

@@ -7,9 +7,7 @@ use serde::Deserialize;
 
 use crate::{
     miscellaneous::DefaultCollection,
-    models::media::{
-        ImportOrExportItemIdentifier, ImportOrExportMediaItem, ImportOrExportMediaItemSeen,
-    },
+    models::media::{ImportOrExportMediaItem, ImportOrExportMediaItemSeen},
 };
 
 use super::{DeployIgdbImportInput, ImportFailStep, ImportFailedItem, ImportResult};
@@ -56,13 +54,12 @@ pub async fn import(input: DeployIgdbImportInput) -> Result<ImportResult> {
             }
         };
         media.push(ImportOrExportMediaItem {
-            collections: vec![collection.clone()],
-            internal_identifier: Some(ImportOrExportItemIdentifier::NeedsDetails(record.id)),
             lot,
             source,
             source_id: record.game,
-            identifier: "".to_string(),
+            identifier: record.id,
             seen_history: seen_history.clone(),
+            collections: vec![collection.clone()],
             reviews: vec![],
         });
     }

apps/backend/src/importer/imdb.rs

@@ -7,7 +7,7 @@ use serde::Deserialize;
 use crate::{
     importer::{DeployGenericCsvImportInput, ImportFailStep, ImportFailedItem, ImportResult},
     miscellaneous::DefaultCollection,
-    models::media::{ImportOrExportItemIdentifier, ImportOrExportMediaItem},
+    models::media::ImportOrExportMediaItem,
     providers::tmdb::NonMediaTmdbService,
 };
 
@@ -58,7 +58,7 @@ pub async fn import(
                 continue;
             }
         };
-        let tmdb_identifier = match tmdb_service
+        let identifier = match tmdb_service
             .find_by_external_id(&record.id, "imdb_id")
             .await
         {
@@ -73,14 +73,13 @@ pub async fn import(
                 continue;
             }
         };
-        tracing::debug!("Found tmdb id: {} ({}/{})", tmdb_identifier, idx + 1, total);
+        tracing::debug!("Found tmdb id: {} ({}/{})", identifier, idx + 1, total);
         media.push(ImportOrExportMediaItem {
-            collections: vec![DefaultCollection::Watchlist.to_string()],
-            identifier: "".to_string(),
-            internal_identifier: Some(ImportOrExportItemIdentifier::NeedsDetails(tmdb_identifier)),
+            identifier,
             lot,
             source,
             source_id: record.id,
+            collections: vec![DefaultCollection::Watchlist.to_string()],
             reviews: vec![],
             seen_history: vec![],
         });

apps/backend/src/importer/jellyfin.rs

@@ -13,9 +13,7 @@ use crate::{
     importer::{
         DeployUrlAndKeyAndUsernameImportInput, ImportFailStep, ImportFailedItem, ImportResult,
     },
-    models::media::{
-        ImportOrExportItemIdentifier, ImportOrExportMediaItem, ImportOrExportMediaItemSeen,
-    },
+    models::media::{ImportOrExportMediaItem, ImportOrExportMediaItemSeen},
     utils::{JSON, USER_AGENT_STR},
 };
 
@@ -175,9 +173,6 @@ pub async fn import(input: DeployUrlAndKeyAndUsernameImportInput) -> Result<Impo
                 lot,
                 source_id: item.series_name.unwrap_or(item.name),
                 source: MediaSource::Tmdb,
-                internal_identifier: Some(ImportOrExportItemIdentifier::NeedsDetails(
-                    tmdb_id.clone(),
-                )),
                 seen_history: vec![seen],
                 identifier: tmdb_id,
                 reviews: vec![],

apps/backend/src/importer/mal.rs

@@ -16,8 +16,7 @@ use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use crate::{
     importer::{DeployMalImportInput, ImportResult},
     models::media::{
-        ImportOrExportItemIdentifier, ImportOrExportItemRating, ImportOrExportMediaItem,
-        ImportOrExportMediaItemSeen,
+        ImportOrExportItemRating, ImportOrExportMediaItem, ImportOrExportMediaItemSeen,
     },
 };
 
@@ -91,14 +90,11 @@ fn convert_to_format(item: Item, lot: MediaLot) -> ImportOrExportMediaItem {
         ..Default::default()
     };
     ImportOrExportMediaItem {
-        source_id: item.title.clone(),
         lot,
         source: MediaSource::Mal,
-        identifier: "".to_string(),
-        internal_identifier: Some(ImportOrExportItemIdentifier::NeedsDetails(
-            item.identifier.to_string(),
-        )),
+        identifier: item.identifier.to_string(),
         seen_history,
+        source_id: item.title.clone(),
         reviews: vec![review_item],
         collections: vec![],
     }

apps/backend/src/importer/media_tracker.rs

@@ -1,6 +1,5 @@
 use async_graphql::Result;
 use database::{ImportSource, MediaLot, MediaSource};
-use nanoid::nanoid;
 use reqwest::{
     header::{HeaderMap, HeaderValue, USER_AGENT},
     ClientBuilder,
@@ -18,9 +17,8 @@ use crate::{
     },
     models::{
         media::{
-            BookSpecifics, CreateOrUpdateCollectionInput, ImportOrExportItemIdentifier,
-            ImportOrExportItemRating, ImportOrExportItemReview, ImportOrExportMediaItemSeen,
-            MediaDetails, MetadataFreeCreator,
+            CreateOrUpdateCollectionInput, ImportOrExportItemRating, ImportOrExportItemReview,
+            ImportOrExportMediaItemSeen,
         },
         IdObject,
     },
@@ -116,13 +114,6 @@ struct ItemSeen {
     episode_id: Option<i32>,
 }
 
-#[derive(Debug, Serialize, Deserialize, Clone)]
-#[serde(untagged)]
-enum ItemNumberOfPages {
-    Nothing(String),
-    Something(i32),
-}
-
 #[derive(Debug, Serialize, Deserialize, Clone)]
 #[serde(rename_all = "camelCase")]
 struct ItemDetails {
@@ -135,10 +126,6 @@ struct ItemDetails {
     tmdb_id: Option<i32>,
     openlibrary_id: Option<String>,
     goodreads_id: Option<i32>,
-    title: String,
-    overview: Option<String>,
-    authors: Option<Vec<String>>,
-    number_of_pages: Option<ItemNumberOfPages>,
 }
 
 pub async fn import(input: DeployUrlAndKeyImportInput) -> Result<ImportResult> {
@@ -244,7 +231,13 @@ pub async fn import(input: DeployUrlAndKeyImportInput) -> Result<ImportResult> {
         let (identifier, source) = match media_type {
             MediaType::Book => {
                 if let Some(_g_id) = details.goodreads_id {
-                    (nanoid!(10), MediaSource::Custom)
+                    failed_items.push(ImportFailedItem {
+                        lot: Some(lot),
+                        step: ImportFailStep::ItemDetailsFromSource,
+                        identifier: d.id.to_string(),
+                        error: Some("Goodreads ID not supported".to_string()),
+                    });
+                    continue;
                 } else {
                     (
                         get_key(&details.openlibrary_id.clone().unwrap()),
@@ -265,7 +258,6 @@ pub async fn import(input: DeployUrlAndKeyImportInput) -> Result<ImportResult> {
             total = data_len,
             seen = details.seen_history.len()
         );
-        let need_details = details.goodreads_id.is_none();
 
         let mut collections = vec![];
         for list in lists.iter() {
@@ -276,52 +268,12 @@ pub async fn import(input: DeployUrlAndKeyImportInput) -> Result<ImportResult> {
             }
         }
 
-        let num_pages = details.number_of_pages.and_then(|d| match d {
-            ItemNumberOfPages::Nothing(_) => None,
-            ItemNumberOfPages::Something(s) => Some(s),
-        });
-
         let item = ImportOrExportMediaItem {
             source_id: d.id.to_string(),
             source,
             lot,
             collections,
-            identifier: "".to_string(),
-            internal_identifier: Some(match need_details {
-                false => ImportOrExportItemIdentifier::AlreadyFilled(Box::new(MediaDetails {
-                    identifier,
-                    title: details.title,
-                    description: details.overview,
-                    lot,
-                    source: MediaSource::Custom,
-                    creators: details
-                        .authors
-                        .unwrap_or_default()
-                        .into_iter()
-                        .map(|a| MetadataFreeCreator {
-                            name: a,
-                            role: "Author".to_owned(),
-                            image: None,
-                        })
-                        .collect(),
-                    provider_rating: None,
-                    genres: vec![],
-                    url_images: vec![],
-                    videos: vec![],
-                    publish_year: None,
-                    publish_date: None,
-                    suggestions: vec![],
-                    group_identifiers: vec![],
-                    is_nsfw: None,
-                    production_status: None,
-                    people: vec![],
-                    s3_images: vec![],
-                    original_language: None,
-                    book_specifics: Some(BookSpecifics { pages: num_pages }),
-                    ..Default::default()
-                })),
-                true => ImportOrExportItemIdentifier::NeedsDetails(identifier),
-            }),
+            identifier,
             reviews: Vec::from_iter(details.user_rating.map(|r| {
                 let review = if let Some(_s) = r.clone().review {
                     Some(ImportOrExportItemReview {

apps/backend/src/importer/mod.rs

@@ -23,9 +23,8 @@ use crate::{
         fitness::UserWorkoutInput,
         media::{
             CommitMediaInput, CommitPersonInput, CreateOrUpdateCollectionInput,
-            ImportOrExportItemIdentifier, ImportOrExportItemRating, ImportOrExportMediaGroupItem,
-            ImportOrExportMediaItem, ImportOrExportPersonItem, PostReviewInput,
-            ProgressUpdateInput,
+            ImportOrExportItemRating, ImportOrExportMediaGroupItem, ImportOrExportMediaItem,
+            ImportOrExportPersonItem, PostReviewInput, ProgressUpdateInput,
         },
         BackgroundJob, ChangeCollectionToEntityInput,
     },
@@ -341,24 +340,16 @@ impl ImporterService {
                 iden = &item.source_id
             );
             let rev_length = item.reviews.len();
-            let identifier = item.internal_identifier.clone().unwrap();
-            let data = match identifier {
-                ImportOrExportItemIdentifier::NeedsDetails(identifier) => {
-                    self.media_service
-                        .commit_metadata(CommitMediaInput {
-                            identifier,
-                            lot: item.lot,
-                            source: item.source,
-                            force_update: Some(true),
-                        })
-                        .await
-                }
-                ImportOrExportItemIdentifier::AlreadyFilled(a) => {
-                    self.media_service
-                        .commit_metadata_internal(*a.clone(), None)
-                        .await
-                }
-            };
+            let identifier = item.identifier.clone();
+            let data = self
+                .media_service
+                .commit_metadata(CommitMediaInput {
+                    identifier,
+                    lot: item.lot,
+                    source: item.source,
+                    force_update: Some(true),
+                })
+                .await;
             let metadata = match data {
                 Ok(r) => r,
                 Err(e) => {

apps/backend/src/importer/movary.rs

@@ -9,8 +9,8 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     importer::{
-        DeployMovaryImportInput, ImportFailStep, ImportFailedItem, ImportOrExportItemIdentifier,
-        ImportOrExportMediaItem, ImportResult,
+        DeployMovaryImportInput, ImportFailStep, ImportFailedItem, ImportOrExportMediaItem,
+        ImportResult,
     },
     miscellaneous::DefaultCollection,
     models::media::{
@@ -65,10 +65,7 @@ pub async fn import(input: DeployMovaryImportInput) -> Result<ImportResult> {
             source_id: record.common.title.clone(),
             lot,
             source,
-            internal_identifier: Some(ImportOrExportItemIdentifier::NeedsDetails(
-                record.common.tmdb_id.to_string(),
-            )),
-            identifier: "".to_string(),
+            identifier: record.common.tmdb_id.to_string(),
             seen_history: vec![],
             reviews: vec![ImportOrExportItemRating {
                 // DEV: Rates items out of 10
@@ -96,10 +93,7 @@ pub async fn import(input: DeployMovaryImportInput) -> Result<ImportResult> {
             source_id: record.title.clone(),
             lot,
             source,
-            internal_identifier: Some(ImportOrExportItemIdentifier::NeedsDetails(
-                record.tmdb_id.to_string(),
-            )),
-            identifier: "".to_string(),
+            identifier: record.tmdb_id.to_string(),
             seen_history: vec![],
             reviews: vec![],
             collections: vec![DefaultCollection::Watchlist.to_string()],
@@ -159,10 +153,7 @@ pub async fn import(input: DeployMovaryImportInput) -> Result<ImportResult> {
                 source_id: record.common.title.clone(),
                 lot,
                 source,
-                identifier: "".to_string(),
-                internal_identifier: Some(ImportOrExportItemIdentifier::NeedsDetails(
-                    record.common.tmdb_id.to_string(),
-                )),
+                identifier: record.common.tmdb_id.to_string(),
                 seen_history: vec![seen_item],
                 reviews,
                 collections: vec![],