src/club/wpia/gigi/pages/Page.java

   1 package club.wpia.gigi.pages;
   2
   3 import java.io.IOException;
   4 import java.net.URL;
   5 import java.util.Enumeration;
   6 import java.util.HashMap;
   7 import java.util.Locale;
   8 import java.util.Map;
   9
  10 import javax.servlet.ServletRequest;
  11 import javax.servlet.http.HttpServletRequest;
  12 import javax.servlet.http.HttpServletResponse;
  13 import javax.servlet.http.HttpSession;
  14
  15 import club.wpia.gigi.Gigi;
  16 import club.wpia.gigi.PermissionCheckable;
  17 import club.wpia.gigi.dbObjects.User;
  18 import club.wpia.gigi.localisation.Language;
  19 import club.wpia.gigi.output.template.Template;
  20 import club.wpia.gigi.util.AuthorizationContext;
  21
  22 /**
  23  * This class encapsulates a sub page of Gigi. A template residing nearby this
  24  * class with name &lt;className&gt;.templ will be loaded automatically.
  25  */
  26 public abstract class Page implements PermissionCheckable {
  27
  28     private String title;
  29
  30     private Template defaultTemplate;
  31
  32     public Page(String title) {
  33         this.title = title;
  34         URL resource = getClass().getResource(getClass().getSimpleName() + ".templ");
  35         if (resource != null) {
  36             defaultTemplate = new Template(resource);
  37         }
  38     }
  39
  40     /**
  41      * Retrieves the default template (&lt;className&gt;.templ) which has
  42      * already been loaded.
  43      *
  44      * @return the default template.
  45      */
  46     public Template getDefaultTemplate() {
  47         return defaultTemplate;
  48     }
  49
  50     /**
  51      * This method can be overridden to execute code and do stuff before the
  52      * default template is applied.
  53      *
  54      * @param req
  55      *            the request to handle.
  56      * @param resp
  57      *            the response to write to
  58      * @return true, if the request is consumed and the default template should
  59      *         not be applied.
  60      * @throws IOException
  61      *             if output goes wrong.
  62      */
  63     public boolean beforeTemplate(HttpServletRequest req, HttpServletResponse resp) throws IOException {
  64         if (req.getMethod().equals("POST")) {
  65             return beforePost(req, resp);
  66         }
  67         return false;
  68     }
  69
  70     /**
  71      * This method can be overridden to execute code and do stuff before the
  72      * default template is applied when the request is a post request and the
  73      * default implementation of
  74      * {@link #beforeTemplate(HttpServletRequest, HttpServletResponse)} is
  75      * called.
  76      *
  77      * @param req
  78      *            the request to handle.
  79      * @param resp
  80      *            the response to write to
  81      * @return true, if the request is consumed and the default template should
  82      *         not be applied.
  83      * @throws IOException
  84      *             if output goes wrong.
  85      */
  86     public boolean beforePost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
  87         return false;
  88     }
  89
  90     /**
  91      * This method is called to generate the content inside the default
  92      * template.
  93      *
  94      * @param req
  95      *            the request to handle.
  96      * @param resp
  97      *            the response to write to
  98      * @throws IOException
  99      *             if output goes wrong.
 100      */
 101     public abstract void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException;
 102
 103     /**
 104      * Same as {@link #doGet(HttpServletRequest, HttpServletResponse)} but for
 105      * POST requests. By default they are redirected to
 106      * {@link #doGet(HttpServletRequest, HttpServletResponse)};
 107      *
 108      * @param req
 109      *            the request to handle.
 110      * @param resp
 111      *            the response to write to
 112      * @throws IOException
 113      *             if output goes wrong.
 114      */
 115     public void doPost(HttpServletRequest req, HttpServletResponse resp) throws IOException {
 116         doGet(req, resp);
 117     }
 118
 119     /**
 120      * Returns true, if this page requires login. Default is <code>true</code>
 121      *
 122      * @return if the page needs login.
 123      */
 124     public boolean needsLogin() {
 125         return true;
 126     }
 127
 128     public String getTitle() {
 129         return title;
 130     }
 131
 132     public static Language getLanguage(ServletRequest req) {
 133         HttpSession session = ((HttpServletRequest) req).getSession();
 134         synchronized (session) {
 135
 136             Locale sessval = (Locale) session.getAttribute(Language.SESSION_ATTRIB_NAME);
 137             if (sessval != null) {
 138                 Language l = Language.getInstance(sessval);
 139                 if (l != null) {
 140                     return l;
 141                 }
 142             }
 143             Enumeration<Locale> langs = req.getLocales();
 144             while (langs.hasMoreElements()) {
 145                 Locale c = langs.nextElement();
 146                 Language l = Language.getInstance(c);
 147                 if (l != null) {
 148                     session.setAttribute(Language.SESSION_ATTRIB_NAME, l.getLocale());
 149                     return l;
 150                 }
 151             }
 152             session.setAttribute(Language.SESSION_ATTRIB_NAME, Locale.ENGLISH);
 153             return Language.getInstance(Locale.ENGLISH);
 154         }
 155     }
 156
 157     public static String translate(ServletRequest req, String string) {
 158         Language l = getLanguage(req);
 159         return l.getTranslation(string);
 160     }
 161
 162     public static User getUser(HttpServletRequest req) {
 163         return LoginPage.getUser(req);
 164     }
 165
 166     @Override
 167     public boolean isPermitted(AuthorizationContext ac) {
 168         return !needsLogin() || ac != null;
 169     }
 170
 171     /**
 172      * Derive a default variable map for template processing.
 173      *
 174      * @param req
 175      *            the HTTP-request to derive the map from
 176      * @return the map
 177      */
 178     protected Map<String, Object> getDefaultVars(HttpServletRequest req) {
 179         HashMap<String, Object> vars = new HashMap<String, Object>();
 180         vars.put(Gigi.LINK_HOST, req.getAttribute(Gigi.LINK_HOST));
 181         return vars;
 182     }
 183
 184 }