251 lines
12 KiB
Rust
251 lines
12 KiB
Rust
use futures::StreamExt;
|
||
use gloo_net::eventsource::futures::EventSource;
|
||
use leptos::prelude::*;
|
||
use leptos::task::spawn_local;
|
||
use shared::{AppEvent, GlobalStats, NotificationLevel, Torrent};
|
||
use std::collections::HashMap;
|
||
use struct_patch::traits::Patch;
|
||
use base64::{Engine as _, engine::general_purpose::URL_SAFE_NO_PAD as BASE64_URL};
|
||
// use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64};
|
||
use wasm_bindgen::JsCast;
|
||
|
||
use crate::components::ui::toast::{ToastType, toast};
|
||
|
||
pub fn show_toast(level: NotificationLevel, message: impl Into<String>) {
|
||
let msg = message.into();
|
||
gloo_console::log!("TOAST CALL:", &msg, format!("{:?}", level));
|
||
log::info!("Displaying toast: [{:?}] {}", level, msg);
|
||
|
||
let variant = match level {
|
||
NotificationLevel::Success => ToastType::Success,
|
||
NotificationLevel::Error => ToastType::Error,
|
||
NotificationLevel::Warning => ToastType::Warning,
|
||
NotificationLevel::Info => ToastType::Info,
|
||
};
|
||
|
||
toast(msg, variant);
|
||
}
|
||
|
||
pub fn toast_success(message: impl Into<String>) { show_toast(NotificationLevel::Success, message); }
|
||
pub fn toast_error(message: impl Into<String>) { show_toast(NotificationLevel::Error, message); }
|
||
|
||
pub fn get_action_messages(action: &str) -> (&'static str, &'static str) {
|
||
match action {
|
||
"start" => ("Torrent başlatıldı", "Torrent başlatılamadı"),
|
||
"stop" => ("Torrent durduruldu", "Torrent durdurulamadı"),
|
||
"pause" => ("Torrent duraklatıldı", "Torrent duraklatılamadı"),
|
||
"delete" => ("Torrent silindi", "Torrent silinemedi"),
|
||
"delete_with_data" => ("Torrent ve verileri silindi", "Torrent silinemedi"),
|
||
"recheck" => ("Torrent kontrol ediliyor", "Kontrol başlatılamadı"),
|
||
_ => ("İşlem tamamlandı", "İşlem başarısız"),
|
||
}
|
||
}
|
||
|
||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||
pub enum FilterStatus {
|
||
All, Downloading, Seeding, Completed, Paused, Inactive, Active, Error,
|
||
}
|
||
|
||
#[derive(Clone, Copy, Debug)]
|
||
pub struct TorrentStore {
|
||
pub torrents: RwSignal<HashMap<String, Torrent>>,
|
||
pub filter: RwSignal<FilterStatus>,
|
||
pub search_query: RwSignal<String>,
|
||
pub global_stats: RwSignal<GlobalStats>,
|
||
pub user: RwSignal<Option<String>>,
|
||
pub selected_torrent: RwSignal<Option<String>>,
|
||
pub push_enabled: RwSignal<bool>,
|
||
}
|
||
|
||
pub fn provide_torrent_store() {
|
||
let torrents = RwSignal::new(HashMap::new());
|
||
let filter = RwSignal::new(FilterStatus::All);
|
||
let search_query = RwSignal::new(String::new());
|
||
let global_stats = RwSignal::new(GlobalStats::default());
|
||
let user = RwSignal::new(Option::<String>::None);
|
||
let selected_torrent = RwSignal::new(Option::<String>::None);
|
||
let push_enabled = RwSignal::new(false);
|
||
|
||
let show_browser_notification = crate::utils::notification::use_app_notification();
|
||
|
||
let store = TorrentStore { torrents, filter, search_query, global_stats, user, selected_torrent, push_enabled };
|
||
provide_context(store);
|
||
|
||
// Initial check for push status
|
||
spawn_local(async move {
|
||
if let Ok(enabled) = is_push_subscribed().await {
|
||
push_enabled.set(enabled);
|
||
}
|
||
});
|
||
|
||
let global_stats_for_sse = global_stats;
|
||
let torrents_for_sse = torrents;
|
||
let show_browser_notification = show_browser_notification.clone();
|
||
|
||
spawn_local(async move {
|
||
let mut backoff_ms: u32 = 1000;
|
||
let mut was_connected = false;
|
||
let mut disconnect_notified = false;
|
||
|
||
loop {
|
||
let es_result = EventSource::new("/api/events");
|
||
match es_result {
|
||
Ok(mut es) => {
|
||
if let Ok(mut stream) = es.subscribe("message") {
|
||
let mut got_first_message = false;
|
||
while let Some(Ok((_, msg))) = stream.next().await {
|
||
if !got_first_message {
|
||
got_first_message = true;
|
||
backoff_ms = 1000;
|
||
if was_connected && disconnect_notified {
|
||
show_toast(NotificationLevel::Success, "Sunucu bağlantısı yeniden kuruldu");
|
||
disconnect_notified = false;
|
||
}
|
||
was_connected = true;
|
||
}
|
||
|
||
if let Some(data_str) = msg.data().as_string() {
|
||
if let Ok(bytes) = BASE64.decode(&data_str) {
|
||
if let Ok(event) = rmp_serde::from_slice::<AppEvent>(&bytes) {
|
||
match event {
|
||
AppEvent::FullList(list, _) => {
|
||
torrents_for_sse.update(|map| {
|
||
let new_hashes: std::collections::HashSet<String> = list.iter().map(|t| t.hash.clone()).collect();
|
||
map.retain(|hash, _| new_hashes.contains(hash));
|
||
for new_torrent in list { map.insert(new_torrent.hash.clone(), new_torrent); }
|
||
});
|
||
}
|
||
AppEvent::Update(patch) => {
|
||
if let Some(hash) = patch.hash.clone() {
|
||
torrents_for_sse.update(|map| { if let Some(t) = map.get_mut(&hash) { t.apply(patch); } });
|
||
}
|
||
}
|
||
AppEvent::Stats(stats) => { global_stats_for_sse.set(stats); }
|
||
AppEvent::Notification(n) => {
|
||
show_toast(n.level.clone(), n.message.clone());
|
||
if n.message.contains("tamamlandı") || n.level == shared::NotificationLevel::Error {
|
||
show_browser_notification("VibeTorrent", &n.message);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if was_connected && !disconnect_notified {
|
||
show_toast(NotificationLevel::Warning, "Sunucu bağlantısı kesildi, yeniden bağlanılıyor...");
|
||
disconnect_notified = true;
|
||
}
|
||
}
|
||
}
|
||
Err(_) => {
|
||
if was_connected && !disconnect_notified {
|
||
show_toast(NotificationLevel::Warning, "Sunucu bağlantısı kurulamıyor...");
|
||
disconnect_notified = true;
|
||
}
|
||
}
|
||
}
|
||
gloo_timers::future::TimeoutFuture::new(backoff_ms).await;
|
||
backoff_ms = std::cmp::min(backoff_ms * 2, 30000);
|
||
}
|
||
});
|
||
}
|
||
|
||
pub async fn is_push_subscribed() -> Result<bool, String> {
|
||
let window = web_sys::window().ok_or("no window")?;
|
||
let navigator = window.navigator();
|
||
let sw_container = navigator.service_worker();
|
||
|
||
let registration = wasm_bindgen_futures::JsFuture::from(sw_container.ready().map_err(|e| format!("{:?}", e))?)
|
||
.await
|
||
.map_err(|e| format!("{:?}", e))?
|
||
.dyn_into::<web_sys::ServiceWorkerRegistration>()
|
||
.map_err(|_| "not a registration")?;
|
||
|
||
let push_manager = registration.push_manager().map_err(|e| format!("{:?}", e))?;
|
||
let subscription = wasm_bindgen_futures::JsFuture::from(push_manager.get_subscription().map_err(|e| format!("{:?}", e))?)
|
||
.await
|
||
.map_err(|e| format!("{:?}", e))?;
|
||
|
||
Ok(!subscription.is_null())
|
||
}
|
||
|
||
pub async fn subscribe_to_push_notifications() {
|
||
let window = web_sys::window().expect("no window");
|
||
let navigator = window.navigator();
|
||
let sw_container = navigator.service_worker();
|
||
|
||
let registration = match wasm_bindgen_futures::JsFuture::from(sw_container.ready().expect("sw not ready")).await {
|
||
Ok(reg) => reg.dyn_into::<web_sys::ServiceWorkerRegistration>().expect("not a reg"),
|
||
Err(e) => { log::error!("SW Ready Error: {:?}", e); return; }
|
||
};
|
||
|
||
// 1. Get Public Key from Backend
|
||
let public_key_res: Result<String, _> = shared::server_fns::push::get_public_key().await;
|
||
let public_key = match public_key_res {
|
||
Ok(key) => key,
|
||
Err(e) => { log::error!("Failed to get public key: {:?}", e); return; }
|
||
};
|
||
|
||
// 2. Convert base64 key to Uint8Array
|
||
let decoded_key = BASE64_URL.decode(public_key.trim()).expect("invalid public key");
|
||
let key_array = js_sys::Uint8Array::from(&decoded_key[..]);
|
||
|
||
// 3. Prepare Options
|
||
let options = web_sys::PushSubscriptionOptionsInit::new();
|
||
options.set_user_visible_only(true);
|
||
options.set_application_server_key(&key_array.into());
|
||
|
||
// 4. Subscribe
|
||
let push_manager = registration.push_manager().expect("no push manager");
|
||
match wasm_bindgen_futures::JsFuture::from(push_manager.subscribe_with_options(&options).expect("subscribe failed")).await {
|
||
Ok(subscription) => {
|
||
let sub_js = subscription.clone();
|
||
|
||
// Use JS to extract JSON string representation
|
||
let json_str = js_sys::JSON::stringify(&sub_js).expect("stringify failed").as_string().expect("not a string");
|
||
let sub_obj: serde_json::Value = serde_json::from_str(&json_str).expect("serde from str failed");
|
||
|
||
let endpoint = sub_obj["endpoint"].as_str().expect("no endpoint").to_string();
|
||
let p256dh = sub_obj["keys"]["p256dh"].as_str().expect("no p256dh").to_string();
|
||
let auth = sub_obj["keys"]["auth"].as_str().expect("no auth").to_string();
|
||
|
||
// 5. Save to Backend
|
||
match shared::server_fns::push::subscribe_push(endpoint, p256dh, auth).await {
|
||
Ok(_) => {
|
||
log::info!("Push subscription saved successfully");
|
||
toast_success("Bildirimler aktif edildi");
|
||
}
|
||
Err(e) => log::error!("Failed to save subscription: {:?}", e),
|
||
}
|
||
}
|
||
Err(e) => log::error!("Subscription Error: {:?}", e),
|
||
}
|
||
}
|
||
|
||
pub async fn unsubscribe_from_push_notifications() {
|
||
let window = web_sys::window().expect("no window");
|
||
let sw_container = window.navigator().service_worker();
|
||
|
||
let registration = wasm_bindgen_futures::JsFuture::from(sw_container.ready().expect("sw not ready")).await
|
||
.unwrap().dyn_into::<web_sys::ServiceWorkerRegistration>().unwrap();
|
||
|
||
let push_manager = registration.push_manager().unwrap();
|
||
if let Ok(sub_future) = push_manager.get_subscription() {
|
||
if let Ok(subscription) = wasm_bindgen_futures::JsFuture::from(sub_future).await {
|
||
if !subscription.is_null() {
|
||
let sub = subscription.dyn_into::<web_sys::PushSubscription>().unwrap();
|
||
let endpoint = sub.endpoint();
|
||
|
||
// 1. Unsubscribe in Browser
|
||
let _ = wasm_bindgen_futures::JsFuture::from(sub.unsubscribe().unwrap()).await;
|
||
|
||
// 2. Remove from Backend
|
||
let _ = shared::server_fns::push::unsubscribe_push(endpoint).await;
|
||
log::info!("Push subscription removed");
|
||
show_toast(NotificationLevel::Info, "Bildirimler kapatıldı");
|
||
}
|
||
}
|
||
}
|
||
}
|