cal-redis 0.1.80

// File: cal-redis/src/cache/websocket.rs

use super::CallableCache;
use crate::constants::{ChannelKeys, WS_CONNECTIONS_KEY};
use cal_core::RedisEvent;
use redis::{AsyncCommands, RedisError};

impl CallableCache {
    /// Get account_id for a WebSocket connection
    pub async fn get_ws_account(
        &self,
        ws_connection_id: &str,
    ) -> Result<Option<String>, RedisError> {
        println!("[CallableCache::get_ws_account] Getting account for WebSocket: {}", ws_connection_id);
        let mut con = self.redis_connection();
        let result = con.hget(WS_CONNECTIONS_KEY, ws_connection_id).await?;
        match &result {
            Some(account_id) => println!("[CallableCache::get_ws_account] Found account: {}", account_id),
            None => println!("[CallableCache::get_ws_account] No account found for WebSocket"),
        }
        Ok(result)
    }

    /// Get all WebSocket connections for an account
    pub async fn get_account_connections(
        &self,
        account_id: &str,
    ) -> Result<Vec<String>, RedisError> {
        println!("[CallableCache::get_account_connections] Getting WebSocket connections for account: {}", account_id);
        let mut con = self.redis_connection();

        // Get all connections and filter by account
        let all_connections: Vec<(String, String)> = con.hgetall(WS_CONNECTIONS_KEY).await?;

        let connections: Vec<String> = all_connections
            .into_iter()
            .filter(|(_, acc_id)| acc_id == account_id)
            .map(|(conn_id, _)| conn_id)
            .collect();

        println!("[CallableCache::get_account_connections] Found {} connections", connections.len());
        Ok(connections)
    }

    /// Publish event to account-specific channel
    pub async fn publish_account_event(
        &self,
        account_id: &str,
        event: &RedisEvent,
    ) -> Result<(), RedisError> {
        println!("[CallableCache::publish_account_event] Publishing event for account: {}, Event type: {:?}",
                 account_id, std::mem::discriminant(event));
        let channel = ChannelKeys::account_events(account_id);
        let event_json = serde_json::to_string(event).map_err(super::helpers::serde_to_redis_error)?;

        let mut con = self.redis_connection();
        con.publish(&channel, event_json).await?;

        Ok(())
    }
}