elastic_parser/
lib.rs

1pub mod aggregation;
2
3extern crate serde;
4extern crate serde_json;
5
6#[derive(Debug, Serialize, Deserialize)]
7pub struct SearchResponse<T: Clone> {
8    #[serde(default)]
9    pub _scroll_id: Option<String>,
10    #[serde(default)]
11    pub took: Option<usize>,
12    pub hits: Option<Hits<T>>,
13    #[serde(default)]
14    pub aggregations: Option<Value>,
15}
16
17impl<T: Clone> SearchResponse<T> {
18    pub fn total_value(&self) -> usize {
19        if self.hits.is_none() {
20            return 0;
21        }
22        if self.hits.as_ref().is_none() {
23            return 0;
24        }
25
26        let hits = self.hits.as_ref().unwrap();
27        if hits.total.as_ref().is_none() {
28            return 0;
29        }
30        let total = hits.total.as_ref().unwrap();
31        total.value.unwrap_or_default()
32    }
33    pub fn sources(&self) -> Vec<&T> {
34        if self.hits.is_none() {
35            return vec![];
36        }
37        let hits = self.hits.as_ref().unwrap();
38        if hits.hits.is_none() {
39            return vec![];
40        }
41        let mut data = vec![];
42        let hits = hits.hits.as_ref().unwrap();
43        for hit in hits {
44            if hit._source.is_some() {
45                data.push(hit._source.as_ref().unwrap());
46            }
47        }
48        data
49    }
50    pub fn hits(&self) -> Vec<Hit<T>> {
51        if self.hits.is_none() {
52            return vec![];
53        }
54        let hits = self.hits.clone().unwrap();
55        if hits.hits.is_none() {
56            return vec![];
57        }
58        let mut data = vec![];
59        let hits = hits.hits.unwrap();
60        for hit in hits {
61            data.push(hit.clone());
62        }
63        data
64    }
65    pub fn aggregations(&self) -> Option<AggregationResponseParser> {
66        if self.aggregations.is_none() {
67            return None;
68        }
69        Some(AggregationResponseParser::new(
70            self.aggregations.clone().unwrap(),
71        ))
72    }
73}
74
75#[derive(Debug, Serialize, Deserialize, Clone)]
76pub struct HitsTotal {
77    #[serde(default)]
78    pub value: Option<usize>,
79    #[serde(default)]
80    pub relation: Option<String>,
81}
82
83#[derive(Debug, Serialize, Deserialize, Clone)]
84pub struct Hits<T: Clone> {
85    pub total: Option<HitsTotal>,
86    pub max_score: Option<f32>,
87    pub hits: Option<Vec<Hit<T>>>,
88}
89
90// impl<T> Hits<T> {
91//     fn total(&self) -> HitsTotal {
92//         return match self.total.clone() {
93//             Some(v) => { v }
94//             None => {
95//                 HitsTotal {
96//                     value: 0,
97//                     relation: "".to_string(),
98//                 }
99//             }
100//         };
101//     }
102//     fn max_score(&self) -> f32 {
103//         self.max_score.unwrap_or(0.0)
104//     }
105// }
106
107#[derive(Debug, Serialize, Deserialize, Default, Clone)]
108pub struct Hit<T>
109where
110    T: Clone,
111{
112    #[serde(default)]
113    pub _index: Option<String>,
114    #[serde(default)]
115    pub _type: Option<String>,
116    #[serde(default)]
117    pub _id: Option<String>,
118    #[serde(default)]
119    pub _score: Option<f32>,
120    pub _source: Option<T>,
121}
122
123impl<T: std::default::Default + std::clone::Clone> Hit<T> {
124    pub fn index(&self) -> String {
125        if self._index.is_none() {
126            return "".to_string();
127        }
128        self._index.as_ref().unwrap().to_string()
129    }
130
131    // pub fn get_type(&self) -> String {
132    //     self.clone()._type.unwrap_or_default().to_string()
133    // }
134    pub fn id(&self) -> String {
135        self.clone()._id.unwrap_or_default().to_string()
136    }
137    // pub fn score(&self) -> f32 {
138    //     self.clone()._score.unwrap_or_default().clone()
139    // }
140}
141
142#[derive(Debug, Serialize, Deserialize, Clone)]
143pub struct Doc<T> {
144    pub _index: String,
145    pub _type: String,
146    pub _id: String,
147    // pub found:bool,
148    // pub _version: Option<usize>,
149    // pub _seq_no: Option<usize>,
150    // pub _primary_term: Option<usize>,
151    pub _source: Option<T>,
152}
153
154#[derive(Debug, Serialize, Deserialize, Clone)]
155pub struct Shards {
156    pub total: Option<usize>,
157    pub successful: Option<usize>,
158    pub failed: Option<usize>,
159}
160
161use crate::aggregation::AggregationResponseParser;
162use serde::{de, Deserialize, Serialize};
163use serde_json::Value;
164
165pub fn parse<'a, T>(s: &'a str) -> T
166where
167    T: de::Deserialize<'a>,
168{
169    serde_json::from_str(s).expect("")
170}
171
172impl<T> SearchResponse<T>
173where
174    T: std::clone::Clone,
175{
176    pub fn to_hit(&self) -> Vec<Hit<T>> {
177        let hits = self.hits.clone();
178        if hits.is_none() {
179            return vec![];
180        }
181        hits.unwrap().hits.unwrap_or_default().to_vec()
182    }
183}
elastic_parser/lib.rs

elastic_parser/
lib.rs
