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