use serde::{Deserialize, Serialize};
use crate::client::Spider;
use crate::ops::{curated_surface, first_page, Call};
use crate::params::ReturnFormat;
use crate::response::{Outcome, Page, Pages};
use crate::transport::route;
use crate::Result;
#[derive(Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct Document {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub html: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub content: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub url: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub lang: Option<String>,
}
impl std::fmt::Debug for Document {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Document")
.field("html", &self.html.as_ref().map(|_| "<redacted>"))
.field("content", &self.content.as_ref().map(|_| "<redacted>"))
.field("url", &self.url.as_ref().map(|_| "<redacted>"))
.field("lang", &self.lang.as_ref().map(|_| "<redacted>"))
.finish_non_exhaustive()
}
}
impl Document {
pub fn html(html: impl Into<String>) -> Document {
Document {
html: Some(html.into()),
..Document::default()
}
}
pub fn content(content: impl Into<String>) -> Document {
Document {
content: Some(content.into()),
..Document::default()
}
}
pub fn from_url(mut self, url: impl Into<String>) -> Document {
self.url = Some(url.into());
self
}
pub fn in_language(mut self, lang: impl Into<String>) -> Document {
self.lang = Some(lang.into());
self
}
}
#[derive(Debug, Clone, Serialize)]
struct TransformBody {
data: Vec<Document>,
#[serde(skip_serializing_if = "Option::is_none")]
return_format: Option<ReturnFormat>,
#[serde(skip_serializing_if = "Option::is_none")]
readability: Option<bool>,
}
#[derive(Debug)]
pub struct Transform<'a> {
call: Call<'a>,
docs: Vec<Document>,
format: Option<ReturnFormat>,
}
impl<'a> Transform<'a> {
pub(crate) fn new(spider: &'a Spider, docs: Vec<Document>) -> Transform<'a> {
Transform {
call: Call::bare(spider),
docs,
format: None,
}
}
pub fn format(mut self, format: ReturnFormat) -> Transform<'a> {
self.format = Some(format);
self
}
pub fn readability(mut self, on: bool) -> Transform<'a> {
self.call.params.readability = Some(on);
self
}
pub async fn send(self) -> Result<Outcome<Page>> {
first_page(self.send_all().await?)
}
pub async fn send_all(mut self) -> Result<Outcome<Pages>> {
let docs = std::mem::take(&mut self.docs);
let format = self.format;
self.call.params.return_format = format.map(Into::into);
self.call
.run(route::TRANSFORM, |params| TransformBody {
data: docs.clone(),
return_format: format,
readability: params.readability,
})
.await
}
}
curated_surface!(Transform);