aghpb 1.4.1

Anime girls holding programming books API wrapper for 🦀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

use std::{collections::HashMap, error::Error};

use bytes::Bytes;
use chrono::{DateTime, FixedOffset};
use reqwest::header::HeaderMap;

#[cfg(feature = "image")]
use image::DynamicImage;

use crate::get_id;

pub struct BookData {
    pub name: String,
    pub category: String,
    pub date_added: DateTime<FixedOffset>,
    pub search_id: String,
    pub commit_url: String,
    pub commit_author: String,
}

impl BookData {
    /// Creates a book from a json dictionary.
    pub fn from_json(book_dict: HashMap<String, String>) -> BookData {
        let name = book_dict.get("name").expect(
            "Failed acquiring book name from json!"
        ).to_owned();

        let category = book_dict.get("category").expect(
            "Failed acquiring book category from json!"
        ).to_owned();

        let date_added = DateTime::parse_from_str(book_dict.get("date_added").expect(
            "Failed acquiring book date added header!"
        ), "%Y-%m-%d %H:%M:%S%z").expect(
            "Failed to convert book's date added header to date time object."
        );

        let search_id = book_dict.get("search_id").expect(
            "Failed acquiring book search id header!"
        ).to_owned();

        let commit_url = book_dict.get("commit_url").expect(
            "Failed acquiring book commit url header!"
        ).to_owned();

        let commit_author = book_dict.get("commit_author").expect(
            "Failed acquiring book commit author header!"
        ).to_owned();

        Self {
            name,
            category,
            date_added,
            search_id,
            commit_url,
            commit_author
        }
    }

    // Get's the book from the api.
    pub async fn get_book(&self) -> Result<Book, Box<dyn Error>> {
        get_id(String::from(&self.search_id)).await
    }
}

pub struct Book {
    pub details: BookData,
    pub raw_bytes: Bytes,
}

impl Book {
    /// Creates a book from a response's headers and bytes.
    pub fn from_response(headers: HeaderMap, bytes: Bytes) -> Book {
        let name = headers.get("book-name").expect(
            "Failed acquiring book name header!"
        ).to_str().expect("Failed converting book name to string.").to_owned();
    
        let category = headers.get("book-category").expect(
            "Failed acquiring book category header!"
        ).to_str().expect("Failed converting book category to string.").to_owned();
    
        let date_added = DateTime::parse_from_str(headers.get("book-date-added").expect(
            "Failed acquiring book date added header!"
        ).to_str().expect("Failed converting book date time to string."), "%Y-%m-%d %H:%M:%S%z").expect(
            "Failed to convert book's date added header to date time object."
        );
    
        let search_id = headers.get("book-search-id").expect(
            "Failed acquiring book search id header!"
        ).to_str().expect("Failed converting book search id to string.").to_owned();
    
        let commit_url = headers.get("book-commit-url").expect(
            "Failed acquiring book commit url header!"
        ).to_str().expect("Failed converting book commit url to string.").to_owned();
    
        let commit_author = headers.get("book-commit-author").expect(
            "Failed acquiring book commit author header!"
        ).to_str().expect("Failed converting book commit author to string.").to_owned();

        Self {
            details: BookData { 
                name, 
                category, 
                date_added, 
                search_id, 
                commit_url, 
                commit_author 
            },
            raw_bytes: bytes
        }
    }

    #[cfg(feature = "image")]
    pub fn to_image(&self) -> DynamicImage {
        image::load_from_memory(&self.raw_bytes).expect("Failed to convert bytes into dynamic image object.")
    }
}