flickr-api 0.2.2

Easy interface to the Flickr API
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

use crate::*;
use reqwest::multipart::{Form, Part};
use tokio::fs::read;

#[derive(Debug, Serialize, Deserialize, PartialEq)]
#[serde(rename = "rsp")]
struct UploadXMLAnswer {
    stat: String,

    #[serde(flatten)]
    content: UploadXMLPayload,
}

#[derive(Debug, Serialize, Deserialize, PartialEq)]
enum UploadXMLPayload {
    #[serde(rename = "photoid")]
    PhotoId {
        #[serde(rename = "$value")]
        value: String,
    },

    #[serde(rename = "err")]
    Err { code: String, msg: String },
}

impl UploadXMLAnswer {
    fn to_result(self) -> Result<String, FlickrError> {
        match self.content {
            UploadXMLPayload::PhotoId { value } => Ok(value),
            UploadXMLPayload::Err { code, msg } => Err(FlickrError {
                stat: self.stat,
                code: code.parse().unwrap_or(0),
                message: msg,
            }),
        }
    }
}

impl PhotoRequestBuilder {
    /// Access the "special" upload API and upload a photo from a given path
    pub async fn upload_from_path(&self, path: &std::path::Path) -> Result<String, Box<dyn Error>> {
        self.upload(
            &read(path).await?,
            Some(String::from(
                path.file_name()
                    .and_then(|f| f.to_str())
                    .unwrap_or("unknown"),
            )),
        )
        .await
    }

    /// Access the "special" upload API and upload a photo from its contents
    pub async fn upload(
        &self,
        photo: &[u8],
        filename: Option<String>,
    ) -> Result<String, Box<dyn Error>> {
        let mut params = vec![];
        oauth::build_request(
            oauth::RequestTarget::Post(URL_UPLOAD),
            &mut params,
            &self.handle.key,
            self.handle.token.as_ref(),
        );

        // Filename is apparently required and request will fail if not set
        let photo_part =
            Part::bytes(Vec::from(photo)).file_name(filename.unwrap_or("unknown".to_string()));

        let form = params
            .into_iter()
            .fold(Form::new(), |form, (k, v)| form.text(k, v))
            .part("photo", photo_part);

        let request = self
            .handle
            .client
            .post(URL_UPLOAD)
            .multipart(form)
            .send()
            .await?;

        let text = request.text().await?;

        log::trace!("Upload response: {:?}", text);

        let id = serde_xml_rs::from_str::<UploadXMLAnswer>(&text)?.to_result()?;

        Ok(id)
    }
}

#[test]
fn test_upload_answer_error() {
    let anwser = r#"<?xml version="1.0" encoding="utf-8" ?><rsp stat="fail"><err code="5" msg="Filetype was not recognised"/></rsp>"#;

    let answer = serde_xml_rs::from_str::<UploadXMLAnswer>(anwser).unwrap();

    assert_eq!(
        answer,
        UploadXMLAnswer {
            stat: "fail".to_string(),
            content: UploadXMLPayload::Err {
                code: "5".to_string(),
                msg: "Filetype was not recognised".to_string()
            }
        }
    );
}

#[test]
fn test_upload_answer_ok() {
    let anwser = r#"<?xml version="1.0" encoding="utf-8" ?><rsp stat="ok"><photoid>54026462270</photoid></rsp>"#;

    let answer = serde_xml_rs::from_str::<UploadXMLAnswer>(anwser).unwrap();

    assert_eq!(
        answer,
        UploadXMLAnswer {
            stat: "ok".to_string(),
            content: UploadXMLPayload::PhotoId {
                value: "54026462270".to_string()
            }
        }
    );
}