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