fluffyf 0.2.0

An e621 api wrapper and downloader
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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

// Copyright 2024 Ezra Alvarion
//
// Licensed under the Apache License, Version 2.0 <LICENSE-Apache or
// https://www.apache.org/licenses/LICENSE-2.0> or the BSD 2-Clause 
// License <LICENSE-BSD or https://opensource.org/license/bsd-2-clause/>,
// at Your option. This file may not be copied, modified, or distributed
// except according to those terms.

use {
    std::cmp::Ordering,

    reqwest::{Url, Client},
    serde::Deserialize,
    time::OffsetDateTime,
    
    super::{
        tags::{Tags, TagType},
        file::{PostFile, PostPreview, PostSample},
        supplement::IdType,
        traits::*,
        datetimeformat,
    },
};

pub const POSTS_URL: &'static str = "posts.json";

/// Represents the rating of a [`Post`]
/// 
/// Serve as an analogue to E621's `"rating"` string.
/// 
/// [`Deserialize`]:
/// - `"s"` => [`Safe`](Rating::Safe)
/// - `"q"` => [`Questionable`](Rating::Questionable)
/// - `"e"` => [`Explicit`](Rating::Explicit)
#[derive(Debug, PartialEq, Eq, Deserialize)]
pub enum Rating {
    #[serde(rename = "s")]
    Safe,
    #[serde(rename = "q")]
    Questionable,
    #[serde(rename = "e")]
    Explicit
}

/// Analogue to `"flags": {...}` JSON object
#[derive(Debug, PartialEq, Eq, Deserialize)]
pub struct Flags {
    /// If the post is pending approval.
    pub pending: bool,
    pub flagged: bool,
    pub note_locked: bool,
    pub status_locked: bool,
    pub rating_locked: bool,
    pub deleted: bool
}

/// Analogue to `"relationships": {...}` JSON object
#[derive(Debug, Deserialize)]
pub struct PostRelations {
    pub parent_id: Option<IdType>,
    pub has_children: bool,
    pub has_active_children: bool,
    pub children: Vec<IdType>
}

/// Analogue to `"score": {...}` JSON object
#[derive(Debug, Eq, Deserialize)]
pub struct Score {
    pub up: i32,
    pub down: i32,
    pub total: i32,
}

impl Ord for Score {
    fn cmp(&self, other: &Self) -> Ordering {
        self.total.cmp(&other.total)
    }
}

impl PartialOrd for Score {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl PartialEq for Score {
    fn eq(&self, other: &Self) -> bool {
        self.total == other.total
    }
}

impl Score {
    fn count_total(&mut self) -> i32 {
        self.total = self.up + self.down;
        self.total
    }
}

#[derive(Debug, Deserialize)]
pub struct Post {
    pub id: IdType,
    #[serde(with = "datetimeformat")]
    pub created_at: OffsetDateTime,
    #[serde(with = "datetimeformat::option")]
    pub updated_at: Option<OffsetDateTime>,
    pub file: PostFile,
    pub preview: PostPreview,
    pub sample: PostSample,
    pub score: Score,
    pub tags: Tags,
    pub locked_tags: TagType,
    pub change_seq: u32,
    pub flags: Flags,
    pub rating: Rating,
    pub fav_count: u32,
    pub sources: Vec<String>,
    pub pools: Vec<IdType>,
    pub relationships: PostRelations,
    pub approver_id: Option<IdType>,
    pub uploader_id: IdType,
    pub description: String,
    pub comment_count: u16,
    pub is_favorited: bool,
    pub has_notes: bool,
    pub duration: Option<f32>
}

impl Post {


    pub async fn vote(&self, client: Client) {
        //method::post(client, , )
    }

    pub async fn vote_by_id(id: IdType) {

    }

    pub async fn vote_by_url(url: Url) {

    }
}

/// Analogue to `/posts/<id>.json`
#[derive(Debug, Deserialize)]
#[serde(rename_all="lowercase")]
pub enum PostWrapper {
    Post(Post)
}

impl List for PostWrapper {
    const ENDPOINT: &'static str = "posts";
}

/// Analogue to `/posts.json`
pub type Posts = Vec<Post>;