stremio 0.1.1

A fast & async library for Stremio, written in 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
129
130
131
132
133
134
135
136
137
138
139
140
141

use std::collections::HashMap;

use serde::{Deserialize, Deserializer, Serialize};
use serde_json::Value;

pub(crate) const LOGIN_API_URL: &str = "https://api.strem.io/api/login";
pub(crate) const GET_USER_API_URL: &str = "https://api.strem.io/api/getUser";
pub(crate) const GET_USER_SESSIONS_API_URL: &str = "https://api.strem.io/api/getUserSessions";
pub(crate) const LOGOUT_API_URL: &str = "https://api.strem.io/api/logout";
pub(crate) const GET_ADDON_COLLECTION_API_URL: &str = "https://api.strem.io/api/addonCollectionGet";
pub(crate) const DATASTORE_META_API_URL: &str = "https://api.strem.io/api/datastoreMeta";

pub(crate) fn deserialize_null_default<'de, D, T>(deserializer: D) -> Result<T, D::Error>
where
    T: Default + Deserialize<'de>,
    D: Deserializer<'de>,
{
    let opt = Option::deserialize(deserializer)?;
    Ok(opt.unwrap_or_default())
}

/// API Response struct.
#[derive(Serialize, Deserialize, Debug)]
pub struct ApiResponse {
    // API returns `result` value as `null' on successful login.
    #[serde(deserialize_with = "deserialize_null_default")]
    pub result: HashMap<String, Value>,
    // API returns `error` value as `null' on successful login.
    #[serde(deserialize_with = "deserialize_null_default")]
    pub error: HashMap<String, Value>,
}

/// API Response struct.
#[derive(Serialize, Deserialize, Debug)]
pub struct GenericApiResponse {
    // API returns `result` value as `null' on successful login.
    #[serde(deserialize_with = "deserialize_null_default")]
    pub result: Value,
    // API returns `error` value as `null' on successful login.
    #[serde(deserialize_with = "deserialize_null_default")]
    pub error: HashMap<String, Value>,
}

/// user info struct for API response.
#[derive(Serialize, Deserialize, Debug)]
pub struct UserInfo {
    pub _id: String,
    pub email: String,
    #[serde(alias = "fbId")]
    pub fb_id: String,
    pub fullname: String,
    pub avatar: String,
    pub anonymous: String,
    pub gdpr_consent: HashMap<String, Value>,
    pub taste: String,
    pub lang: String,
    #[serde(alias = "dateRegistered")]
    pub date_registered: String,
    #[serde(alias = "lastModified")]
    pub last_modified: String,
    pub stremio_addons: String,
    pub premium_expire: String,
}

/// Login API struct.
#[derive(Serialize, Deserialize)]
pub struct LoginCredential {
    pub email: String,
    pub password: String,
    pub auth_key: Option<String>,
}

impl LoginCredential {
    pub fn new(email: String, password: String, auth_key: Option<String>) -> Self {
        LoginCredential {
            email,
            password,
            auth_key,
        }
    }
}

/// UserAuth struct for API calls.
#[derive(Serialize, Debug)]
#[serde(rename_all = "camelCase")]
pub struct UserAuth {
    auth_key: String,
}

impl UserAuth {
    pub fn new(auth_key: String) -> Self {
        Self { auth_key }
    }
}

/// GetAddonCollection struct for `addonCollectionGet` API.
#[derive(Debug, Serialize, Default)]
pub struct GetAddonCollection {
    #[serde(rename = "addFromURL")]
    add_from_url: Vec<String>,
    #[serde(rename = "authKey")]
    auth_key: String,
    update: bool,
}

impl GetAddonCollection {
    pub fn new(auth_key: String) -> Self {
        Self {
            auth_key,
            ..Default::default()
        }
    }
}

/// DatastoreMeta struct for `datastoreMeta` API.
#[derive(Debug, Serialize)]
pub struct DatastoreMeta {
    #[serde(rename = "authKey")]
    auth_key: String,
    collection: String,
    from: String,
}

impl DatastoreMeta {
    pub fn new_with_auth_key(auth_key: String) -> Self {
        Self {
            auth_key,
            ..Default::default()
        }
    }
}

impl Default for DatastoreMeta {
    fn default() -> Self {
        Self {
            auth_key: String::default(),
            collection: "libraryItem".to_string(),
            from: "linvo-p2p-sync".to_string(),
        }
    }
}