csfdapi 0.1.0

Unofficial wrapper for mobile csfd 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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use ::Csfd;
use reqwest;
use std::collections::HashMap;
use std::borrow::Cow;
use std::fmt;

pub struct HomeData {
    data: Vec<HomeDataItem>
}

impl HomeData {
    fn new() -> HomeData {
        HomeData {
            data: Vec::new()
        }
    }

    fn add_if_not_exists(&mut self, item: HomeDataItem) -> &mut Self {
        if !self.data.contains(&item) {
            self.data.push(item);
        }

        self
    }

    pub fn all(&mut self) -> &mut Self {
        self.new_videos()
            .tv_tips()
            .cinema_releases()
            .dvd_releases()
            .bluray_releases()
            .film_profile_visits()
            .creator_profile_visits()
            .adverts()
    }

    pub fn new_videos(&mut self) -> &mut Self {
        self.add_if_not_exists(HomeDataItem::NewVideos)
    }

    pub fn tv_tips(&mut self) -> & mut Self {
        self.add_if_not_exists(HomeDataItem::TvTips)
    }

    pub fn cinema_releases(&mut self) -> & mut Self {
        self.add_if_not_exists(HomeDataItem::CinemaReleases)
    }

    pub fn dvd_releases(&mut self) -> & mut Self {
        self.add_if_not_exists(HomeDataItem::DvdReleases)
    }

    pub fn bluray_releases(&mut self) -> & mut Self {
        self.add_if_not_exists(HomeDataItem::BlurayReleases)
    }

    pub fn film_profile_visits(&mut self) -> & mut Self {
        self.add_if_not_exists(HomeDataItem::FilmProfileVisits)
    }

    pub fn creator_profile_visits(&mut self) -> & mut Self {
        self.add_if_not_exists(HomeDataItem::CreatorProfileVisits)
    }

    pub fn adverts(&mut self) -> & mut Self {
        self.add_if_not_exists(HomeDataItem::Adverts)
    }
}

impl fmt::Display for HomeData {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let string = self.data.iter().map(|i| i.to_string()).collect::<Vec<String>>().join(",");
        write!(f, "{}", string)
    }
}

#[derive(PartialEq, Clone)]
pub enum HomeDataItem {
    NewVideos,
    TvTips,
    CinemaReleases,
    DvdReleases,
    BlurayReleases,
    FilmProfileVisits,
    CreatorProfileVisits,
    Adverts,
}

impl fmt::Display for HomeDataItem {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let string = match self {
            HomeDataItem::NewVideos => "new_videos",
            HomeDataItem::TvTips => "tv_tips",
            HomeDataItem::CinemaReleases => "cinema_releases",
            HomeDataItem::DvdReleases => "dvd_releases",
            HomeDataItem::BlurayReleases => "bluray_releases",
            HomeDataItem::FilmProfileVisits => "film_profile_visits",
            HomeDataItem::CreatorProfileVisits => "creator_profile_visits",
            HomeDataItem::Adverts => "adverts",
        };

        write!(f, "{}", string)
    }
}

#[derive(Debug)]
pub struct HomeRequest<'a> {
    inner: Csfd<'a>,
    params: HashMap<&'static str, Cow<'a, str>>,
}

impl<'a> HomeRequest<'a> {
    pub fn new(csfd: &Csfd<'a>) -> HomeRequest<'a> {
        HomeRequest {
            inner: csfd.clone(),
            params: HashMap::new(),
        }
    }

    pub fn data<F>(&mut self, data: F) -> &mut Self
        where F: FnOnce(&mut HomeData) -> &mut HomeData
    {
        let mut home_data = HomeData::new();
        data(&mut home_data);
        self.params.insert("data", home_data.to_string().into());
        self
    }

    pub fn limit(&mut self, limit: u32) -> &mut Self {
        self.params.insert("limit", limit.to_string().into());
        self
    }

    pub fn creator_profile_visits_limit(&mut self, limit: u32) -> &mut Self {
        self.params.insert("creator_profile_visits_limit", limit.to_string().into());
        self
    }

    pub fn send(&self) -> Result<String, reqwest::Error> {
        self.inner.get("home", Some(self.params.clone()))?.text()
    }
}