poot 0.1.1

API wrapper for Photop.
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

use serde::Serialize;
use serde_json::json;

use crate::model::{id::{GroupId, PostId}, post::Post};

use super::BASE_API_URL;

#[derive(Serialize)]
pub struct CreatePostBody {
    #[serde(rename = "text")]
    pub content: String,

    #[serde(skip_serializing)]
    pub group_id: Option<GroupId>,

    #[serde(skip_serializing)]
    pub images: Vec<reqwest::multipart::Part>,
}

impl From<String> for CreatePostBody {
    fn from(content: String) -> CreatePostBody {
        CreatePostBody {
            content,
            group_id: None,
            images: Vec::new(),
        }
    }
}

impl super::Context {
    pub async fn create_post(&self, body: CreatePostBody) -> Result<Post, reqwest::Error> {
        let CreatePostBody {
            content,
            group_id,
            mut images,
        } = body;

        let form = images.drain(..).enumerate().fold(
            reqwest::multipart::Form::new().text("data", json!({ "text": content }).to_string()),
            |form, (i, image)| form.part(format!("image_{}", i), image),
        );

        let mut post_url = BASE_API_URL.join("posts/new").unwrap();
        if let Some(group_id) = group_id {
            post_url
                .query_pairs_mut()
                .append_pair("groupid", &group_id.to_string());
            println!("{}", group_id.to_string());
        }

        let post_id = self
            .client
            .post(post_url)
            .header("auth", self.auth.to_string())
            .multipart(form)
            .send()
            .await?
            .json::<PostId>()
            .await?;
        Ok(self.get_post(post_id).await?)
    }
}