browser_commander/playwright/protocol/
api_request_context.rs1#![allow(clippy::all, missing_docs, unused_imports)]
5
6use serde::{Deserialize, Serialize};
7
8use super::*;
9use crate::playwright::connection::{
10 Binary, Channel, ChannelType, ObjectRef, ProtocolError, ProtocolEvent, Ref,
11};
12
13#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
15pub struct APIRequestContextInitializer {
16 #[serde(rename = "tracing")]
17 pub tracing: Ref<Tracing>,
18}
19
20#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
22pub struct APIRequestContextFetchParams {
23 #[serde(rename = "url")]
24 pub url: String,
25 #[serde(rename = "encodedParams", default, skip_serializing_if = "Option::is_none")]
26 pub encoded_params: Option<String>,
27 #[serde(rename = "params", default, skip_serializing_if = "Option::is_none")]
28 pub params: Option<Vec<NameValue>>,
29 #[serde(rename = "method", default, skip_serializing_if = "Option::is_none")]
30 pub method: Option<String>,
31 #[serde(rename = "headers", default, skip_serializing_if = "Option::is_none")]
32 pub headers: Option<Vec<NameValue>>,
33 #[serde(rename = "postData", default, skip_serializing_if = "Option::is_none")]
34 pub post_data: Option<Binary>,
35 #[serde(rename = "jsonData", default, skip_serializing_if = "Option::is_none")]
36 pub json_data: Option<String>,
37 #[serde(rename = "formData", default, skip_serializing_if = "Option::is_none")]
38 pub form_data: Option<Vec<NameValue>>,
39 #[serde(rename = "multipartData", default, skip_serializing_if = "Option::is_none")]
40 pub multipart_data: Option<Vec<FormField>>,
41 #[serde(rename = "failOnStatusCode", default, skip_serializing_if = "Option::is_none")]
42 pub fail_on_status_code: Option<bool>,
43 #[serde(rename = "ignoreHTTPSErrors", default, skip_serializing_if = "Option::is_none")]
44 pub ignore_https_errors: Option<bool>,
45 #[serde(rename = "maxRedirects", default, skip_serializing_if = "Option::is_none")]
46 pub max_redirects: Option<i64>,
47 #[serde(rename = "maxRetries", default, skip_serializing_if = "Option::is_none")]
48 pub max_retries: Option<i64>,
49}
50
51#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
53pub struct APIRequestContextFetchResult {
54 #[serde(rename = "response")]
55 pub response: APIResponse,
56}
57
58#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
60pub struct APIRequestContextFetchResponseBodyParams {
61 #[serde(rename = "fetchUid")]
62 pub fetch_uid: String,
63}
64
65#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
67pub struct APIRequestContextFetchResponseBodyResult {
68 #[serde(rename = "binary", default, skip_serializing_if = "Option::is_none")]
69 pub binary: Option<Binary>,
70}
71
72#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
74pub struct APIRequestContextFetchLogParams {
75 #[serde(rename = "fetchUid")]
76 pub fetch_uid: String,
77}
78
79#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
81pub struct APIRequestContextFetchLogResult {
82 #[serde(rename = "log")]
83 pub log: Vec<String>,
84}
85
86#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
88pub struct APIRequestContextStorageStateParams {
89 #[serde(rename = "indexedDB", default, skip_serializing_if = "Option::is_none")]
90 pub indexed_db: Option<bool>,
91}
92
93#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
95pub struct APIRequestContextStorageStateResult {
96 #[serde(rename = "cookies")]
97 pub cookies: Vec<NetworkCookie>,
98 #[serde(rename = "origins")]
99 pub origins: Vec<OriginStorage>,
100}
101
102#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
104pub struct APIRequestContextDisposeAPIResponseParams {
105 #[serde(rename = "fetchUid")]
106 pub fetch_uid: String,
107}
108
109#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
111pub struct APIRequestContextDisposeParams {
112 #[serde(rename = "reason", default, skip_serializing_if = "Option::is_none")]
113 pub reason: Option<String>,
114}
115
116#[derive(Debug, Clone, PartialEq)]
118pub enum APIRequestContextEvent {
119 Unknown {
121 method: String,
123 params: serde_json::Value,
125 },
126}
127
128impl ProtocolEvent for APIRequestContextEvent {
129 fn parse(method: &str, params: serde_json::Value) -> Result<Self, serde_json::Error> {
130 match method {
131 _ => Ok(Self::Unknown { method: method.to_string(), params }),
132 }
133 }
134}
135
136#[derive(Debug, Clone)]
138pub struct APIRequestContext {
139 channel: Channel,
140}
141
142impl ChannelType for APIRequestContext {
143 const INTERFACE: &'static str = "APIRequestContext";
144 type Initializer = APIRequestContextInitializer;
145 type Event = APIRequestContextEvent;
146
147 fn accepts(interface: &str) -> bool {
148 matches!(interface, "APIRequestContext")
149 }
150
151 fn from_channel(channel: Channel) -> Self {
152 Self { channel }
153 }
154
155 fn channel(&self) -> &Channel {
156 &self.channel
157 }
158}
159
160impl APIRequestContext {
161 pub async fn fetch(&self, params: APIRequestContextFetchParams) -> Result<APIRequestContextFetchResult, ProtocolError> {
163 self.channel.send("fetch", ¶ms).await
164 }
165
166 pub async fn fetch_response_body(&self, params: APIRequestContextFetchResponseBodyParams) -> Result<APIRequestContextFetchResponseBodyResult, ProtocolError> {
168 self.channel.send("fetchResponseBody", ¶ms).await
169 }
170
171 pub async fn fetch_log(&self, params: APIRequestContextFetchLogParams) -> Result<APIRequestContextFetchLogResult, ProtocolError> {
173 self.channel.send("fetchLog", ¶ms).await
174 }
175
176 pub async fn storage_state(&self, params: APIRequestContextStorageStateParams) -> Result<APIRequestContextStorageStateResult, ProtocolError> {
178 self.channel.send("storageState", ¶ms).await
179 }
180
181 pub async fn dispose_api_response(&self, params: APIRequestContextDisposeAPIResponseParams) -> Result<(), ProtocolError> {
183 self.channel.send_no_result("disposeAPIResponse", ¶ms).await
184 }
185
186 pub async fn dispose(&self, params: APIRequestContextDisposeParams) -> Result<(), ProtocolError> {
188 self.channel.send_no_result("dispose", ¶ms).await
189 }
190}