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

use crate::types;
use crate::Openstreetmap;
use crate::OpenstreetmapError;
use crate::RequestOptions;

#[derive(Debug, Deserialize)]
struct Osm {
    pub api: Api,
    pub policy: types::Policy,
}

impl From<Osm> for types::CapabilitiesAndPolicy {
    fn from(value: Osm) -> types::CapabilitiesAndPolicy {
        types::CapabilitiesAndPolicy {
            capabilities: types::Capabilities {
                versions: types::VersionRange {
                    minimum: value.api.version.minimum,
                    maximum: value.api.version.maximum,
                },
                maximum_area: value.api.area.maximum,
                maximum_note_area: value.api.note_area.maximum,
                tracepoints_per_page: value.api.tracepoints.per_page,
                maximum_waynodes: value.api.waynodes.maximum,
                maximum_changeset_elements: value.api.changesets.maximum_elements,
                timeout: value.api.timeout.seconds,
                status: types::Status {
                    database: value.api.status.database,
                    api: value.api.status.api,
                    gpx: value.api.status.gpx,
                },
            },
            policy: value.policy,
        }
    }
}

#[derive(Debug, Deserialize)]
struct Api {
    pub version: Version,
    pub area: Area,
    pub note_area: NoteArea,
    pub tracepoints: Tracepoints,
    pub waynodes: Waynodes,
    pub changesets: Changesets,
    pub timeout: Timeout,
    pub status: types::Status,
}

#[derive(Debug, Deserialize)]
struct Version {
    pub minimum: String,
    pub maximum: String,
}

#[derive(Debug, Deserialize)]
struct Area {
    pub maximum: f64,
}

#[derive(Debug, Deserialize)]
struct NoteArea {
    pub maximum: f64,
}

#[derive(Debug, Deserialize)]
struct Tracepoints {
    pub per_page: u64,
}

#[derive(Debug, Deserialize)]
struct Waynodes {
    pub maximum: u64,
}

#[derive(Debug, Deserialize)]
struct Changesets {
    pub maximum_elements: u64,
}

#[derive(Debug, Deserialize)]
struct Timeout {
    pub seconds: u64,
}

pub struct Capabilities {
    client: Openstreetmap,
}

impl Capabilities {
    pub fn new(client: &Openstreetmap) -> Self {
        Capabilities {
            client: client.clone(),
        }
    }

    pub async fn get(&self) -> Result<types::CapabilitiesAndPolicy, OpenstreetmapError> {
        let capabilities_and_policies: types::CapabilitiesAndPolicy = self
            .client
            .request::<(), Osm>(
                reqwest::Method::GET,
                "capabilities",
                types::RequestBody::None,
                RequestOptions::new(),
            )
            .await?
            .into();

        Ok(capabilities_and_policies)
    }
}