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

use restson::{Error, RestClient};

use crate::{Codec, Country, Language, State, Station, Stats, Tag};
use crate::{
    CodecResponse, CountryResponse, LanguageResponse, StateResponse, StationResponse, TagResponse,
};
use crate::{PlayableStationUrl, StationSearch};

pub struct Client {
    rest_client: RestClient,
}

impl Client {
    pub fn new(base_url: &str) -> Client {
        let rest_client = match RestClient::new(base_url) {
            Ok(rc) => rc,
            Err(_) => panic!("Could not create rest_client!"),
        };

        Client { rest_client }
    }

    pub fn get_station_by_id(&mut self, id: u32) -> Result<Option<Station>, Error> {
        match self.rest_client.get(id)? {
            StationResponse::Station(station) => Ok(Some(station)),
            StationResponse::Stations(mut stations) => Ok(stations.pop()),
        }
    }

    pub fn get_all_stations(&mut self) -> Result<Vec<Station>, Error> {
        match self.rest_client.get(())? {
            StationResponse::Stations(stations) => Ok(stations),
            _ => Err(Error::InvalidValue),
        }
    }

    pub fn get_all_codecs(&mut self) -> Result<Vec<Codec>, Error> {
        match self.rest_client.get(())? {
            CodecResponse::Codecs(codecs) => Ok(codecs),
            _ => Err(Error::InvalidValue),
        }
    }

    pub fn get_all_countries(&mut self) -> Result<Vec<Country>, Error> {
        match self.rest_client.get(())? {
            CountryResponse::Countries(countries) => Ok(countries),
            _ => Err(Error::InvalidValue),
        }
    }

    pub fn get_all_languages(&mut self) -> Result<Vec<Language>, Error> {
        match self.rest_client.get(())? {
            LanguageResponse::Languages(languages) => Ok(languages),
            _ => Err(Error::InvalidValue),
        }
    }

    pub fn get_all_states(&mut self) -> Result<Vec<State>, Error> {
        match self.rest_client.get(())? {
            StateResponse::States(states) => Ok(states),
            _ => Err(Error::InvalidValue),
        }
    }

    pub fn get_all_tags(&mut self) -> Result<Vec<Tag>, Error> {
        match self.rest_client.get(())? {
            TagResponse::Tags(tags) => Ok(tags),
            _ => Err(Error::InvalidValue),
        }
    }

    pub fn get_stats(&mut self) -> Result<Stats, Error> {
        self.rest_client.get(())
    }

    pub fn get_playable_station_url(&mut self, station: Station) -> Result<String, Error> {
        let result: PlayableStationUrl = self.rest_client.get(station)?;
        Ok(result.url)
    }

    pub fn search(&mut self, data: StationSearch) -> Result<Vec<Station>, Error> {
        match self.rest_client.post_capture((), &data)? {
            StationResponse::Stations(stations) => Ok(stations),
            _ => Err(Error::InvalidValue),
        }
    }
}