🔀 Merge branch 'release/v82'
[Sone.git] / web / page / FreenetTemplatePage.java
1 /*
2  * Sone - FreenetTemplatePage.java - Copyright Â© 2010 David Roden
3  *
4  * This program is free software: you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation, either version 3 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
16  */
17
18 package net.pterodactylus.sone.web.page;
19
20 import java.io.IOException;
21 import java.io.StringWriter;
22 import java.util.Collection;
23 import java.util.Collections;
24 import java.util.List;
25 import java.util.Map;
26 import java.util.Map.Entry;
27 import java.util.logging.Level;
28 import java.util.logging.Logger;
29
30 import net.pterodactylus.util.logging.Logging;
31 import net.pterodactylus.util.template.Template;
32 import net.pterodactylus.util.template.TemplateContext;
33 import net.pterodactylus.util.template.TemplateContextFactory;
34 import net.pterodactylus.util.web.Method;
35 import net.pterodactylus.util.web.Page;
36 import net.pterodactylus.util.web.RedirectResponse;
37 import net.pterodactylus.util.web.Response;
38 import freenet.clients.http.LinkEnabledCallback;
39 import freenet.clients.http.PageMaker;
40 import freenet.clients.http.PageNode;
41 import freenet.clients.http.ToadletContext;
42 import freenet.support.HTMLNode;
43
44 /**
45  * Base class for all {@link Page}s that are rendered with {@link Template}s and
46  * fit into Freenet’s web interface.
47  *
48  * @author <a href="mailto:bombe@pterodactylus.net">David â€˜Bombe’ Roden</a>
49  */
50 public class FreenetTemplatePage implements Page<FreenetRequest>, LinkEnabledCallback {
51
52         /** The logger. */
53         private static final Logger logger = Logging.getLogger(FreenetTemplatePage.class);
54
55         /** The path of the page. */
56         private final String path;
57
58         /** The template context factory. */
59         private final TemplateContextFactory templateContextFactory;
60
61         /** The template to render. */
62         private final Template template;
63
64         /** Where to redirect for invalid form passwords. */
65         private final String invalidFormPasswordRedirectTarget;
66
67         /**
68          * Creates a new template page.
69          *
70          * @param path
71          *            The path of the page
72          * @param templateContextFactory
73          *            The template context factory
74          * @param template
75          *            The template to render
76          * @param invalidFormPasswordRedirectTarget
77          *            The target to redirect to if a POST request does not contain
78          *            the correct form password
79          */
80         public FreenetTemplatePage(String path, TemplateContextFactory templateContextFactory, Template template, String invalidFormPasswordRedirectTarget) {
81                 this.path = path;
82                 this.templateContextFactory = templateContextFactory;
83                 this.template = template;
84                 this.invalidFormPasswordRedirectTarget = invalidFormPasswordRedirectTarget;
85         }
86
87         /**
88          * {@inheritDoc}
89          */
90         @Override
91         public String getPath() {
92                 return path;
93         }
94
95         /**
96          * Returns the title of the page.
97          *
98          * @param request
99          *            The request to serve
100          * @return The title of the page
101          */
102         protected String getPageTitle(FreenetRequest request) {
103                 return null;
104         }
105
106         /**
107          * {@inheritDoc}
108          */
109         @Override
110         public boolean isPrefixPage() {
111                 return false;
112         }
113
114         /**
115          * {@inheritDoc}
116          */
117         @Override
118         public Response handleRequest(FreenetRequest request, Response response) throws IOException {
119                 String redirectTarget = getRedirectTarget(request);
120                 if (redirectTarget != null) {
121                         return new RedirectResponse(redirectTarget);
122                 }
123
124                 if (isFullAccessOnly() && !request.getToadletContext().isAllowedFullAccess()) {
125                         return response.setStatusCode(401).setStatusText("Not authorized").setContentType("text/html");
126                 }
127                 ToadletContext toadletContext = request.getToadletContext();
128                 if (request.getMethod() == Method.POST) {
129                         /* require form password. */
130                         String formPassword = request.getHttpRequest().getPartAsStringFailsafe("formPassword", 32);
131                         if (!formPassword.equals(toadletContext.getContainer().getFormPassword())) {
132                                 return new RedirectResponse(invalidFormPasswordRedirectTarget);
133                         }
134                 }
135                 PageMaker pageMaker = toadletContext.getPageMaker();
136                 PageNode pageNode = pageMaker.getPageNode(getPageTitle(request), toadletContext);
137                 for (String styleSheet : getStyleSheets()) {
138                         pageNode.addCustomStyleSheet(styleSheet);
139                 }
140                 for (Map<String, String> linkNodeParameters : getAdditionalLinkNodes(request)) {
141                         HTMLNode linkNode = pageNode.headNode.addChild("link");
142                         for (Entry<String, String> parameter : linkNodeParameters.entrySet()) {
143                                 linkNode.addAttribute(parameter.getKey(), parameter.getValue());
144                         }
145                 }
146                 String shortcutIcon = getShortcutIcon();
147                 if (shortcutIcon != null) {
148                         pageNode.addForwardLink("icon", shortcutIcon);
149                 }
150
151                 TemplateContext templateContext = templateContextFactory.createTemplateContext();
152                 templateContext.mergeContext(template.getInitialContext());
153                 try {
154                         long start = System.nanoTime();
155                         processTemplate(request, templateContext);
156                         long finish = System.nanoTime();
157                         logger.log(Level.FINEST, "Template was rendered in " + ((finish - start) / 1000) / 1000.0 + "ms.");
158                 } catch (RedirectException re1) {
159                         return new RedirectResponse(re1.getTarget());
160                 }
161
162                 StringWriter stringWriter = new StringWriter();
163                 template.render(templateContext, stringWriter);
164                 pageNode.content.addChild("%", stringWriter.toString());
165
166                 postProcess(request, templateContext);
167
168                 return response.setStatusCode(200).setStatusText("OK").setContentType("text/html").write(pageNode.outer.generate());
169         }
170
171         /**
172          * Can be overridden to return a custom set of style sheets that are to be
173          * included in the page’s header.
174          *
175          * @return Additional style sheets to load
176          */
177         protected Collection<String> getStyleSheets() {
178                 return Collections.emptySet();
179         }
180
181         /**
182          * Returns the name of the shortcut icon to include in the page’s header.
183          *
184          * @return The URL of the shortcut icon, or {@code null} for no icon
185          */
186         protected String getShortcutIcon() {
187                 return null;
188         }
189
190         /**
191          * Can be overridden when extending classes need to set variables in the
192          * template before it is rendered.
193          *
194          * @param request
195          *            The request that is rendered
196          * @param templateContext
197          *            The template context to set variables in
198          * @throws RedirectException
199          *             if the processing page wants to redirect after processing
200          */
201         protected void processTemplate(FreenetRequest request, TemplateContext templateContext) throws RedirectException {
202                 /* do nothing. */
203         }
204
205         /**
206          * This method will be called after
207          * {@link #processTemplate(FreenetRequest, TemplateContext)} has processed
208          * the template and the template was rendered. This method will not be
209          * called if {@link #processTemplate(FreenetRequest, TemplateContext)}
210          * throws a {@link RedirectException}!
211          *
212          * @param request
213          *            The request being processed
214          * @param templateContext
215          *            The template context that supplied the rendered data
216          */
217         protected void postProcess(FreenetRequest request, TemplateContext templateContext) {
218                 /* do nothing. */
219         }
220
221         /**
222          * Can be overridden to redirect the user to a different page, in case a log
223          * in is required, or something else is wrong.
224          *
225          * @param request
226          *            The request that is processed
227          * @return The URL to redirect to, or {@code null} to not redirect
228          */
229         protected String getRedirectTarget(FreenetRequest request) {
230                 return null;
231         }
232
233         /**
234          * Returns additional &lt;link&gt; nodes for the HTML’s &lt;head&gt; node.
235          *
236          * @param request
237          *            The request for which to return the link nodes
238          * @return All link nodes that should be added to the HTML head
239          */
240         protected List<Map<String, String>> getAdditionalLinkNodes(FreenetRequest request) {
241                 return Collections.emptyList();
242         }
243
244         /**
245          * Returns whether this page should only be allowed for requests from hosts
246          * with full access.
247          *
248          * @return {@code true} if this page should only be allowed for hosts with
249          *         full access, {@code false} to allow this page for any host
250          */
251         protected boolean isFullAccessOnly() {
252                 return false;
253         }
254
255         //
256         // INTERFACE LinkEnabledCallback
257         //
258
259         /**
260          * {@inheritDoc}
261          */
262         @Override
263         public boolean isEnabled(ToadletContext toadletContext) {
264                 return !isFullAccessOnly();
265         }
266
267         /**
268          * Exception that can be thrown to signal that a subclassed {@link Page}
269          * wants to redirect the user during the
270          * {@link FreenetTemplatePage#processTemplate(FreenetRequest, TemplateContext)}
271          * method call.
272          *
273          * @author <a href="mailto:bombe@pterodactylus.net">David â€˜Bombe’ Roden</a>
274          */
275         public static class RedirectException extends Exception {
276
277                 /** The target to redirect to. */
278                 private final String target;
279
280                 /**
281                  * Creates a new redirect exception.
282                  *
283                  * @param target
284                  *            The target of the redirect
285                  */
286                 public RedirectException(String target) {
287                         this.target = target;
288                 }
289
290                 /**
291                  * Returns the target to redirect to.
292                  *
293                  * @return The target to redirect to
294                  */
295                 public String getTarget() {
296                         return target;
297                 }
298
299         }
300
301 }