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