Merge pull request #368 from BYTES-TECHES/guard

Fixed Issue #303

Author: Mystery-CLI

indexer/src/database.rs

@@ -1057,22 +1057,8 @@ impl Database {
     ) -> Result<crate::models::NotificationPreferences, AppError> {
         // Fetch existing or use defaults, then apply partial update
         let existing = self.get_notification_preferences(address).await?;
-        let base = existing.unwrap_or_else(|| crate::models::NotificationPreferences {
-            address: address.to_string(),
-            email_enabled: false,
-            email_address: None,
-            sms_enabled: false,
-            phone_number: None,
-            push_enabled: false,
-            push_token: None,
-            on_trade_created: true,
-            on_trade_funded: true,
-            on_trade_completed: true,
-            on_trade_confirmed: true,
-            on_dispute_raised: true,
-            on_dispute_resolved: true,
-            on_trade_cancelled: true,
-            updated_at: chrono::Utc::now(),
+        let base = existing.unwrap_or_else(|| {
+            crate::models::NotificationPreferences::default_for_address(address.to_string())
         });
 
         let row = sqlx::query_as::<_, crate::models::NotificationPreferences>(
@@ -1121,6 +1107,23 @@ impl Database {
         Ok(row)
     }
 
+    pub async fn unregister_push_token(&self, token: &str) -> Result<u64, AppError> {
+        let result = sqlx::query(
+            r#"
+            UPDATE notification_preferences
+            SET push_enabled = FALSE,
+                push_token = NULL,
+                updated_at = NOW()
+            WHERE push_token = $1
+            "#,
+        )
+        .bind(token)
+        .execute(&self.pool)
+        .await?;
+
+        Ok(result.rows_affected())
+    }
+
     pub async fn log_notification(
         &self,
         address: &str,

indexer/src/error.rs

@@ -23,6 +23,9 @@ pub enum AppError {
     #[error("Invalid event data: {0}")]
     InvalidEventData(String),
 
+    #[error("Bad request: {0}")]
+    BadRequest(String),
+
     #[error("Event not found")]
     EventNotFound,
 
@@ -82,6 +85,11 @@ impl IntoResponse for AppError {
                 "INVALID_EVENT_DATA",
                 "Invalid event data",
             ),
+            AppError::BadRequest(_) => (
+                StatusCode::BAD_REQUEST,
+                "BAD_REQUEST",
+                "Bad request",
+            ),
             AppError::EventNotFound => {
                 (StatusCode::NOT_FOUND, "EVENT_NOT_FOUND", "Event not found")
             }

indexer/src/event_monitor.rs

@@ -277,6 +277,9 @@ impl EventMonitor {
         };
         self.ws_manager.broadcast(ws_message).await;
 
+        // Notifications are best-effort and should not block the rest of event processing.
+        self.notification_service.process_event(event).await;
+
         // Fraud detection for high-value trade events
         let report = match event.event_type.as_str() {
             "trade_created" => self.fraud_service.process_event(event).await,

indexer/src/handlers.rs

@@ -62,6 +62,8 @@ pub async fn api_index() -> Json<serde_json::Value> {
             "notif_prefs_get": "GET  /notifications/preferences/:address",
             "notif_prefs_put": "PUT  /notifications/preferences/:address",
             "notif_log":       "GET  /notifications/log/:address",
+            "push_register":   "POST /push/register",
+            "push_unregister": "DELETE /push/unregister/:device_token",
             "help":            "GET  /help"
         }
     }))
@@ -473,7 +475,7 @@ pub async fn get_notification_preferences(
         .database
         .get_notification_preferences(&address)
         .await?
-        .ok_or_else(|| AppError::NotFound("preferences not found".into()))?;
+        .unwrap_or_else(|| crate::models::NotificationPreferences::default_for_address(address));
     Ok(Json(prefs))
 }
 
@@ -503,6 +505,61 @@ pub async fn get_notification_log(
     Ok(Json(entries))
 }
 
+/// POST /push/register
+pub async fn register_push_token(
+    State(state): State<AppState>,
+    Json(body): Json<crate::models::PushRegistrationRequest>,
+) -> Result<Json<crate::models::NotificationPreferences>, AppError> {
+    let token = body.device_token.trim();
+    let address = body.address.trim();
+
+    if token.is_empty() || address.is_empty() {
+        return Err(AppError::BadRequest(
+            "address and device_token are required".to_string(),
+        ));
+    }
+
+    let prefs = state
+        .database
+        .upsert_notification_preferences(
+            address,
+            &crate::models::UpdateNotificationPreferences {
+                email_enabled: None,
+                email_address: None,
+                sms_enabled: None,
+                phone_number: None,
+                push_enabled: Some(true),
+                push_token: Some(token.to_string()),
+                on_trade_created: None,
+                on_trade_funded: None,
+                on_trade_completed: None,
+                on_trade_confirmed: None,
+                on_dispute_raised: None,
+                on_dispute_resolved: None,
+                on_trade_cancelled: None,
+            },
+        )
+        .await?;
+
+    Ok(Json(prefs))
+}
+
+/// DELETE /push/unregister/:device_token
+pub async fn unregister_push_token(
+    Path(device_token): Path<String>,
+    State(state): State<AppState>,
+) -> Result<Json<serde_json::Value>, AppError> {
+    let removed = state
+        .database
+        .unregister_push_token(device_token.trim())
+        .await?;
+
+    Ok(Json(json!({
+        "status": "ok",
+        "removed": removed,
+    })))
+}
+
 // =============================================================================
 // Gateway Handlers
 // =============================================================================

indexer/src/main.rs

@@ -289,6 +289,8 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             get(get_notification_preferences).put(upsert_notification_preferences),
         )
         .route("/notifications/log/:address", get(get_notification_log))
+        .route("/push/register", post(register_push_token))
+        .route("/push/unregister/:device_token", delete(unregister_push_token))
         // Performance monitoring
         .route("/performance/dashboard", get(get_performance_dashboard))
         .route("/performance/alerts", get(get_performance_alerts))

indexer/src/models.rs

@@ -517,6 +517,28 @@ pub struct NotificationPreferences {
     pub updated_at: DateTime<Utc>,
 }
 
+impl NotificationPreferences {
+    pub fn default_for_address(address: impl Into<String>) -> Self {
+        Self {
+            address: address.into(),
+            email_enabled: false,
+            email_address: None,
+            sms_enabled: false,
+            phone_number: None,
+            push_enabled: false,
+            push_token: None,
+            on_trade_created: true,
+            on_trade_funded: true,
+            on_trade_completed: true,
+            on_trade_confirmed: true,
+            on_dispute_raised: true,
+            on_dispute_resolved: true,
+            on_trade_cancelled: true,
+            updated_at: Utc::now(),
+        }
+    }
+}
+
 /// Upsert payload — all fields optional so callers only send what they want to change.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct UpdateNotificationPreferences {
@@ -547,3 +569,10 @@ pub struct NotificationLogEntry {
     pub error: Option<String>,
     pub created_at: DateTime<Utc>,
 }
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PushRegistrationRequest {
+    pub device_token: String,
+    pub platform: String,
+    pub address: String,
+}

indexer/src/notification_service/channels.rs

@@ -14,6 +14,19 @@ pub async fn send_email(
     subject: &str,
     body: &str,
 ) -> Result<(), String> {
+    if cfg.email_api_url.trim().is_empty()
+        || cfg.email_api_key.trim().is_empty()
+        || cfg.email_from.trim().is_empty()
+    {
+        return Err("email provider is not configured".to_string());
+    }
+    if to.trim().is_empty() {
+        return Err("email recipient is empty".to_string());
+    }
+    if subject.trim().is_empty() || body.trim().is_empty() {
+        return Err("email content is empty".to_string());
+    }
+
     let client = Client::new();
     // SendGrid-compatible POST /v3/mail/send
     let payload = json!({
@@ -46,6 +59,20 @@ pub async fn send_email(
 }
 
 pub async fn send_sms(cfg: &NotificationConfig, to: &str, body: &str) -> Result<(), String> {
+    if cfg.sms_api_url.trim().is_empty()
+        || cfg.sms_account_sid.trim().is_empty()
+        || cfg.sms_auth_token.trim().is_empty()
+        || cfg.sms_from.trim().is_empty()
+    {
+        return Err("sms provider is not configured".to_string());
+    }
+    if to.trim().is_empty() {
+        return Err("sms recipient is empty".to_string());
+    }
+    if body.trim().is_empty() {
+        return Err("sms content is empty".to_string());
+    }
+
     let client = Client::new();
     // Twilio-compatible POST /2010-04-01/Accounts/{sid}/Messages.json
     let url = format!(
@@ -81,6 +108,19 @@ pub async fn send_push(
     title: &str,
     body: &str,
 ) -> Result<(), String> {
+    if cfg.push_api_url.trim().is_empty()
+        || cfg.push_project_id.trim().is_empty()
+        || cfg.push_server_key.trim().is_empty()
+    {
+        return Err("push provider is not configured".to_string());
+    }
+    if token.trim().is_empty() {
+        return Err("push token is empty".to_string());
+    }
+    if title.trim().is_empty() || body.trim().is_empty() {
+        return Err("push content is empty".to_string());
+    }
+
     let client = Client::new();
     // FCM v1 HTTP API
     let payload = json!({
@@ -102,7 +142,7 @@ pub async fn send_push(
         .map_err(|e| e.to_string())?;
 
     if res.status().is_success() {
-        info!("Push sent to token {}", &token[..8]);
+        info!("Push sent to token {}", token_preview(token));
         Ok(())
     } else {
         let msg = format!(
@@ -114,3 +154,12 @@ pub async fn send_push(
         Err(msg)
     }
 }
+
+fn token_preview(token: &str) -> &str {
+    let end = token
+        .char_indices()
+        .nth(8)
+        .map(|(idx, _)| idx)
+        .unwrap_or(token.len());
+    &token[..end]
+}