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.List;\r
  37 import java.util.HashMap;\r
  38 import java.util.Locale;\r
  39 \r
  40 import javax.servlet.http.HttpServletRequest;\r
  41 import javax.servlet.http.HttpServletResponse;\r
  42 import javax.servlet.http.HttpSession;\r
  43 \r
  44 import freemarker.template.SimpleHash;\r
  45 import freemarker.template.TemplateModelRoot;\r
  46 \r
  47 import mir.config.MirPropertiesConfiguration;\r
  48 import mir.config.MirPropertiesConfiguration.PropertiesConfigExc;\r
  49 import mir.entity.EntityList;\r
  50 import mir.log.LoggerWrapper;\r
  51 import mir.misc.HTMLParseException;\r
  52 import mir.misc.HTMLTemplateProcessor;\r
  53 import mir.misc.LineFilterWriter;\r
  54 import mir.module.AbstractModule;\r
  55 import mir.module.ModuleException;\r
  56 import mir.storage.StorageObject;\r
  57 import mir.util.*;\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 ServletModuleException {\r
 142     try {\r
 143       aResponse.sendRedirect(MirPropertiesConfiguration.instance().getString("RootUri") + "/Mir?"+aQuery);\r
 144     }\r
 145     catch (Throwable t) {\r
 146       throw new ServletModuleException(t.getMessage());\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 ServletModuleException {\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 (Exception e) {\r
 183       throw new ServletModuleException(e.getMessage());\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 ServletModuleException {\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 (Exception e) {\r
 203       throw new ServletModuleException(e.getMessage());\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 ServletModuleException, ServletModuleUserException {\r
 218     try {\r
 219       HashMap 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 (Exception e) {\r
 226       throw new ServletModuleException(e.getMessage());\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) throws ServletModuleException {\r
 236     try {\r
 237       String idParam = req.getParameter("id");\r
 238 \r
 239       if (idParam == null)\r
 240         throw new ServletModuleException("Invalid call to delete: no id supplied");\r
 241 \r
 242       String confirmParam = req.getParameter("confirm");\r
 243       String cancelParam = req.getParameter("cancel");\r
 244       if (confirmParam == null && cancelParam == null) {\r
 245         SimpleHash mergeData = new SimpleHash();\r
 246 \r
 247         mergeData.put("module", getOperationModuleName());\r
 248         mergeData.put("infoString", getOperationModuleName() + ": " + idParam);\r
 249         mergeData.put("id", idParam);\r
 250         mergeData.put("where", req.getParameter("where"));\r
 251         mergeData.put("order", req.getParameter("order"));\r
 252         mergeData.put("offset", req.getParameter("offset"));\r
 253         // this stuff is to be compatible with the other more advanced\r
 254         // search method used for media and comments\r
 255         mergeData.put("query_media_folder", req.getParameter("query_media_folder"));\r
 256         mergeData.put("query_is_published", req.getParameter("query_is_published"));\r
 257         mergeData.put("query_text", req.getParameter("query_text"));\r
 258         mergeData.put("query_field", req.getParameter("query_field"));\r
 259 \r
 260         deliver(req, res, mergeData, templateConfirmString);\r
 261       }\r
 262       else {\r
 263         if (confirmParam != null && !confirmParam.equals("")) {\r
 264           //theLog.printInfo("delete confirmed!");\r
 265           mainModule.deleteById(idParam);\r
 266           list(req, res); // back to list\r
 267         }\r
 268         else {\r
 269           if (req.getParameter("where") != null)\r
 270             list(req, res);\r
 271           else\r
 272             edit(req, res);\r
 273         }\r
 274       }\r
 275     }\r
 276     catch (Exception e) {\r
 277       throw new ServletModuleException(e.getMessage());\r
 278     }\r
 279   }\r
 280 \r
 281   /**\r
 282    *  edit(req,res) - generische Editmethode. Wennn die Funktionalitaet\r
 283    *  nicht reicht, muss sie in der abgeleiteten ServletModule-Klasse\r
 284    *  ueberschreiben werden.\r
 285    *\r
 286    * @param req Http-Request, das vom Dispatcher durchgereicht wird\r
 287    * @param res Http-Response, die vom Dispatcher durchgereicht wird\r
 288    */\r
 289   public void edit(HttpServletRequest req, HttpServletResponse res)\r
 290       throws ServletModuleException {\r
 291     try {\r
 292       String idParam = req.getParameter("id");\r
 293       deliver(req, res, mainModule.getById(idParam), templateObjektString);\r
 294     }\r
 295     catch (ModuleException e) {\r
 296       throw new ServletModuleException(e.getMessage());\r
 297     }\r
 298   }\r
 299 \r
 300   /**\r
 301    *  update(req,res) - generische Updatemethode. Wennn die Funktionalitaet\r
 302    *  nicht reicht, muss sie in der abgeleiteten ServletModule-Klasse\r
 303    *  ueberschreiben werden.\r
 304    *\r
 305    * @param req Http-Request, das vom Dispatcher durchgereicht wird\r
 306    * @param res Http-Response, die vom Dispatcher durchgereicht wird\r
 307    */\r
 308 \r
 309   public void update(HttpServletRequest req, HttpServletResponse res)\r
 310       throws ServletModuleException {\r
 311     try {\r
 312       String idParam = req.getParameter("id");\r
 313       HashMap withValues = getIntersectingValues(req, mainModule.getStorageObject());\r
 314 \r
 315       String id = mainModule.set(withValues);\r
 316       String whereParam = req.getParameter("where");\r
 317       String orderParam = req.getParameter("order");\r
 318 \r
 319       if ((whereParam != null && !whereParam.equals("")) || (orderParam != null && !orderParam.equals(""))) {\r
 320         list(req, res);\r
 321       }\r
 322       else {\r
 323         edit(req, res);\r
 324       }\r
 325     }\r
 326     catch (Exception e) {\r
 327       throw new ServletModuleException(e.getMessage());\r
 328     }\r
 329   }\r
 330 \r
 331   /**\r
 332    * deliver liefert das Template mit dem Filenamen templateFilename\r
 333    * an den HttpServletResponse res aus, nachdem es mit den Daten aus\r
 334    * TemplateModelRoot rtm gemischt wurde\r
 335    *\r
 336    * @param res Http-Response, die vom Dispatcher durchgereicht wird\r
 337    * @param rtm beinahalten das freemarker.template.TempalteModelRoot mit den\r
 338    *   Daten, die ins Template gemerged werden sollen.\r
 339    * @param tmpl Name des Templates\r
 340    * @exception ServletModuleException\r
 341    */\r
 342   public void deliver(HttpServletRequest req, HttpServletResponse res,\r
 343                       TemplateModelRoot rtm, TemplateModelRoot popups,\r
 344                       String templateFilename)\r
 345       throws ServletModuleException {\r
 346     if (rtm == null) rtm = new SimpleHash();\r
 347     try {\r
 348       PrintWriter out = res.getWriter();\r
 349       HTMLTemplateProcessor.process(res, templateFilename, rtm, popups, out, getLocale(req));\r
 350 \r
 351       // we default to admin bundles here, which is not exactly beautiful...\r
 352       // but this whole producer stuff is going to be rewritten soon.\r
 353       // ServletModuleOpenIndy overwrites deliver() to use open bundles\r
 354       // (br1)\r
 355       out.close();\r
 356     }\r
 357     catch (HTMLParseException e) {\r
 358       throw new ServletModuleException(e.getMessage());\r
 359     } catch (IOException e) {\r
 360       throw new ServletModuleException(e.getMessage());\r
 361     }\r
 362   }\r
 363 \r
 364 \r
 365   /**\r
 366    * deliver liefert das Template mit dem Filenamen templateFilename\r
 367    * an den HttpServletResponse res aus, nachdem es mit den Daten aus\r
 368    * TemplateModelRoot rtm gemischt wurde\r
 369    *\r
 370    * @param res Http-Response, die vom Dispatcher durchgereicht wird\r
 371    * @param rtm beinahalten das freemarker.template.TempalteModelRoot mit den\r
 372    *   Daten, die ins Template gemerged werden sollen.\r
 373    * @param tmpl Name des Templates\r
 374    * @exception ServletModuleException\r
 375    */\r
 376   public void deliver(HttpServletRequest req, HttpServletResponse res,\r
 377                       TemplateModelRoot rtm, String templateFilename)\r
 378       throws ServletModuleException {\r
 379     deliver(req, res, rtm, null, templateFilename);\r
 380   }\r
 381 \r
 382   /**\r
 383    * deliver liefert das Template mit dem Filenamen templateFilename\r
 384    * an den HttpServletResponse res aus, nachdem es mit den Daten aus\r
 385    * TemplateModelRoot rtm gemischt wurde\r
 386    *\r
 387    * @param res Http-Response, die vom Dispatcher durchgereicht wird\r
 388    * @param rtm beinahalten das freemarker.template.TempalteModelRoot mit den\r
 389    *   Daten, die ins Template gemerged werden sollen.\r
 390    * @param tmpl Name des Templates\r
 391    * @exception ServletModuleException\r
 392    */\r
 393   public void deliver_compressed(HttpServletRequest req, HttpServletResponse res,\r
 394                                  TemplateModelRoot rtm, String templateFilename)\r
 395       throws ServletModuleException {\r
 396     if (rtm == null) rtm = new SimpleHash();\r
 397     try {\r
 398       PrintWriter out = new LineFilterWriter(res.getWriter());\r
 399       //PrintWriter out =  res.getWriter();\r
 400       HTMLTemplateProcessor.process(res, templateFilename, rtm, out, getLocale(req));\r
 401       out.close();\r
 402     }\r
 403     catch (HTMLParseException e) {\r
 404       throw new ServletModuleException(e.getMessage());\r
 405     }\r
 406     catch (IOException e) {\r
 407       throw new ServletModuleException(e.getMessage());\r
 408     }\r
 409   }\r
 410 \r
 411   /**\r
 412    * deliver liefert das Template mit dem Filenamen templateFilename\r
 413    * an den HttpServletResponse res aus, nachdem es mit den Daten aus\r
 414    * TemplateModelRoot rtm gemischt wurde\r
 415    *\r
 416    * @param out ist der OutputStream, in den die gergten Daten geschickt werden sollen.\r
 417    * @param rtm beinahalten das freemarker.template.TempalteModelRoot mit den\r
 418    *   Daten, die ins Template gemerged werden sollen.\r
 419    * @param tmpl Name des Templates\r
 420    * @exception ServletModuleException\r
 421    */\r
 422   private void deliver(HttpServletResponse res, HttpServletRequest req, PrintWriter out,\r
 423                        TemplateModelRoot rtm, String templateFilename)\r
 424       throws HTMLParseException {\r
 425     HTMLTemplateProcessor.process(res, templateFilename, rtm, out, getLocale(req));\r
 426   }\r
 427 \r
 428   /**\r
 429    *  Wenn die abgeleitete Klasse diese Methode ueberschreibt und einen String mit einem\r
 430    *  Methodennamen zurueckliefert, dann wird diese Methode bei fehlender Angabe des\r
 431    *  doParameters ausgefuehrt.\r
 432    *\r
 433    * @return Name der Default-Action\r
 434    */\r
 435   public String defaultAction() {\r
 436     return defaultAction;\r
 437   }\r
 438 \r
 439   /**\r
 440    *  Hier kann vor der Datenaufbereitung schon mal ein response geschickt\r
 441    *  werden (um das subjektive Antwortverhalten bei langsamen Verbindungen\r
 442    *  zu verbessern).\r
 443    */\r
 444   public void predeliver(HttpServletRequest req, HttpServletResponse res) {\r
 445     ;\r
 446   }\r
 447 \r
 448   /**\r
 449    * Holt die Felder aus der Metadatenfelderliste des StorageObjects, die\r
 450    * im HttpRequest vorkommen und liefert sie als HashMap zurueck\r
 451    *\r
 452    * @return HashMap mit den Werten\r
 453    */\r
 454   public HashMap getIntersectingValues(HttpServletRequest req, StorageObject theStorage)\r
 455       throws ServletModuleException {\r
 456 \r
 457     try {\r
 458       HTTPRequestParser parser;\r
 459       List theFieldList;\r
 460 \r
 461       logger.debug("using charset: " + req.getParameter("charset"));\r
 462       logger.debug("using method: " + req.getParameter("do"));\r
 463       if (req.getParameter("charset") != null) {\r
 464         parser = new HTTPRequestParser(req, req.getParameter("charset"));\r
 465         logger.debug("using charset: " + req.getParameter("charset"));\r
 466         logger.debug("original charset: " + req.getCharacterEncoding());\r
 467       }\r
 468       else {\r
 469         parser = new HTTPRequestParser(req);\r
 470       }\r
 471 \r
 472       theFieldList = theStorage.getFields();\r
 473 \r
 474       HashMap withValues = new HashMap();\r
 475       String aField, aValue;\r
 476 \r
 477       for (int i = 0; i < theFieldList.size(); i++) {\r
 478         aField = (String) theFieldList.get(i);\r
 479 \r
 480         logger.debug("field " + aField + " = " + parser.getParameter(aField));\r
 481 \r
 482         aValue = parser.getParameter(aField);\r
 483         if (aValue != null)\r
 484           withValues.put(aField, aValue);\r
 485       }\r
 486       return withValues;\r
 487     }\r
 488     catch (Throwable e) {\r
 489       e.printStackTrace(logger.asPrintWriter(LoggerWrapper.DEBUG_MESSAGE));\r
 490       throw new ServletModuleException(\r
 491           "ServletModule.getIntersectingValues: " + e.getMessage());\r
 492     }\r
 493   }\r
 494 \r
 495 }\r