Merge pull request #559 from solomon35-stack/fix/solomon35-stack-issues-440-441-442-443

fix: resolve issues #440 #441 #442 #443 (solomon35-stack)

Author: LaGodxy

contracts/analytics/src/errors.rs

@@ -51,4 +51,6 @@ pub enum AnalyticsError {
     InvalidInsightData = 22,
     /// No insight record was found with the given ID.
     InsightNotFound = 23,
+    /// Timestamp is not a valid UTC Unix epoch second (Issue #442: DST fix).
+    InvalidTimestamp = 24,
 }

contracts/analytics/src/lib.rs

@@ -27,6 +27,7 @@ use shared::event_schema::{
     SessionRecordedEvent,
 };
 use shared::monitoring::{ContractHealthReport, Monitor};
+use shared::timestamp_utils::{utc_day_index, validate_utc_timestamp};
 use shared::{emit_access_control_event, emit_analytics_event};
 use soroban_sdk::{
     contract, contractimpl, contracttype, symbol_short, Address, BytesN, Env, String, Symbol, Vec,
@@ -120,11 +121,12 @@ fn update_progress_analytics(
         });
     }
 
-    // Streak calculation
-    let current_day = end_time / 86400;
+    // Streak calculation — use UTC day index to avoid DST off-by-one (Issue #442).
+    // utc_day_index() divides by SECS_PER_DAY after normalising to UTC midnight,
+    // so a DST transition never shifts the day boundary.
+    let current_day = utc_day_index(end_time);
     let prev_day = if analytics.total_sessions > 1 {
-        let prev_last = analytics.last_activity.saturating_sub(time_spent);
-        prev_last / 86400
+        utc_day_index(analytics.last_activity)
     } else {
         current_day
     };
@@ -421,6 +423,11 @@ impl Analytics {
 
         session.student.require_auth();
 
+        // Issue #442: validate that end_time is a plausible UTC epoch second.
+        // This rejects millisecond-precision values and local-time offsets that
+        // would cause DST off-by-one errors in streak / day-range calculations.
+        validate_utc_timestamp(end_time).map_err(|_| AnalyticsError::InvalidTimestamp)?;
+
         let time_spent = end_time.saturating_sub(session.start_time);
 
         session.end_time = end_time;
@@ -865,13 +872,13 @@ impl Analytics {
         if start_date >= end_date {
             return result;
         }
-        let mut current = (start_date / 86400) * 86400;
-        let end_day = (end_date / 86400) * 86400;
+        let mut current = utc_day_index(start_date) * shared::timestamp_utils::SECS_PER_DAY;
+        let end_day = utc_day_index(end_date) * shared::timestamp_utils::SECS_PER_DAY;
         while current <= end_day {
             if let Some(metrics) = AnalyticsStorage::get_daily_metrics(&env, &course_id, current) {
                 result.push_back(metrics);
             }
-            current += 86400;
+            current += shared::timestamp_utils::SECS_PER_DAY;
         }
         result
     }

contracts/mobile-optimizer/src/pwa_manager.rs

@@ -1,7 +1,20 @@
-use soroban_sdk::{contracttype, Address, Env, String, Vec};
+use soroban_sdk::{contracttype, symbol_short, Address, Env, String, Vec};
 
 use crate::types::*;
 
+// ─── Storage keys for new PWA features ────────────────────────────────────────
+
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+enum PwaExtKey {
+    /// Pending push notifications for a user.
+    PushQueue(Address),
+    /// Install prompt history for a user.
+    InstallHistory(Address),
+    /// Global PWA metrics.
+    Metrics,
+}
+
 pub struct PwaManager;
 
 impl PwaManager {
@@ -231,6 +244,233 @@ impl PwaManager {
             start_url: String::from_str(env, "/dashboard"),
         }
     }
+
+    // ── Push Notifications (Issue #440) ───────────────────────────────────────
+
+    /// Queue a push notification for `recipient`.
+    ///
+    /// The notification is stored on-chain so the off-chain push service can
+    /// poll and deliver it.  Returns `Err` if the recipient has no active push
+    /// subscription.
+    pub fn send_push_notification(
+        env: &Env,
+        notification: PushNotification,
+    ) -> Result<(), MobileOptimizerError> {
+        // Require an active push subscription.
+        let config = Self::get_or_create_config(env, &notification.recipient);
+        if !config.push_subscription_active {
+            return Err(MobileOptimizerError::PwaError);
+        }
+
+        let key = PwaExtKey::PushQueue(notification.recipient.clone());
+        let mut queue: Vec<PushNotification> =
+            env.storage().persistent().get(&key).unwrap_or_else(|| Vec::new(env));
+
+        queue.push_back(notification.clone());
+        env.storage().persistent().set(&key, &queue);
+
+        // Update metrics.
+        let mut metrics = Self::get_metrics(env);
+        metrics.notifications_sent += 1;
+        env.storage().persistent().set(&PwaExtKey::Metrics, &metrics);
+
+        env.events().publish(
+            (symbol_short!("push_sent"), notification.recipient.clone()),
+            notification.notification_id,
+        );
+
+        Ok(())
+    }
+
+    /// Mark a notification as delivered (called by the push service).
+    pub fn mark_notification_delivered(
+        env: &Env,
+        recipient: &Address,
+        notification_id: &String,
+    ) -> Result<(), MobileOptimizerError> {
+        let key = PwaExtKey::PushQueue(recipient.clone());
+        let mut queue: Vec<PushNotification> = env
+            .storage()
+            .persistent()
+            .get(&key)
+            .ok_or(MobileOptimizerError::PwaError)?;
+
+        let mut found = false;
+        let mut updated: Vec<PushNotification> = Vec::new(env);
+        for mut n in queue.iter() {
+            if n.notification_id == *notification_id {
+                n.delivered = true;
+                found = true;
+            }
+            updated.push_back(n);
+        }
+        if !found {
+            return Err(MobileOptimizerError::PwaError);
+        }
+        env.storage().persistent().set(&key, &updated);
+
+        let mut metrics = Self::get_metrics(env);
+        metrics.notifications_delivered += 1;
+        env.storage().persistent().set(&PwaExtKey::Metrics, &metrics);
+
+        Ok(())
+    }
+
+    /// Mark a notification as read by the user.
+    pub fn mark_notification_read(
+        env: &Env,
+        recipient: &Address,
+        notification_id: &String,
+    ) -> Result<(), MobileOptimizerError> {
+        let key = PwaExtKey::PushQueue(recipient.clone());
+        let mut queue: Vec<PushNotification> = env
+            .storage()
+            .persistent()
+            .get(&key)
+            .ok_or(MobileOptimizerError::PwaError)?;
+
+        let mut found = false;
+        let mut updated: Vec<PushNotification> = Vec::new(env);
+        for mut n in queue.iter() {
+            if n.notification_id == *notification_id {
+                n.read = true;
+                found = true;
+            }
+            updated.push_back(n);
+        }
+        if !found {
+            return Err(MobileOptimizerError::PwaError);
+        }
+        env.storage().persistent().set(&key, &updated);
+
+        let mut metrics = Self::get_metrics(env);
+        metrics.notifications_read += 1;
+        env.storage().persistent().set(&PwaExtKey::Metrics, &metrics);
+
+        Ok(())
+    }
+
+    /// Return all pending (unread) notifications for `recipient`.
+    pub fn get_pending_notifications(
+        env: &Env,
+        recipient: &Address,
+    ) -> Vec<PushNotification> {
+        let key = PwaExtKey::PushQueue(recipient.clone());
+        let queue: Vec<PushNotification> =
+            env.storage().persistent().get(&key).unwrap_or_else(|| Vec::new(env));
+
+        let now = env.ledger().timestamp();
+        let mut pending: Vec<PushNotification> = Vec::new(env);
+        for n in queue.iter() {
+            let not_expired = n.expires_at.map_or(true, |exp| now < exp);
+            if !n.read && not_expired {
+                pending.push_back(n);
+            }
+        }
+        pending
+    }
+
+    // ── Install-to-Home-Screen (Issue #440) ───────────────────────────────────
+
+    /// Record that the install prompt was shown to `user`.
+    pub fn record_install_prompt_shown(
+        env: &Env,
+        user: &Address,
+        platform: String,
+    ) -> Result<(), MobileOptimizerError> {
+        let record = InstallPromptRecord {
+            user: user.clone(),
+            shown_at: env.ledger().timestamp(),
+            outcome: InstallPromptOutcome::Pending,
+            platform,
+        };
+
+        let key = PwaExtKey::InstallHistory(user.clone());
+        let mut history: Vec<InstallPromptRecord> =
+            env.storage().persistent().get(&key).unwrap_or_else(|| Vec::new(env));
+        history.push_back(record);
+        env.storage().persistent().set(&key, &history);
+
+        let mut metrics = Self::get_metrics(env);
+        metrics.prompts_shown += 1;
+        env.storage().persistent().set(&PwaExtKey::Metrics, &metrics);
+
+        Ok(())
+    }
+
+    /// Record the user's response to the install prompt.
+    pub fn record_install_prompt_outcome(
+        env: &Env,
+        user: &Address,
+        outcome: InstallPromptOutcome,
+    ) -> Result<(), MobileOptimizerError> {
+        let key = PwaExtKey::InstallHistory(user.clone());
+        let mut history: Vec<InstallPromptRecord> = env
+            .storage()
+            .persistent()
+            .get(&key)
+            .ok_or(MobileOptimizerError::PwaError)?;
+
+        // Update the most recent pending record.
+        let len = history.len();
+        if len == 0 {
+            return Err(MobileOptimizerError::PwaError);
+        }
+        let mut updated: Vec<InstallPromptRecord> = Vec::new(env);
+        for (i, mut r) in history.iter().enumerate() {
+            if i as u32 == len - 1 && r.outcome == InstallPromptOutcome::Pending {
+                r.outcome = outcome.clone();
+            }
+            updated.push_back(r);
+        }
+        env.storage().persistent().set(&key, &updated);
+
+        // Update metrics and install status.
+        let mut metrics = Self::get_metrics(env);
+        match outcome {
+            InstallPromptOutcome::Accepted => {
+                metrics.installs_accepted += 1;
+                metrics.active_push_subscribers += 1;
+                Self::update_install_status(env, user, PwaInstallStatus::Installed)?;
+            }
+            InstallPromptOutcome::Dismissed => {
+                metrics.installs_dismissed += 1;
+            }
+            InstallPromptOutcome::Pending => {}
+        }
+        env.storage().persistent().set(&PwaExtKey::Metrics, &metrics);
+
+        env.events().publish(
+            (symbol_short!("pwa_install"), user.clone()),
+            outcome == InstallPromptOutcome::Accepted,
+        );
+
+        Ok(())
+    }
+
+    /// Return the install prompt history for `user`.
+    pub fn get_install_history(env: &Env, user: &Address) -> Vec<InstallPromptRecord> {
+        env.storage()
+            .persistent()
+            .get(&PwaExtKey::InstallHistory(user.clone()))
+            .unwrap_or_else(|| Vec::new(env))
+    }
+
+    /// Return global PWA metrics.
+    pub fn get_metrics(env: &Env) -> PwaMetrics {
+        env.storage()
+            .persistent()
+            .get(&PwaExtKey::Metrics)
+            .unwrap_or(PwaMetrics {
+                prompts_shown: 0,
+                installs_accepted: 0,
+                installs_dismissed: 0,
+                notifications_sent: 0,
+                notifications_delivered: 0,
+                notifications_read: 0,
+                active_push_subscribers: 0,
+            })
+    }
 }
 
 #[contracttype]