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
|
use super::{client, deserialize, Authenticate};
use crate::{
entities::{account::Account, card::Card, context::Context, status::Status},
errors::{Error, Result},
};
use http_types::{Method, Request, Response};
use hyper_old_types::header::{parsing, Link, RelationType};
use smol::{prelude::*, Async};
use std::{
fmt::Debug,
net::{TcpStream, ToSocketAddrs},
};
use url::Url;
// link header name
const LINK: &str = "link";
#[derive(Debug)]
pub struct Page<'client, T, A: Authenticate + Debug + 'client> {
next: Option<Request>,
prev: Option<Request>,
auth: &'client A,
_marker: std::marker::PhantomData<T>,
}
impl<'client, T: serde::de::DeserializeOwned, A: Authenticate + Debug + 'client>
Page<'client, T, A>
{
pub fn new(next: Request, auth: &'client A) -> Page<'client, T, A> {
Page {
next: Some(next),
prev: None,
auth,
_marker: std::marker::PhantomData,
}
}
pub async fn next_page(&mut self) -> Result<Option<Vec<T>>> {
let mut req = if let Some(next) = self.next.take() {
next
} else {
return Ok(None);
};
Ok(self.send(req).await?)
}
pub async fn prev_page(&mut self) -> Result<Option<Vec<T>>> {
let req = if let Some(prev) = self.prev.take() {
prev
} else {
return Ok(None);
};
Ok(self.send(req).await?)
}
async fn send(&mut self, mut req: Request) -> Result<Option<Vec<T>>> {
self.auth.authenticate(&mut req).await?;
log::trace!("Request: {:?}", req);
let response = client::fetch(req).await?;
log::trace!("Response: {:?}", response);
self.fill_links_from_resp(&response)?;
let items = deserialize(response).await?;
Ok(items)
}
fn fill_links_from_resp(&mut self, response: &Response) -> Result<()> {
let (prev, next) = get_links(&response)?;
self.prev = prev.map(|url| Request::new(Method::Get, url));
self.next = next.map(|url| Request::new(Method::Get, url));
Ok(())
}
}
fn get_links(response: &Response) -> Result<(Option<Url>, Option<Url>)> {
let mut prev = None;
let mut next = None;
if let Some(link_header) = response.header(LINK) {
let link_header = link_header.as_str();
let link_header = link_header.as_bytes();
let link_header: Link = parsing::from_raw_str(&link_header)?;
for value in link_header.values() {
if let Some(relations) = value.rel() {
if relations.contains(&RelationType::Next) {
next = Some(Url::parse(value.link())?);
}
if relations.contains(&RelationType::Prev) {
prev = Some(Url::parse(value.link())?);
}
}
}
}
Ok((prev, next))
}
|
