libpaprika 0.4.1

A library to read and generate Paprika recipe files and recipe collections.
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

use futures::StreamExt;
use futures::TryStreamExt;
use log::debug;
use log::info;
use reqwest::Client;
use serde::Deserialize;

use crate::Recipe;

const API_ROOT: &str = "https://www.paprikaapp.com/api/v2";

pub type Token = String;

#[derive(Deserialize, Debug)]
struct ApiResult<T> {
    result: T,
}

pub async fn login(client: &Client, email: &str, password: &str) -> Result<Token, reqwest::Error> {
    #[derive(Deserialize)]
    struct TokenResponse {
        pub token: String,
    }

    let response: ApiResult<TokenResponse> = client
        .post(format!("{API_ROOT}/account/login"))
        .form(&[("email", email), ("password", password)])
        .send()
        .await?
        .json()
        .await?;

    Ok(response.result.token)
}

pub async fn recipes(client: &Client, token: &Token) -> Result<Vec<Recipe>, reqwest::Error> {
    #[derive(Deserialize, Debug)]
    struct RecipeEntry {
        uid: String,
        // hash: String,
    }

    type RecipesResponse = Vec<RecipeEntry>;

    let response: ApiResult<RecipesResponse> = client
        .get(format!("{API_ROOT}/sync/recipes"))
        .bearer_auth(token)
        .send()
        .await?
        .json()
        .await?;

    let recipes = futures::stream::iter(response.result.into_iter())
        .map(move |re| recipe(client, token, re.uid))
        .buffer_unordered(8)
        .try_collect::<Vec<Recipe>>()
        .await?;

    Ok(recipes)
}

pub async fn recipe(
    client: &Client,
    token: &Token,
    uid: impl AsRef<str>,
) -> Result<Recipe, reqwest::Error> {
    let uid = uid.as_ref();
    info!("Fetching Recipe {uid}");

    let response: ApiResult<Recipe> = client
        .get(format!("{API_ROOT}/sync/recipe/{uid}"))
        .bearer_auth(token)
        .send()
        .await?
        .json()
        .await?;

    debug!("Result for Recipe {uid}: {response:?}");

    Ok(response.result)
}

#[cfg(test)]
mod test {
    use std::env;

    use reqwest::Client;

    use super::{login, recipes, Token};

    async fn env_token() -> Option<Token> {
        env::var("PAPRIKA_TOKEN").ok()
    }

    #[tokio::test]
    async fn test_login() {
        let (Ok(email), Ok(password)) = (env::var("PAPRIKA_EMAIL"), env::var("PAPRIKA_PASSWORD")) else {
        return
      };

        login(&Client::new(), &email, &password).await.unwrap();
    }

    #[tokio::test]
    async fn test_recipes() {
        let Some(token) = env_token().await else {
          return
        };

        let rs = recipes(&Client::new(), &token).await.unwrap();
        assert_ne!(rs.len(), 0);
    }
}