Skip to main content

har/v1_3/
mod.rs

1use serde::{Deserialize, Serialize};
2use serde_with::skip_serializing_none;
3
4#[skip_serializing_none]
5#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Default)]
6pub struct Log {
7    pub creator: Creator,
8    pub browser: Option<Creator>,
9    pub pages: Option<Vec<Pages>>,
10    pub entries: Vec<Entries>,
11    pub comment: Option<String>,
12}
13
14#[skip_serializing_none]
15#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Default)]
16pub struct Creator {
17    pub name: String,
18    pub version: String,
19    pub comment: Option<String>,
20}
21
22#[skip_serializing_none]
23#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Default)]
24pub struct Pages {
25    #[serde(rename = "startedDateTime")]
26    pub started_date_time: String,
27    pub id: String,
28    pub title: String,
29    #[serde(rename = "pageTimings")]
30    pub page_timings: PageTimings,
31    pub comment: Option<String>,
32}
33
34#[skip_serializing_none]
35#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Default)]
36pub struct PageTimings {
37    #[serde(rename = "onContentLoad", default = "default_fsize_maybe")]
38    pub on_content_load: Option<f64>,
39    #[serde(rename = "onLoad", default = "default_fsize_maybe")]
40    pub on_load: Option<f64>,
41    pub comment: Option<String>,
42}
43
44#[skip_serializing_none]
45#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Default)]
46pub struct Entries {
47    pub pageref: Option<String>,
48    #[serde(rename = "startedDateTime")]
49    pub started_date_time: String,
50    pub time: f64,
51    pub request: Request,
52    pub response: Response,
53    pub cache: Cache,
54    pub timings: Timings,
55    #[serde(rename = "serverIPAddress")]
56    pub server_ip_address: Option<String>,
57    pub connection: Option<String>,
58    pub comment: Option<String>,
59}
60
61#[skip_serializing_none]
62#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Default)]
63pub struct Request {
64    pub method: String,
65    pub url: String,
66    #[serde(rename = "httpVersion")]
67    pub http_version: String,
68    pub cookies: Vec<Cookies>,
69    pub headers: Vec<Headers>,
70    #[serde(rename = "queryString")]
71    pub query_string: Vec<QueryString>,
72    #[serde(rename = "postData")]
73    pub post_data: Option<PostData>,
74    #[serde(rename = "headersSize", deserialize_with = "de_default_isize")]
75    pub headers_size: i64,
76    #[serde(rename = "bodySize", default = "default_isize")]
77    pub body_size: i64,
78    pub comment: Option<String>,
79    #[serde(rename = "headersCompression")]
80    pub headers_compression: Option<i64>,
81}
82
83#[skip_serializing_none]
84#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Default)]
85pub struct Headers {
86    pub name: String,
87    pub value: String,
88    pub comment: Option<String>,
89}
90
91#[skip_serializing_none]
92#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Default)]
93pub struct Cookies {
94    pub name: String,
95    pub value: String,
96    pub path: Option<String>,
97    pub domain: Option<String>,
98    pub expires: Option<String>,
99    #[serde(rename = "httpOnly")]
100    pub http_only: Option<bool>,
101    pub secure: Option<bool>,
102    pub comment: Option<String>,
103}
104
105#[skip_serializing_none]
106#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Default)]
107pub struct QueryString {
108    pub name: String,
109    pub value: String,
110    pub comment: Option<String>,
111}
112
113#[skip_serializing_none]
114#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Default)]
115pub struct PostData {
116    #[serde(rename = "mimeType")]
117    pub mime_type: String,
118    /// Either text or params but not both : TODO turn into an untagged enum
119    pub text: Option<String>,
120    pub params: Option<Vec<Params>>,
121    pub comment: Option<String>,
122    pub encoding: Option<String>,
123}
124
125#[skip_serializing_none]
126#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Default)]
127pub struct Params {
128    pub name: String,
129    pub value: Option<String>,
130    #[serde(rename = "fileName")]
131    pub file_name: Option<String>,
132    #[serde(rename = "contentType")]
133    pub content_type: Option<String>,
134    pub comment: Option<String>,
135    pub encoding: Option<String>,
136}
137
138#[skip_serializing_none]
139#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Default)]
140pub struct Response {
141    pub status: i64,
142    #[serde(rename = "statusText")]
143    pub status_text: String,
144    #[serde(rename = "httpVersion")]
145    pub http_version: String,
146    pub cookies: Vec<Cookies>,
147    pub headers: Vec<Headers>,
148    pub content: Content,
149    #[serde(rename = "redirectURL")]
150    pub redirect_url: Option<String>,
151    #[serde(rename = "headersSize", default = "default_isize")]
152    pub headers_size: i64,
153    #[serde(rename = "bodySize", default = "default_isize")]
154    pub body_size: i64,
155    pub comment: Option<String>,
156    #[serde(rename = "headersCompression")]
157    pub headers_compression: Option<i64>,
158}
159
160#[skip_serializing_none]
161#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Default)]
162pub struct Content {
163    #[serde(default = "default_isize")]
164    pub size: i64,
165    pub compression: Option<i64>,
166    #[serde(rename = "mimeType")]
167    pub mime_type: Option<String>,
168    pub text: Option<String>,
169    pub encoding: Option<String>,
170    pub comment: Option<String>,
171}
172
173#[skip_serializing_none]
174#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Default)]
175pub struct Cache {
176    #[serde(rename = "beforeRequest")]
177    pub before_request: Option<CacheEntity>,
178    #[serde(rename = "afterRequest")]
179    pub after_request: Option<CacheEntity>,
180}
181
182#[skip_serializing_none]
183#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Default)]
184pub struct CacheEntity {
185    pub expires: Option<String>,
186    #[serde(rename = "lastAccess")]
187    pub last_access: String,
188    #[serde(rename = "eTag")]
189    pub e_tag: String,
190    #[serde(rename = "hitCount")]
191    pub hit_count: i64,
192    pub comment: Option<String>,
193}
194
195#[skip_serializing_none]
196#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Default)]
197pub struct Timings {
198    #[serde(default = "default_fsize_maybe")]
199    pub blocked: Option<f64>,
200    #[serde(default = "default_fsize_maybe")]
201    pub dns: Option<f64>,
202    #[serde(default = "default_fsize_maybe")]
203    pub connect: Option<f64>,
204    pub send: f64,
205    pub wait: f64,
206    pub receive: f64,
207    #[serde(default = "default_fsize_maybe")]
208    pub ssl: Option<f64>,
209    pub comment: Option<String>,
210}
211
212fn de_default_isize<'de, D>(deserializer: D) -> Result<i64, D::Error>
213where
214    D: serde::Deserializer<'de>,
215{
216    Ok(Option::<i64>::deserialize(deserializer)?.unwrap_or(-1))
217}
218
219fn default_isize() -> i64 {
220    -1
221}
222
223fn default_fsize_maybe() -> Option<f64> {
224    Some(-1_f64)
225}