cameo 0.2.0

Unified movie/TV show database SDK for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use super::{CameoClient, CameoClientError};
#[cfg(feature = "cache")]
use crate::cache::CacheKey;
use crate::{
    core::pagination::Page,
    unified::{
        media_id::MediaId,
        models::{UnifiedMovie, UnifiedTvShow},
    },
};

impl CameoClient {
    /// Get movie recommendations based on a movie.
    pub async fn movie_recommendations(
        &self,
        id: &MediaId,
        page: Option<u32>,
    ) -> Result<Page<UnifiedMovie>, CameoClientError> {
        #[cfg(feature = "cache")]
        let key = CacheKey::Discovery {
            provider: id.provider().to_string(),
            endpoint: format!("movie_recommendations_{id}"),
            page: page.unwrap_or(1),
        };
        #[cfg(feature = "cache")]
        if let Some(hit) = self.cache_get::<Page<UnifiedMovie>>(&key).await {
            return Ok(hit);
        }
        let result = self
            .route(&self.recommendation, id)?
            .movie_recommendations(id, page)
            .await?;
        #[cfg(feature = "cache")]
        {
            self.cache_put(key, &result, self.cache_discovery_ttl())
                .await;
            self.cache_movie_items(&result).await;
        }
        Ok(result)
    }

    /// Get TV show recommendations based on a TV show.
    pub async fn tv_recommendations(
        &self,
        id: &MediaId,
        page: Option<u32>,
    ) -> Result<Page<UnifiedTvShow>, CameoClientError> {
        #[cfg(feature = "cache")]
        let key = CacheKey::Discovery {
            provider: id.provider().to_string(),
            endpoint: format!("tv_recommendations_{id}"),
            page: page.unwrap_or(1),
        };
        #[cfg(feature = "cache")]
        if let Some(hit) = self.cache_get::<Page<UnifiedTvShow>>(&key).await {
            return Ok(hit);
        }
        let result = self
            .route(&self.recommendation, id)?
            .tv_recommendations(id, page)
            .await?;
        #[cfg(feature = "cache")]
        {
            self.cache_put(key, &result, self.cache_discovery_ttl())
                .await;
            self.cache_tv_items(&result).await;
        }
        Ok(result)
    }

    /// Get movies similar to a given movie.
    pub async fn similar_movies(
        &self,
        id: &MediaId,
        page: Option<u32>,
    ) -> Result<Page<UnifiedMovie>, CameoClientError> {
        #[cfg(feature = "cache")]
        let key = CacheKey::Discovery {
            provider: id.provider().to_string(),
            endpoint: format!("similar_movies_{id}"),
            page: page.unwrap_or(1),
        };
        #[cfg(feature = "cache")]
        if let Some(hit) = self.cache_get::<Page<UnifiedMovie>>(&key).await {
            return Ok(hit);
        }
        let result = self
            .route(&self.recommendation, id)?
            .similar_movies(id, page)
            .await?;
        #[cfg(feature = "cache")]
        {
            self.cache_put(key, &result, self.cache_discovery_ttl())
                .await;
            self.cache_movie_items(&result).await;
        }
        Ok(result)
    }

    /// Get TV shows similar to a given TV show.
    pub async fn similar_tv_shows(
        &self,
        id: &MediaId,
        page: Option<u32>,
    ) -> Result<Page<UnifiedTvShow>, CameoClientError> {
        #[cfg(feature = "cache")]
        let key = CacheKey::Discovery {
            provider: id.provider().to_string(),
            endpoint: format!("similar_tv_{id}"),
            page: page.unwrap_or(1),
        };
        #[cfg(feature = "cache")]
        if let Some(hit) = self.cache_get::<Page<UnifiedTvShow>>(&key).await {
            return Ok(hit);
        }
        let result = self
            .route(&self.recommendation, id)?
            .similar_tv_shows(id, page)
            .await?;
        #[cfg(feature = "cache")]
        {
            self.cache_put(key, &result, self.cache_discovery_ttl())
                .await;
            self.cache_tv_items(&result).await;
        }
        Ok(result)
    }
}