1use std::cell::RefCell;
30use std::sync::Arc;
31
32use tera::{Filter, Function, Tera, Value};
33
34use crate::view_restriction::AccessContext;
35
36thread_local! {
37 static CURRENT_ACCESS: RefCell<Option<Arc<AccessContext>>> = const { RefCell::new(None) };
40}
41
42#[must_use = "the guard clears the thread-local on drop; bind it to a local"]
45pub struct AccessGuard {
46 _priv: (),
47}
48
49impl Drop for AccessGuard {
50 fn drop(&mut self) {
51 CURRENT_ACCESS.with(|cell| {
52 *cell.borrow_mut() = None;
53 });
54 }
55}
56
57pub fn install(ctx: AccessContext) -> AccessGuard {
60 CURRENT_ACCESS.with(|cell| {
61 *cell.borrow_mut() = Some(Arc::new(ctx));
62 });
63 AccessGuard { _priv: () }
64}
65
66pub fn register_tera_function(tera: &mut Tera) {
69 tera.register_function("can_view", CanViewFn);
70 tera.register_filter("can_view", CanViewFilter);
71 tera.register_filter("visible", VisibleFilter);
72}
73
74fn value_visible(value: &Value) -> bool {
83 CURRENT_ACCESS.with(|cell| match cell.borrow().as_ref() {
84 None => true,
85 Some(ctx) => {
86 if ctx.is_unrestricted() {
87 return true;
88 }
89 let Some(path) = value.get("path") else {
90 return true;
91 };
92 let Some(path) = path.as_str() else {
93 return false;
94 };
95 match value.get("page_type_id").and_then(Value::as_i64) {
96 Some(tid) => ctx.can_view(path, tid),
97 None => !ctx.gates_by_type() && ctx.can_view(path, 0),
98 }
99 }
100 })
101}
102
103struct CanViewFn;
104
105impl Function for CanViewFn {
106 fn call(&self, args: &std::collections::HashMap<String, Value>) -> tera::Result<Value> {
107 let visible = args.get("page").map(value_visible).unwrap_or(true);
108 Ok(Value::Bool(visible))
109 }
110}
111
112struct CanViewFilter;
113
114impl Filter for CanViewFilter {
115 fn filter(
116 &self,
117 value: &Value,
118 _args: &std::collections::HashMap<String, Value>,
119 ) -> tera::Result<Value> {
120 Ok(Value::Bool(value_visible(value)))
121 }
122}
123
124struct VisibleFilter;
125
126impl Filter for VisibleFilter {
127 fn filter(
128 &self,
129 value: &Value,
130 _args: &std::collections::HashMap<String, Value>,
131 ) -> tera::Result<Value> {
132 Ok(filter_list(value))
133 }
134}
135
136fn filter_list(value: &Value) -> Value {
140 match value {
141 Value::Array(items) => Value::Array(
142 items
143 .iter()
144 .filter(|it| value_visible(it))
145 .map(filter_children)
146 .collect(),
147 ),
148 other => other.clone(),
149 }
150}
151
152fn filter_children(item: &Value) -> Value {
155 let mut out = item.clone();
156 if let Some(obj) = out.as_object_mut() {
157 if let Some(Value::Array(kids)) = obj.get("children") {
158 let filtered: Vec<Value> = kids
159 .iter()
160 .filter(|k| value_visible(k))
161 .map(filter_children)
162 .collect();
163 obj.insert("children".to_owned(), Value::Array(filtered));
164 }
165 }
166 out
167}
168
169#[cfg(test)]
170mod tests {
171 use super::*;
172 use crate::view_restriction::AccessContext;
173 use serde_json::json;
174 use tera::{Context, Tera};
175
176 fn tera() -> Tera {
177 let mut t = Tera::default();
178 register_tera_function(&mut t);
179 t
180 }
181
182 fn render(expr: &str, ctx: &Context) -> String {
183 let mut t = tera();
184 t.add_raw_template("t.html", expr).unwrap();
185 t.render("t.html", ctx).unwrap()
186 }
187
188 #[test]
189 fn can_view_filter_reflects_context() {
190 let _g = install(AccessContext::deny_prefix_for_test("0001/0002/"));
191 let mut ctx = Context::new();
192 ctx.insert(
193 "gated",
194 &json!({ "path": "0001/0002/", "page_type_id": 5, "title": "M" }),
195 );
196 ctx.insert(
197 "open",
198 &json!({ "path": "0001/0003/", "page_type_id": 5, "title": "O" }),
199 );
200 assert_eq!(render("{{ gated | can_view }}", &ctx), "false");
201 assert_eq!(render("{{ open | can_view }}", &ctx), "true");
202 }
203
204 #[test]
206 fn can_view_fails_closed_on_malformed_pages() {
207 let _g = install(AccessContext::deny_type_for_test(5));
208 let mut ctx = Context::new();
209 ctx.insert("no_type", &json!({ "path": "0001/0003/" }));
210 ctx.insert("bad_path", &json!({ "path": 7, "page_type_id": 4 }));
211 ctx.insert("link", &json!({ "title": "Docs", "url": "https://x.test" }));
212 ctx.insert("open", &json!({ "path": "0001/0003/", "page_type_id": 4 }));
213 assert_eq!(render("{{ no_type | can_view }}", &ctx), "false");
214 assert_eq!(render("{{ bad_path | can_view }}", &ctx), "false");
215 assert_eq!(render("{{ link | can_view }}", &ctx), "true");
216 assert_eq!(render("{{ open | can_view }}", &ctx), "true");
217 }
218
219 #[test]
220 fn can_view_defaults_true_without_context() {
221 let mut ctx = Context::new();
223 ctx.insert("p", &json!({ "path": "0001/0002/", "page_type_id": 5 }));
224 assert_eq!(render("{{ p | can_view }}", &ctx), "true");
225 }
226
227 #[test]
228 fn visible_filter_drops_denied_and_recurses() {
229 let _g = install(AccessContext::deny_prefix_for_test("0001/0002/"));
230 let mut ctx = Context::new();
231 ctx.insert(
232 "items",
233 &json!([
234 { "title": "Open", "path": "0001/0003/", "page_type_id": 4,
235 "children": [
236 { "title": "OpenKid", "path": "0001/0003/0009/", "page_type_id": 4 },
237 { "title": "GatedKid", "path": "0001/0002/0008/", "page_type_id": 5 }
238 ] },
239 { "title": "Gated", "path": "0001/0002/", "page_type_id": 5 }
240 ]),
241 );
242 let out = render(
244 "{% for i in items | visible %}{{ i.title }}[{% for c in i.children %}{{ c.title }} {% endfor %}]{% endfor %}",
245 &ctx,
246 );
247 assert_eq!(out, "Open[OpenKid ]");
248 }
249
250 #[test]
251 fn guard_clears_thread_local() {
252 {
253 let _g = install(AccessContext::deny_prefix_for_test("0001/"));
254 let mut ctx = Context::new();
255 ctx.insert("p", &json!({ "path": "0001/0002/", "page_type_id": 5 }));
256 assert_eq!(render("{{ p | can_view }}", &ctx), "false");
257 }
258 let mut ctx = Context::new();
260 ctx.insert("p", &json!({ "path": "0001/0002/", "page_type_id": 5 }));
261 assert_eq!(render("{{ p | can_view }}", &ctx), "true");
262 }
263}