use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;
use std::time::Duration;
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct Timeout {
pub secs: u64,
pub nanos: u32,
}
impl Timeout {
pub const fn from_secs(secs: u64) -> Timeout {
Timeout { secs, nanos: 0 }
}
pub const fn from_millis(millis: u64) -> Timeout {
Timeout {
secs: millis / 1_000,
nanos: ((millis % 1_000) * 1_000_000) as u32,
}
}
}
impl From<Duration> for Timeout {
fn from(value: Duration) -> Timeout {
Timeout {
secs: value.as_secs(),
nanos: value.subsec_nanos(),
}
}
}
impl From<Timeout> for Duration {
fn from(value: Timeout) -> Duration {
Duration::new(value.secs, value.nanos)
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct IdleNetwork {
pub timeout: Timeout,
}
impl IdleNetwork {
pub const fn new(timeout: Timeout) -> IdleNetwork {
IdleNetwork { timeout }
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct SelectorWait {
pub timeout: Timeout,
pub selector: String,
}
impl SelectorWait {
pub fn new(selector: impl Into<String>, timeout: Timeout) -> SelectorWait {
SelectorWait {
timeout,
selector: selector.into(),
}
}
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct Delay {
pub timeout: Timeout,
}
impl Delay {
pub const fn new(timeout: Timeout) -> Delay {
Delay { timeout }
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct WaitFor {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub idle_network: Option<IdleNetwork>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub idle_network0: Option<IdleNetwork>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub almost_idle_network0: Option<IdleNetwork>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub selector: Option<SelectorWait>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub dom: Option<SelectorWait>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub delay: Option<Delay>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub page_navigations: Option<bool>,
}
impl WaitFor {
pub fn idle_network(timeout: Timeout) -> WaitFor {
WaitFor {
idle_network: Some(IdleNetwork::new(timeout)),
..WaitFor::default()
}
}
pub fn selector(selector: impl Into<String>, timeout: Timeout) -> WaitFor {
WaitFor {
selector: Some(SelectorWait::new(selector, timeout)),
..WaitFor::default()
}
}
pub fn delay(timeout: Timeout) -> WaitFor {
WaitFor {
delay: Some(Delay::new(timeout)),
..WaitFor::default()
}
}
pub fn is_empty(&self) -> bool {
self == &WaitFor::default()
}
}
#[derive(Clone, PartialEq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum WebAutomation {
Evaluate(String),
Click(String),
ClickAll(String),
ClickAllClickable(),
ClickPoint {
x: f64,
y: f64,
},
ClickHold {
selector: String,
hold_for_ms: u64,
},
ClickHoldPoint {
x: f64,
y: f64,
hold_for_ms: u64,
},
ClickDrag {
from: String,
to: String,
modifier: Option<i64>,
},
ClickDragPoint {
from_x: f64,
from_y: f64,
to_x: f64,
to_y: f64,
modifier: Option<i64>,
},
Type {
value: String,
modifier: Option<i64>,
},
Wait(u64),
WaitForNavigation,
WaitForDom {
selector: Option<String>,
timeout: u32,
},
WaitFor(String),
WaitForWithTimeout {
selector: String,
timeout: u64,
},
WaitForAndClick(String),
ScrollX(i32),
ScrollY(i32),
Fill {
selector: String,
value: String,
},
InfiniteScroll(u32),
Screenshot {
full_page: bool,
omit_background: bool,
output: String,
},
ValidateChain,
}
impl std::fmt::Debug for WebAutomation {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let variant = match self {
Self::Evaluate(..) => "Evaluate",
Self::Click(..) => "Click",
Self::ClickAll(..) => "ClickAll",
Self::ClickAllClickable(..) => "ClickAllClickable",
Self::ClickPoint { .. } => "ClickPoint",
Self::ClickHold { .. } => "ClickHold",
Self::ClickHoldPoint { .. } => "ClickHoldPoint",
Self::ClickDrag { .. } => "ClickDrag",
Self::ClickDragPoint { .. } => "ClickDragPoint",
Self::Type { .. } => "Type",
Self::Wait(..) => "Wait",
Self::WaitForNavigation => "WaitForNavigation",
Self::WaitForDom { .. } => "WaitForDom",
Self::WaitFor(..) => "WaitFor",
Self::WaitForWithTimeout { .. } => "WaitForWithTimeout",
Self::WaitForAndClick(..) => "WaitForAndClick",
Self::ScrollX(..) => "ScrollX",
Self::ScrollY(..) => "ScrollY",
Self::Fill { .. } => "Fill",
Self::InfiniteScroll(..) => "InfiniteScroll",
Self::Screenshot { .. } => "Screenshot",
Self::ValidateChain => "ValidateChain",
};
f.debug_tuple(variant).field(&"<redacted>").finish()
}
}
pub type WebAutomationMap = BTreeMap<String, Vec<WebAutomation>>;
pub type ExecutionScriptsMap = BTreeMap<String, String>;
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct EventTracker {
#[serde(default, serialize_with = "false_when_unset")]
pub responses: Option<bool>,
#[serde(default, serialize_with = "false_when_unset")]
pub requests: Option<bool>,
#[serde(default, serialize_with = "false_when_unset")]
pub automation: Option<bool>,
}
fn false_when_unset<S: serde::Serializer>(value: &Option<bool>, s: S) -> Result<S::Ok, S::Error> {
s.serialize_bool(value.unwrap_or(false))
}