sapper_std/
lib.rs

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// ============ Status Code ============
36
37#[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.set_status(status::TemporaryRedirect);
48	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.set_status(status::TemporaryRedirect);
85	$response.headers_mut().set(Location($redirect_uri.to_owned()));
86	$response.write_body(format!("redirect to {}", $redirect_uri));
87    })
88}
89
90// ============ Json ============
91
92#[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// ============ Page Render ============
139
140#[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// ============ Params ============
181
182#[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	// return default
262	$default
263    })
264}
265
266
267
268
269// for PathParams, QueryParams and FormParams
270#[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// for PathParams, QueryParams and FormParams, default version
281#[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// ============ Ext Type Params ============
360#[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}