source/mir/servlet/ServletModule.java

   1 /*\r
   2  * Copyright (C) 2001, 2002  The Mir-coders group\r
   3  *\r
   4  * This file is part of Mir.\r
   5  *\r
   6  * Mir is free software; you can redistribute it and/or modify\r
   7  * it under the terms of the GNU General Public License as published by\r
   8  * the Free Software Foundation; either version 2 of the License, or\r
   9  * (at your option) any later version.\r
  10  *\r
  11  * Mir is distributed in the hope that it will be useful,\r
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  14  * GNU General Public License for more details.\r
  15  *\r
  16  * You should have received a copy of the GNU General Public License\r
  17  * along with Mir; if not, write to the Free Software\r
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA\r
  19  *\r
  20  * In addition, as a special exception, The Mir-coders gives permission to link\r
  21  * the code of this program with the com.oreilly.servlet library, any library\r
  22  * licensed under the Apache Software License, The Sun (tm) Java Advanced\r
  23  * Imaging library (JAI), The Sun JIMI library (or with modified versions of\r
  24  * the above that use the same license as the above), and distribute linked\r
  25  * combinations including the two.  You must obey the GNU General Public\r
  26  * License in all respects for all of the code used other than the above\r
  27  * mentioned libraries.  If you modify this file, you may extend this exception\r
  28  * to your version of the file, but you are not obligated to do so.  If you do\r
  29  * not wish to do so, delete this exception statement from your version.\r
  30  */\r
  31 \r
  32 package mir.servlet;\r
  33 \r
  34 import java.io.IOException;\r
  35 import java.io.PrintWriter;\r
  36 import java.util.HashMap;\r
  37 import java.util.List;\r
  38 import java.util.Locale;\r
  39 import java.util.Map;\r
  40 \r
  41 import javax.servlet.http.HttpServletRequest;\r
  42 import javax.servlet.http.HttpServletResponse;\r
  43 import javax.servlet.http.HttpSession;\r
  44 \r
  45 import mir.config.MirPropertiesConfiguration;\r
  46 import mir.config.MirPropertiesConfiguration.PropertiesConfigExc;\r
  47 import mir.entity.EntityList;\r
  48 import mir.log.LoggerWrapper;\r
  49 import mir.misc.HTMLParseException;\r
  50 import mir.misc.HTMLTemplateProcessor;\r
  51 import mir.misc.LineFilterWriter;\r
  52 import mir.module.AbstractModule;\r
  53 import mir.module.ModuleException;\r
  54 import mir.storage.StorageObject;\r
  55 import mir.util.HTTPRequestParser;\r
  56 import freemarker.template.SimpleHash;\r
  57 import freemarker.template.TemplateModelRoot;\r
  58 \r
  59 \r
  60 \r
  61 \r
  62 /**\r
  63  * Abstract class ServletModule provides the base functionality for servlets.\r
  64  * Deriving a class from ServletModule enables class to insert/edit/update/delete\r
  65  * and list Entity from a Database via mainModule.\r
  66  *\r
  67  *\r
  68  *  Abstrakte Klasse ServletModule stellt die Basisfunktionalitaet der\r
  69  *  abgeleiteten ServletModule zur Verf?gung.\r
  70  *\r
  71  * @version 28.6.1999\r
  72  * @author RK\r
  73  */\r
  74 \r
  75 public abstract class ServletModule {\r
  76 \r
  77   public String defaultAction;\r
  78   protected LoggerWrapper logger;\r
  79   protected MirPropertiesConfiguration configuration;\r
  80   protected AbstractModule mainModule;\r
  81   protected String templateListString;\r
  82   protected String templateObjektString;\r
  83   protected String templateConfirmString;\r
  84 \r
  85 \r
  86   public ServletModule(){\r
  87     try {\r
  88       configuration = MirPropertiesConfiguration.instance();\r
  89     }\r
  90     catch (PropertiesConfigExc e) {\r
  91       throw new RuntimeException("Can't get configuration: " + e.getMessage());\r
  92     }\r
  93   }\r
  94 \r
  95 \r
  96   /**\r
  97    * Singelton - Methode muss in den abgeleiteten Klassen ueberschrieben werden.\r
  98    * @return ServletModule\r
  99    */\r
 100   public static ServletModule getInstance() {\r
 101     return null;\r
 102   }\r
 103 \r
 104   /**\r
 105    * get the module name to be used for generic operations like delete.\r
 106    */\r
 107   protected String getOperationModuleName() {\r
 108     return getClass().getName().substring((new String("mircoders.servlet.ServletModule")).length());\r
 109   }\r
 110 \r
 111   /**\r
 112    * get the session binded language\r
 113    */\r
 114   public String getLanguage(HttpServletRequest req) {\r
 115     HttpSession session = req.getSession(false);\r
 116     String language = (String) session.getAttribute("Language");\r
 117     if (language == null) {\r
 118       language = configuration.getString("StandardLanguage");\r
 119     }\r
 120     return language;\r
 121   }\r
 122 \r
 123   /**\r
 124    * get the locale either from the session or the accept-language header ot the request\r
 125    * this supersedes getLanguage for the new i18n\r
 126    */\r
 127   public Locale getLocale(HttpServletRequest req) {\r
 128     Locale loc = null;\r
 129     HttpSession session = req.getSession(false);\r
 130     if (session != null) {\r
 131       // session can be null in case of logout\r
 132       loc = (Locale) session.getAttribute("Locale");\r
 133     }\r
 134     // if there is nothing in the session get it fron the accept-language\r
 135     if (loc == null) {\r
 136       loc = req.getLocale();\r
 137     }\r
 138     return loc;\r
 139   }\r
 140 \r
 141   public void redirect(HttpServletResponse aResponse, String aQuery) throws ServletModuleExc, ServletModuleFailure {\r
 142     try {\r
 143       aResponse.sendRedirect(MirPropertiesConfiguration.instance().getString("RootUri") + "/Mir?"+aQuery);\r
 144     }\r
 145     catch (Throwable t) {\r
 146       throw new ServletModuleFailure("ServletModule.redirect: " +t.getMessage(), t);\r
 147     }\r
 148   }\r
 149 \r
 150   /**\r
 151    *  list(req,res) - generische Listmethode. Wennn die Funktionalitaet\r
 152    *  nicht reicht, muss sie in der abgeleiteten ServletModule-Klasse\r
 153    *  ueberschreiben werden.\r
 154    *\r
 155    * @param req Http-Request, das vom Dispatcher durchgereicht wird\r
 156    * @param res Http-Response, die vom Dispatcher durchgereicht wird\r
 157    */\r
 158   public void list(HttpServletRequest req, HttpServletResponse res)\r
 159       throws ServletModuleExc, ServletModuleUserExc, ServletModuleFailure {\r
 160     try {\r
 161       EntityList theList;\r
 162       String offsetParam = req.getParameter("offset");\r
 163       int offset = 0;\r
 164       PrintWriter out = res.getWriter();\r
 165 \r
 166       // hier offsetcode bearbeiten\r
 167       if (offsetParam != null && !offsetParam.equals("")) {\r
 168         offset = Integer.parseInt(offsetParam);\r
 169       }\r
 170       if (req.getParameter("next") != null) {\r
 171         offset = Integer.parseInt(req.getParameter("nextoffset"));\r
 172       }\r
 173       else {\r
 174         if (req.getParameter("prev") != null) {\r
 175           offset = Integer.parseInt(req.getParameter("prevoffset"));\r
 176         }\r
 177       }\r
 178       theList = mainModule.getByWhereClause(null, offset);\r
 179 \r
 180       HTMLTemplateProcessor.process(res, templateListString, theList, out, getLocale(req));\r
 181     }\r
 182     catch (Throwable e) {\r
 183       throw new ServletModuleFailure(e);\r
 184     }\r
 185   }\r
 186 \r
 187   /**\r
 188    *  add(req,res) - generische Addmethode. Wennn die Funktionalitaet\r
 189    *  nicht reicht, muss sie in der abgeleiteten ServletModule-Klasse\r
 190    *  ueberschreiben werden.\r
 191    * @param req Http-Request, das vom Dispatcher durchgereicht wird\r
 192    * @param res Http-Response, die vom Dispatcher durchgereicht wird\r
 193    */\r
 194   public void add(HttpServletRequest req, HttpServletResponse res)\r
 195       throws ServletModuleExc, ServletModuleUserExc, ServletModuleFailure  {\r
 196 \r
 197     try {\r
 198       SimpleHash mergeData = new SimpleHash();\r
 199       mergeData.put("new", "1");\r
 200       deliver(req, res, mergeData, templateObjektString);\r
 201     }\r
 202     catch (Throwable e) {\r
 203       throw new ServletModuleFailure(e);\r
 204     }\r
 205   }\r
 206 \r
 207   /**\r
 208    *  insert(req,res) - generische Insertmethode, folgt auf add.\r
 209    *  Wennn die Funktionalitaet\r
 210    *  nicht reicht, muss sie in der abgeleiteten ServletModule-Klasse\r
 211    *  ueberschreiben werden.\r
 212    *\r
 213    * @param req Http-Request, das vom Dispatcher durchgereicht wird\r
 214    * @param res Http-Response, die vom Dispatcher durchgereicht wird\r
 215    */\r
 216   public void insert(HttpServletRequest req, HttpServletResponse res)\r
 217       throws ServletModuleExc, ServletModuleUserExc, ServletModuleFailure  {\r
 218     try {\r
 219       Map withValues = getIntersectingValues(req, mainModule.getStorageObject());\r
 220       logger.debug("--trying to add...");\r
 221       String id = mainModule.add(withValues);\r
 222       logger.debug("--trying to deliver..." + id);\r
 223       list(req, res);\r
 224     }\r
 225     catch (Throwable e) {\r
 226       throw new ServletModuleFailure(e);\r
 227     }\r
 228   }\r
 229 \r
 230   /**\r
 231    *  delete(req,res) - generic delete method. Can be overridden in subclasses.\r
 232    *\r
 233    */\r
 234 \r
 235   public void delete(HttpServletRequest req, HttpServletResponse res)\r
 236       throws ServletModuleExc, ServletModuleUserExc, ServletModuleFailure  {\r
 237     try {\r
 238       String idParam = req.getParameter("id");\r
 239 \r
 240       if (idParam == null)\r
 241         throw new ServletModuleExc("Invalid call to delete: no id supplied");\r
 242 \r
 243       String confirmParam = req.getParameter("confirm");\r
 244       String cancelParam = req.getParameter("cancel");\r
 245       if (confirmParam == null && cancelParam == null) {\r
 246         SimpleHash mergeData = new SimpleHash();\r
 247 \r
 248         mergeData.put("module", getOperationModuleName());\r
 249         mergeData.put("infoString", getOperationModuleName() + ": " + idParam);\r
 250         mergeData.put("id", idParam);\r
 251         mergeData.put("where", req.getParameter("where"));\r
 252         mergeData.put("order", req.getParameter("order"));\r
 253         mergeData.put("offset", req.getParameter("offset"));\r
 254         // this stuff is to be compatible with the other more advanced\r
 255         // search method used for media and comments\r
 256         mergeData.put("query_media_folder", req.getParameter("query_media_folder"));\r
 257         mergeData.put("query_is_published", req.getParameter("query_is_published"));\r
 258         mergeData.put("query_text", req.getParameter("query_text"));\r
 259         mergeData.put("query_field", req.getParameter("query_field"));\r
 260 \r
 261         deliver(req, res, mergeData, templateConfirmString);\r
 262       }\r
 263       else {\r
 264         if (confirmParam != null && !confirmParam.equals("")) {\r
 265           //theLog.printInfo("delete confirmed!");\r
 266           mainModule.deleteById(idParam);\r
 267           list(req, res); // back to list\r
 268         }\r
 269         else {\r
 270           if (req.getParameter("where") != null)\r
 271             list(req, res);\r
 272           else\r
 273             edit(req, res);\r
 274         }\r
 275       }\r
 276     }\r
 277     catch (Throwable e) {\r
 278       throw new ServletModuleFailure(e);\r
 279     }\r
 280   }\r
 281 \r
 282   /**\r
 283    *  edit(req,res) - generische Editmethode. Wennn die Funktionalitaet\r
 284    *  nicht reicht, muss sie in der abgeleiteten ServletModule-Klasse\r
 285    *  ueberschreiben werden.\r
 286    *\r
 287    * @param req Http-Request, das vom Dispatcher durchgereicht wird\r
 288    * @param res Http-Response, die vom Dispatcher durchgereicht wird\r
 289    */\r
 290   public void edit(HttpServletRequest req, HttpServletResponse res)\r
 291       throws ServletModuleExc, ServletModuleUserExc, ServletModuleFailure  {\r
 292     edit(req, res, req.getParameter("id"));\r
 293   }\r
 294 \r
 295   /**\r
 296    *  edit(req,res) - generische Editmethode. Wennn die Funktionalitaet\r
 297    *  nicht reicht, muss sie in der abgeleiteten ServletModule-Klasse\r
 298    *  ueberschreiben werden.\r
 299    *\r
 300    * @param req Http-Request, das vom Dispatcher durchgereicht wird\r
 301    * @param res Http-Response, die vom Dispatcher durchgereicht wird\r
 302    */\r
 303   public void edit(HttpServletRequest aRequest, HttpServletResponse aResponse, String anIdentifier)\r
 304       throws ServletModuleExc, ServletModuleUserExc, ServletModuleFailure  {\r
 305     try {\r
 306       deliver(aRequest, aResponse, mainModule.getById(anIdentifier), templateObjektString);\r
 307     }\r
 308     catch (Throwable e) {\r
 309       throw new ServletModuleFailure(e);\r
 310     }\r
 311   }\r
 312 \r
 313   /**\r
 314    *  update(req,res) - generische Updatemethode. Wennn die Funktionalitaet\r
 315    *  nicht reicht, muss sie in der abgeleiteten ServletModule-Klasse\r
 316    *  ueberschreiben werden.\r
 317    *\r
 318    * @param req Http-Request, das vom Dispatcher durchgereicht wird\r
 319    * @param res Http-Response, die vom Dispatcher durchgereicht wird\r
 320    */\r
 321 \r
 322   public void update(HttpServletRequest req, HttpServletResponse res)\r
 323       throws ServletModuleExc, ServletModuleUserExc, ServletModuleFailure  {\r
 324     try {\r
 325       String idParam = req.getParameter("id");\r
 326       Map withValues = getIntersectingValues(req, mainModule.getStorageObject());\r
 327 \r
 328       String id = mainModule.set(withValues);\r
 329       String whereParam = req.getParameter("where");\r
 330       String orderParam = req.getParameter("order");\r
 331 \r
 332       if ((whereParam != null && !whereParam.equals("")) || (orderParam != null && !orderParam.equals(""))) {\r
 333         list(req, res);\r
 334       }\r
 335       else {\r
 336         edit(req, res);\r
 337       }\r
 338     }\r
 339     catch (Throwable e) {\r
 340       throw new ServletModuleFailure(e);\r
 341     }\r
 342   }\r
 343 \r
 344   /**\r
 345    * deliver liefert das Template mit dem Filenamen templateFilename\r
 346    * an den HttpServletResponse res aus, nachdem es mit den Daten aus\r
 347    * TemplateModelRoot rtm gemischt wurde\r
 348    *\r
 349    * @param res Http-Response, die vom Dispatcher durchgereicht wird\r
 350    * @param rtm beinahalten das freemarker.template.TempalteModelRoot mit den\r
 351    *   Daten, die ins Template gemerged werden sollen.\r
 352    * @param tmpl Name des Templates\r
 353    * @exception ServletModuleException\r
 354    */\r
 355   public void deliver(HttpServletRequest req, HttpServletResponse res, TemplateModelRoot rtm,\r
 356          TemplateModelRoot popups, String templateFilename) throws ServletModuleFailure  {\r
 357     if (rtm == null)\r
 358       rtm = new SimpleHash();\r
 359 \r
 360     try {\r
 361       PrintWriter out = res.getWriter();\r
 362       HTMLTemplateProcessor.process(res, templateFilename, rtm, popups, out, getLocale(req));\r
 363 \r
 364       // we default to admin bundles here, which is not exactly beautiful...\r
 365       // but this whole producer stuff is going to be rewritten soon.\r
 366       // ServletModuleOpenIndy overwrites deliver() to use open bundles\r
 367       // (br1)\r
 368       out.close();\r
 369     }\r
 370     catch (Throwable e) {\r
 371       throw new ServletModuleFailure(e);\r
 372     }\r
 373   }\r
 374 \r
 375 \r
 376   /**\r
 377    * deliver liefert das Template mit dem Filenamen templateFilename\r
 378    * an den HttpServletResponse res aus, nachdem es mit den Daten aus\r
 379    * TemplateModelRoot rtm gemischt wurde\r
 380    *\r
 381    * @param res Http-Response, die vom Dispatcher durchgereicht wird\r
 382    * @param rtm beinahalten das freemarker.template.TempalteModelRoot mit den\r
 383    *   Daten, die ins Template gemerged werden sollen.\r
 384    * @param tmpl Name des Templates\r
 385    * @exception ServletModuleException\r
 386    */\r
 387   public void deliver(HttpServletRequest req, HttpServletResponse res,\r
 388         TemplateModelRoot rtm, String templateFilename) throws ServletModuleFailure {\r
 389     deliver(req, res, rtm, null, templateFilename);\r
 390   }\r
 391 \r
 392   /**\r
 393    * deliver liefert das Template mit dem Filenamen templateFilename\r
 394    * an den HttpServletResponse res aus, nachdem es mit den Daten aus\r
 395    * TemplateModelRoot rtm gemischt wurde\r
 396    *\r
 397    * @param res Http-Response, die vom Dispatcher durchgereicht wird\r
 398    * @param rtm beinahalten das freemarker.template.TempalteModelRoot mit den\r
 399    *   Daten, die ins Template gemerged werden sollen.\r
 400    * @param tmpl Name des Templates\r
 401    * @exception ServletModuleException\r
 402    */\r
 403   public void deliver_compressed(HttpServletRequest req, HttpServletResponse res,\r
 404                                  TemplateModelRoot rtm, String templateFilename)\r
 405       throws ServletModuleFailure {\r
 406     if (rtm == null) rtm = new SimpleHash();\r
 407     try {\r
 408       PrintWriter out = new LineFilterWriter(res.getWriter());\r
 409       //PrintWriter out =  res.getWriter();\r
 410       HTMLTemplateProcessor.process(res, templateFilename, rtm, out, getLocale(req));\r
 411       out.close();\r
 412     }\r
 413     catch (Throwable e) {\r
 414       throw new ServletModuleFailure(e);\r
 415     }\r
 416   }\r
 417 \r
 418   /**\r
 419    * deliver liefert das Template mit dem Filenamen templateFilename\r
 420    * an den HttpServletResponse res aus, nachdem es mit den Daten aus\r
 421    * TemplateModelRoot rtm gemischt wurde\r
 422    *\r
 423    * @param out ist der OutputStream, in den die gergten Daten geschickt werden sollen.\r
 424    * @param rtm beinahalten das freemarker.template.TempalteModelRoot mit den\r
 425    *   Daten, die ins Template gemerged werden sollen.\r
 426    * @param tmpl Name des Templates\r
 427    * @exception ServletModuleException\r
 428    */\r
 429   private void deliver(HttpServletResponse res, HttpServletRequest req, PrintWriter out,\r
 430                        TemplateModelRoot rtm, String templateFilename)\r
 431       throws ServletModuleFailure {\r
 432     try {\r
 433       HTMLTemplateProcessor.process(res, templateFilename, rtm, out,\r
 434                                     getLocale(req));\r
 435     }\r
 436     catch (Throwable e) {\r
 437       throw new ServletModuleFailure(e);\r
 438     }\r
 439   }\r
 440 \r
 441   /**\r
 442    *  Wenn die abgeleitete Klasse diese Methode ueberschreibt und einen String mit einem\r
 443    *  Methodennamen zurueckliefert, dann wird diese Methode bei fehlender Angabe des\r
 444    *  doParameters ausgefuehrt.\r
 445    *\r
 446    * @return Name der Default-Action\r
 447    */\r
 448   public String defaultAction() {\r
 449     return defaultAction;\r
 450   }\r
 451 \r
 452   /**\r
 453    * Gets the fields from a httprequest and matches them with the metadata from\r
 454    * the storage object. Returns the keys that match, with their values.\r
 455    *\r
 456    * @return Map with the values\r
 457    */\r
 458   public Map getIntersectingValues(HttpServletRequest req, StorageObject theStorage)\r
 459       throws ServletModuleExc, ServletModuleFailure {\r
 460 \r
 461     try {\r
 462       HTTPRequestParser parser;\r
 463       List theFieldList;\r
 464 \r
 465       logger.debug("using charset: " + req.getParameter("charset"));\r
 466       logger.debug("using method: " + req.getParameter("do"));\r
 467       if (req.getParameter("charset") != null) {\r
 468         parser = new HTTPRequestParser(req, req.getParameter("charset"));\r
 469         logger.debug("using charset: " + req.getParameter("charset"));\r
 470         logger.debug("original charset: " + req.getCharacterEncoding());\r
 471       }\r
 472       else {\r
 473         parser = new HTTPRequestParser(req);\r
 474       }\r
 475 \r
 476       theFieldList = theStorage.getFields();\r
 477 \r
 478       Map withValues = new HashMap();\r
 479       String aField, aValue;\r
 480 \r
 481       for (int i = 0; i < theFieldList.size(); i++) {\r
 482         aField = (String) theFieldList.get(i);\r
 483 \r
 484         logger.debug("field " + aField + " = " + parser.getParameter(aField));\r
 485 \r
 486         aValue = parser.getParameter(aField);\r
 487         if (aValue != null)\r
 488           withValues.put(aField, aValue);\r
 489       }\r
 490       return withValues;\r
 491     }\r
 492     catch (Throwable e) {\r
 493       e.printStackTrace(logger.asPrintWriter(LoggerWrapper.DEBUG_MESSAGE));\r
 494 \r
 495       throw new ServletModuleFailure( "ServletModule.getIntersectingValues: " + e.getMessage(), e);\r
 496     }\r
 497   }\r
 498 \r
 499 }\r