cal_redis/cache/
user.rs

1// File: cal-redis/src/cache/user.rs
2
3use super::CallableCache;
4use crate::{get_user_by_id, get_user_by_ident, get_users};
5use cal_core::User;
6use redis::RedisError;
7use std::sync::Arc;
8
9impl CallableCache {
10    /// Retrieves a user by its ID, first checking the local cache and then Redis.
11    pub async fn get_user_by_id(&self, id: &str) -> Result<Option<Arc<User>>, RedisError> {
12        println!("[CallableCache::get_user_by_id] Getting user by ID: {}", id);
13        // Try to get from local cache first
14        if let Some(resolved_id) = self.local_cache.user_idents.get(id) {
15            println!("[CallableCache::get_user_by_id] Found user ident in local cache: {}", resolved_id);
16            if let Some(user) = self.local_cache.users.get(resolved_id.as_str()) {
17                println!("[CallableCache::get_user_by_id] Found user in local cache: {}", user.email);
18                return Ok(Some(user));
19            }
20
21            // If not in local cache, fetch from Redis
22            println!("[CallableCache::get_user_by_id] User not in local cache, fetching from Redis");
23            match get_user_by_id(self.remote_cache.connection.clone(), &resolved_id).await? {
24                Some(user) => {
25                    println!("[CallableCache::get_user_by_id] Found user in Redis: {}", user.email);
26                    let user_arc = Arc::new(user);
27                    self.local_cache
28                        .users
29                        .insert(resolved_id.to_string(), user_arc.clone());
30                    self.local_cache
31                        .user_idents
32                        .insert(id.to_string(), resolved_id.to_string());
33                    Ok(Some(user_arc))
34                }
35                None => {
36                    println!("[CallableCache::get_user_by_id] User not found in Redis");
37                    Ok(None)
38                }
39            }
40        } else {
41            // Try Redis directly
42            println!("[CallableCache::get_user_by_id] User ident not in local cache, checking Redis");
43            match get_user_by_ident(self.remote_cache.connection.clone(), id).await? {
44                Some(user) => {
45                    println!("[CallableCache::get_user_by_id] Found user in Redis by ident: {}", user.email);
46                    let user_arc = Arc::new(user);
47                    self.local_cache
48                        .users
49                        .insert(user_arc.id.clone(), user_arc.clone());
50                    self.local_cache
51                        .user_idents
52                        .insert(id.to_string(), user_arc.id.clone());
53                    self.local_cache
54                        .user_idents
55                        .insert(user_arc.email.clone(), user_arc.id.clone());
56                    Ok(Some(user_arc))
57                }
58                None => {
59                    println!("[CallableCache::get_user_by_id] User not found in Redis");
60                    Ok(None)
61                }
62            }
63        }
64    }
65
66    /// Retrieves a user by identifier (email), first checking the local cache and then Redis.
67    pub async fn get_user_by_ident(&self, ident: &str) -> Result<Option<Arc<User>>, RedisError> {
68        println!("[CallableCache::get_user_by_ident] Getting user by ident: {}", ident);
69        self.get_user_by_id(ident).await
70    }
71
72    /// Retrieves all users from Redis.
73    pub async fn get_users(&self) -> Result<Arc<Vec<User>>, RedisError> {
74        println!("[CallableCache::get_users] Getting all users from Redis");
75        let users = get_users(self.remote_cache.connection.clone()).await?;
76        println!("[CallableCache::get_users] Retrieved {} users from Redis", users.len());
77        for user in &users {
78            let user_arc = Arc::new(user.clone());
79            self.local_cache
80                .users
81                .insert(user.id.clone(), user_arc.clone());
82            self.local_cache
83                .user_idents
84                .insert(user.id.clone(), user.id.clone());
85            self.local_cache
86                .user_idents
87                .insert(user.email.clone(), user.id.clone());
88        }
89        Ok(Arc::new(users))
90    }
91}