Function Explore

src/pages/explore.rs:57–282

()

#[tracing::instrument(level = "debug", skip())]
#[component]
pub fn Explore() -> impl IntoView {
    let provider_store: Arc<ProviderStore> = expect_context();
    let provider_keys = provider_store.get_provider_keys(ExtensionProviderScope::Recommendations);
    let suggestion_items = RwSignal::new(vec![]);
    let analytics = RwSignal::<Option<AllAnalyticsParsed>>::new(None);
    spawn_local(async move {
        if let Ok(a) = get_top_listened_songs().await {
            tracing::debug!("Got analytics {:?}, {:?}", a, a.songs.len());
            analytics.set(Some(AllAnalyticsParsed {
                total_listen_time: a.total_listen_time,
                songs: vec![],
            }));
            for (song_id, time) in a.songs {
                let provider = get_provider_key_by_id(song_id.clone()).await;
                if let Ok(provider) = provider {
                    let song = get_song_from_id(provider.clone(), song_id).await;
                    match song {
                        Ok(song) => {
                            analytics.update(|a| {
                                if let Some(a) = a.as_mut() {
                                    a.songs.push((song, time))
                                }
                            });
                        }
                        Err(e) => tracing::error!("Failed to fetch song from {} {:?}", provider, e),
                    }
                } else {
                    let song = get_songs_by_options(GetSongOptions {
                        song: Some(SearchableSong {
                            _id: Some(song_id),
                            ..Default::default()
                        }),
                        ..Default::default()
                    })
                    .await;
                    if let Ok(song) = song {
                        if let Some(song) = song.first() {
                            analytics.update(|a| {
                                if let Some(a) = a.as_mut() {
                                    a.songs.push((song.clone(), time))
                                }
                            });
                        }
                    }
                }
            }
        }
    });

    spawn_local(async move {
        for key in provider_keys {
            let suggestions = get_suggestions(key).await;
            if let Ok(suggestions) = suggestions {
                suggestion_items.update(|s| s.extend(suggestions));
            }
        }
    });
    let total_time = create_read_slice(analytics, |a| a.as_ref().map(|a| a.total_listen_time));