1use sapper::{Request, Response, Result};
2
3pub use sapper::PathParams;
4pub use sapper_query::QueryParams;
5pub use sapper_body::FormParams;
6pub use sapper_body::JsonParams;
7pub use sapper_session::{ SessionVal, set_cookie };
8pub use sapper_tmpl::{
9 Context as WebContext,
10 TERA,
11 TeraResult,
12 TeraValue,
13 to_value,
14 render,
15};
16pub use sapper_logger::splog;
17
18pub fn init(req: &mut Request, cookie_key: Option<&'static str>) -> Result<()> {
19 sapper_logger::init(req)?;
20 sapper_query::parse(req)?;
21 sapper_body::parse(req)?;
22 sapper_session::session_val(req, cookie_key)?;
23
24 Ok(())
25}
26
27
28pub fn finish(req: &Request, res: &mut Response) -> Result<()> {
29 sapper_logger::splog(req, res.status())?;
30
31 Ok(())
32}
33
34
35#[macro_export]
38macro_rules! res_redirect {
39 ($redirect_uri:expr) => ({
40 use sapper::Response;
41 use sapper::status;
42 use sapper::header::Location;
43
44 let mut response = Response::new();
45
46 response.set_status(status::Found);
47 response.headers_mut().set(Location($redirect_uri.to_owned()));
49 response.write_body(format!("redirect to {}", $redirect_uri));
50
51 Ok(response)
52 })
53}
54
55#[macro_export]
56macro_rules! res_400 {
57 ($info:expr) => ({
58 Err(sapper::Error::Break($info.to_string()))
59 })
60}
61
62#[macro_export]
63macro_rules! res_404 {
64 () => ({
65 Err(sapper::Error::NotFound)
66 })
67}
68
69#[macro_export]
70macro_rules! res_500 {
71 ($info:expr) => ({
72 Err(sapper::Error::InternalServerError($info.to_string()))
73 })
74}
75
76
77#[macro_export]
78macro_rules! set_response_redirect {
79 ($response:expr, $redirect_uri:expr) => ({
80 use sapper::status;
81 use sapper::header::Location;
82
83 $response.set_status(status::Found);
84 $response.headers_mut().set(Location($redirect_uri.to_owned()));
86 $response.write_body(format!("redirect to {}", $redirect_uri));
87 })
88}
89
90#[macro_export]
93macro_rules! res_json {
94 ($json:expr) => ({
95 use serde_json;
96 use sapper::Response;
97 use sapper::header::ContentType;
98
99 let mut response = Response::new();
100 response.headers_mut().set(ContentType::json());
101 response.write_body(serde_json::to_string(&$json).unwrap());
102
103 Ok(response)
104 })
105}
106
107
108#[macro_export]
109macro_rules! res_json_ok {
110 ($info:expr) => ({
111 use sapper::Response;
112 use serde_json;
113
114 let json2ret = json!({
115 "success": true,
116 "info": $info
117 });
118
119 res_json!(json2ret)
120 })
121}
122
123#[macro_export]
124macro_rules! res_json_error {
125 ($info:expr) => ({
126 use sapper::Response;
127 use serde_json;
128
129 let json2ret = json!({
130 "success": false,
131 "info": $info
132 });
133
134 res_json!(json2ret)
135 })
136}
137
138#[macro_export]
141macro_rules! res_html {
142 ($html:expr, $context:expr) => ({
143 use sapper::Response;
144 use sapper::header::ContentType;
145
146 let res_str = render($html, $context);
147
148 let mut response = Response::new();
149 response.headers_mut().set(ContentType::html());
150 response.write_body(res_str);
151
152 Ok(response)
153 })
154}
155
156
157#[macro_export]
158macro_rules! res_html_before {
159 ($context:expr) => ({
160 Err(sapper::Error::CustomHtml($context))
161 })
162}
163
164#[macro_export]
165macro_rules! res_xml_string {
166 ($context:expr) => ({
167 use sapper::Response;
168 use sapper::status::StatusCode;
169
170 let mut res = Response::new();
171 res.set_status(StatusCode::Ok);
172 res.headers_mut().set_raw("Content-Type", vec!["text/xml".as_bytes().to_vec()]);
173 res.write_body($context);
174
175 Ok(res)
176 })
177}
178
179
180#[macro_export]
183macro_rules! get_params {
184 ($req:expr, $tykey:ty) => ({
185 match $req.ext().get::<$tykey>() {
186 Some(params) => {
187 params
188 },
189 None => {
190 let info = "no params";
191 info!("{}", info);
192 return res_400!(info);
193 }
194 }
195 })
196}
197
198#[macro_export]
199macro_rules! get_path_params {
200 ($req:expr) => ({
201 get_params!($req, PathParams)
202 })
203}
204
205
206#[macro_export]
207macro_rules! get_query_params {
208 ($req:expr) => ({
209 get_params!($req, QueryParams)
210 })
211}
212
213#[macro_export]
214macro_rules! get_form_params {
215 ($req:expr) => ({
216 get_params!($req, FormParams)
217 })
218}
219
220#[macro_export]
221macro_rules! get_json_params {
222 ($req:expr) => ({
223 match serde_json::from_value(get_params!($req, JsonParams).clone()) {
224 Ok(val) => val,
225 Err(_) => {
226 let info = "Json parameter not match to struct.";
227 info!("{}", info);
228 return res_400!(info);
229 }
230 }
231 })
232}
233
234#[macro_export]
235macro_rules! t_cond {
236 ($bool:expr, $prompt:expr) => ({
237 match $bool {
238 true => (),
239 false => {
240 let info = format!("test param condition result: {}", $prompt);
241 info!("{}", info);
242 return res_400!(info);
243 }
244 }
245 })
246}
247
248#[macro_export]
249macro_rules! _missing_or_unrecognized {
250 ($field:expr) => ({
251 let info = format!("missing or unrecognized parameter {}.", $field);
252 info!("{}",info);
253 return res_400!(info);
254 })
255}
256
257#[macro_export]
258macro_rules! _using_default {
259 ($field:expr, $default:expr) => ({
260 info!("missing or unrecognized parameter {}, using default {}.", $field, $default);
261 $default
263 })
264}
265
266
267
268
269#[macro_export]
271macro_rules! t_param {
272 ($params:expr, $field:expr) => ({
273 match $params.get($field) {
274 Some(ref astr) => &astr[0],
275 None => _missing_or_unrecognized! ($field)
276 }
277 })
278}
279
280#[macro_export]
282macro_rules! t_param_default {
283 ($params:expr, $field:expr, $default:expr) => ({
284 match $params.get($field) {
285 Some(ref astr) => &astr[0],
286 None => _using_default! ($field, $default)
287 }
288 })
289}
290
291#[macro_export]
292macro_rules! t_param_parse {
293 ($params:expr, $field:expr, $tykey:ty) => ({
294 match $params.get($field) {
295 Some(ref astr) => {
296 let _t = &astr[0];
297 match _t.parse::<$tykey>() {
298 Ok(output) => output,
299 Err(_) => {
300 let info = format!("parse parameter type error {}.", $field);
301 info!("{}", info);
302 return res_400!(info);
303 }
304 }
305 },
306 None => _missing_or_unrecognized! ($field)
307 }
308 })
309}
310
311#[macro_export]
312macro_rules! t_param_parse_default {
313 ($params:expr, $field:expr, $tykey:ty, $default:expr) => ({
314 match $params.get($field) {
315 Some(ref astr) => {
316 let _t = &astr[0];
317 match _t.parse::<$tykey>() {
318 Ok(output) => output,
319 Err(_) => {
320 _using_default! ($field, $default)
321 }
322 }
323 },
324 None => _using_default! ($field, $default)
325 }
326 })
327}
328
329#[macro_export]
330macro_rules! t_arr_param {
331 ($params:expr, $field:expr) => ({
332 match $params.get($field) {
333 Some(ref arr) => *arr,
334 None => _missing_or_unrecognized! ($field)
335 }
336 })
337}
338
339#[macro_export]
340macro_rules! t_arr_param_default {
341 ($params:expr, $field:expr, $default:expr) => ({
342 match $params.get($field) {
343 Some(ref arr) => *arr,
344 None => _using_default! ($field, $default)
345 }
346 })
347}
348
349#[macro_export]
350macro_rules! t_has_param {
351 ($params:expr, $field:expr) => ({
352 match $params.get($field) {
353 Some(_) => true,
354 None => false
355 }
356 })
357}
358
359#[macro_export]
361macro_rules! get_ext {
362 ($req:expr, $tykey:ty) => ({
363 match $req.ext().get::<$tykey>() {
364 Some(entity) => {
365 Some(entity)
366 },
367 None => None
368 }
369 })
370}
371
372
373#[macro_export]
374macro_rules! get_ext_owned {
375 ($req:expr, $tykey:ty) => ({
376 match $req.ext().get::<$tykey>() {
377 Some(entity) => {
378 Some(entity.clone())
379 },
380 None => None
381 }
382 })
383}