Skip to main content

har/v1_2/
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}
80
81#[skip_serializing_none]
82#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Default)]
83pub struct Headers {
84    pub name: String,
85    pub value: String,
86    pub comment: Option<String>,
87}
88
89#[skip_serializing_none]
90#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Default)]
91pub struct Cookies {
92    pub name: String,
93    pub value: String,
94    pub path: Option<String>,
95    pub domain: Option<String>,
96    pub expires: Option<String>,
97    #[serde(rename = "httpOnly")]
98    pub http_only: Option<bool>,
99    pub secure: Option<bool>,
100    pub comment: Option<String>,
101}
102
103#[skip_serializing_none]
104#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Default)]
105pub struct QueryString {
106    pub name: String,
107    pub value: String,
108    pub comment: Option<String>,
109}
110
111#[skip_serializing_none]
112#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Default)]
113pub struct PostData {
114    #[serde(rename = "mimeType")]
115    pub mime_type: String,
116    /// Either text or params but not both : TODO turn into an untagged enum
117    pub text: Option<String>,
118    pub params: Option<Vec<Params>>,
119    pub comment: Option<String>,
120}
121
122#[skip_serializing_none]
123#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Default)]
124pub struct Params {
125    pub name: String,
126    pub value: Option<String>,
127    #[serde(rename = "fileName")]
128    pub file_name: Option<String>,
129    #[serde(rename = "contentType")]
130    pub content_type: Option<String>,
131    pub comment: Option<String>,
132}
133
134#[skip_serializing_none]
135#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Default)]
136pub struct Response {
137    pub status: i64,
138    #[serde(rename = "statusText")]
139    pub status_text: String,
140    #[serde(rename = "httpVersion")]
141    pub http_version: String,
142    pub cookies: Vec<Cookies>,
143    pub headers: Vec<Headers>,
144    pub content: Content,
145    #[serde(rename = "redirectURL")]
146    pub redirect_url: Option<String>,
147    #[serde(rename = "headersSize", default = "default_isize")]
148    pub headers_size: i64,
149    #[serde(rename = "bodySize", default = "default_isize")]
150    pub body_size: i64,
151    pub comment: Option<String>,
152}
153
154#[skip_serializing_none]
155#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Default)]
156pub struct Content {
157    #[serde(default = "default_isize")]
158    pub size: i64,
159    pub compression: Option<i64>,
160    #[serde(rename = "mimeType")]
161    pub mime_type: Option<String>,
162    pub text: Option<String>,
163    pub encoding: Option<String>,
164    pub comment: Option<String>,
165}
166
167#[skip_serializing_none]
168#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Default)]
169pub struct Cache {
170    #[serde(rename = "beforeRequest")]
171    pub before_request: Option<CacheEntity>,
172    #[serde(rename = "afterRequest")]
173    pub after_request: Option<CacheEntity>,
174}
175
176#[skip_serializing_none]
177#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Default)]
178pub struct CacheEntity {
179    pub expires: Option<String>,
180    #[serde(rename = "lastAccess")]
181    pub last_access: String,
182    #[serde(rename = "eTag")]
183    pub e_tag: String,
184    #[serde(rename = "hitCount")]
185    pub hit_count: i64,
186    pub comment: Option<String>,
187}
188
189#[skip_serializing_none]
190#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Default)]
191pub struct Timings {
192    #[serde(default = "default_fsize_maybe")]
193    pub blocked: Option<f64>,
194    #[serde(default = "default_fsize_maybe")]
195    pub dns: Option<f64>,
196    #[serde(default = "default_fsize_maybe")]
197    pub connect: Option<f64>,
198    pub send: f64,
199    pub wait: f64,
200    pub receive: f64,
201    #[serde(default = "default_fsize_maybe")]
202    pub ssl: Option<f64>,
203    pub comment: Option<String>,
204}
205
206fn de_default_isize<'de, D>(deserializer: D) -> Result<i64, D::Error>
207where
208    D: serde::Deserializer<'de>,
209{
210    Ok(Option::<i64>::deserialize(deserializer)?.unwrap_or(-1))
211}
212
213fn default_isize() -> i64 {
214    -1
215}
216
217fn default_fsize_maybe() -> Option<f64> {
218    Some(-1_f64)
219}