source/mir/servlet/ServletModule.java

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