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