source/mir/servlet/ServletModule.java

   1 package  mir.servlet;
   2
   3 import  java.io.*;
   4 import  java.lang.*;
   5 import  java.util.*;
   6 import  javax.servlet.http.*;
   7 import  freemarker.template.*;
   8 import  mir.storage.*;
   9 import  mir.servlet.ServletModuleException;
  10 import  mir.misc.*;
  11 import  mir.entity.*;
  12 import  mir.module.*;
  13 import  mir.misc.*;
  14
  15
  16 /**
  17  * Abstract class ServletModule provides the base functionality for servlets.
  18  * Deriving a class from ServletModule enables class to insert/edit/update/delete
  19  * and list Entity from a Database via mainModule.
  20  *
  21  *
  22  *  Abstrakte Klasse ServletModule stellt die Basisfunktionalitaet der
  23  *  abgeleiteten ServletModule zur Verfügung.
  24  *
  25  * @version 28.6.1999
  26  * @author RK
  27  */
  28
  29 public abstract class ServletModule {
  30
  31   public String                 defaultAction;
  32   protected Logfile             theLog;
  33   protected AbstractModule      mainModule;
  34   protected String              templateListString;
  35   protected String              templateObjektString;
  36   protected String              templateConfirmString;
  37
  38   /**
  39    * Singelton - Methode muss in den abgeleiteten Klassen ueberschrieben werden.
  40    * @return ServletModule
  41    */
  42   public static ServletModule getInstance() { return null; }
  43
  44   /**
  45    * get the session binded language
  46    */
  47   public String getLanguage(HttpServletRequest req){
  48     HttpSession session = req.getSession(false);
  49     String language = (String)session.getAttribute("Language");
  50     if(language==null){
  51       language=MirConfig.getProp("StandardLanguage");
  52     }
  53     return language;
  54   }
  55
  56   // ACHTUNG DEPRECATED::::
  57   public void process(HttpServletRequest req, HttpServletResponse res) throws ServletModuleException {}
  58
  59
  60
  61   /**
  62    *  list(req,res) - generische Listmethode. Wennn die Funktionalitaet
  63    *  nicht reicht, muss sie in der abgeleiteten ServletModule-Klasse
  64    *  ueberschreiben werden.
  65    *
  66    * @param req Http-Request, das vom Dispatcher durchgereicht wird
  67    * @param res Http-Response, die vom Dispatcher durchgereicht wird
  68    */
  69   public void list(HttpServletRequest req, HttpServletResponse res)
  70     throws ServletModuleException {
  71     try {
  72       EntityList   theList;
  73       String       offsetParam = req.getParameter("offset");
  74       int          offset=0;
  75       PrintWriter out = res.getWriter();
  76
  77       // hier offsetcode bearbeiten
  78       if (offsetParam != null && !offsetParam.equals("")){
  79         offset = Integer.parseInt(offsetParam);
  80       }
  81       if (req.getParameter("next") != null){
  82           offset=Integer.parseInt(req.getParameter("nextoffset"));
  83       } else {
  84           if (req.getParameter("prev") != null){
  85             offset = Integer.parseInt(req.getParameter("prevoffset"));
  86           }
  87       }
  88       theList = mainModule.getByWhereClause(null, offset);
  89       //theList = mainModule.getByWhereClause((String)null, offset);
  90       if (theList == null || theList.getCount() == 0 || theList.getCount()>1){
  91         HTMLTemplateProcessor.process(res,getLanguage(req)+"/"+templateListString, theList, out);
  92       } else {
  93         deliver(req, res, theList.elementAt(0), templateObjektString);
  94       }
  95     } catch (Exception e) {
  96       throw new ServletModuleException(e.toString());
  97     }
  98   }
  99
 100   /**
 101    *  add(req,res) - generische Addmethode. Wennn die Funktionalitaet
 102    *  nicht reicht, muss sie in der abgeleiteten ServletModule-Klasse
 103    *  ueberschreiben werden.
 104    * @param req Http-Request, das vom Dispatcher durchgereicht wird
 105    * @param res Http-Response, die vom Dispatcher durchgereicht wird
 106    */
 107   public void add(HttpServletRequest req, HttpServletResponse res)
 108     throws ServletModuleException {
 109
 110     try {
 111       SimpleHash mergeData = new SimpleHash();
 112       mergeData.put("new", "1");
 113       deliver(req, res, mergeData, templateObjektString);
 114     } catch (Exception e) {
 115       throw new ServletModuleException(e.toString());
 116     }
 117   }
 118
 119   /**
 120    *  insert(req,res) - generische Insertmethode, folgt auf add.
 121    *  Wennn die Funktionalitaet
 122    *  nicht reicht, muss sie in der abgeleiteten ServletModule-Klasse
 123    *  ueberschreiben werden.
 124    *
 125    * @param req Http-Request, das vom Dispatcher durchgereicht wird
 126    * @param res Http-Response, die vom Dispatcher durchgereicht wird
 127    */
 128   public void insert(HttpServletRequest req, HttpServletResponse res)
 129     throws ServletModuleException, ServletModuleUserException {
 130     try {
 131       HashMap withValues = getIntersectingValues(req, mainModule.getStorageObject());
 132       String id = mainModule.add(withValues);
 133       // theLog.printDebugInfo("--trying to deliver..."+id);
 134       list(req,res);
 135       //deliver(req, res, mainModule.getById(id), templateObjektString);
 136     } catch (Exception e) {
 137       throw new ServletModuleException(e.toString());
 138     }
 139   }
 140
 141 /**
 142    *  delete(req,res) - generische Deletemethode. Wennn die Funktionalitaet
 143    *  nicht reicht, muss sie in der abgeleiteten ServletModule-Klasse
 144    *  ueberschreiben werden.
 145    *
 146    * @param req Http-Request, das vom Dispatcher durchgereicht wird
 147    * @param res Http-Response, die vom Dispatcher durchgereicht wird
 148    */
 149
 150   public void delete(HttpServletRequest req, HttpServletResponse res)
 151   throws ServletModuleException
 152   {
 153     try {
 154       String idParam = req.getParameter("id");
 155       if (idParam == null) throw new ServletModuleException("Falscher Aufruf: (id) nicht angegeben");
 156       // Hier code zum Loeschen
 157       String confirmParam = req.getParameter("confirm");
 158       String cancelParam = req.getParameter("cancel");
 159       if (confirmParam == null && cancelParam == null) {
 160         // HTML Ausgabe zum Confirmen!
 161         SimpleHash mergeData = new SimpleHash();
 162         String moduleClassName = mainModule.getClass().getName();
 163         int i = moduleClassName.indexOf(".Module");
 164         String moduleName = moduleClassName.substring(i+7);
 165         mergeData.put("module", moduleName);
 166         mergeData.put("infoString", moduleName + ": " + idParam);
 167         mergeData.put("id", idParam);
 168         mergeData.put("where", req.getParameter("where"));
 169         mergeData.put("order", req.getParameter("order"));
 170         mergeData.put("offset", req.getParameter("offset"));
 171         deliver(req, res, mergeData,templateConfirmString);
 172       } else {
 173         if (confirmParam!= null && !confirmParam.equals("")) {
 174           //theLog.printInfo("delete confirmed!");
 175           mainModule.deleteById(idParam);
 176           list(req,res); // back to list
 177         } else {
 178           if (req.getParameter("where") != null)
 179               list(req,res);
 180           else
 181             edit(req,res);
 182         }
 183       }
 184     } catch (Exception e) {
 185       throw new ServletModuleException(e.toString());
 186     }
 187   }
 188
 189   /**
 190    *  edit(req,res) - generische Editmethode. Wennn die Funktionalitaet
 191    *  nicht reicht, muss sie in der abgeleiteten ServletModule-Klasse
 192    *  ueberschreiben werden.
 193    *
 194    * @param req Http-Request, das vom Dispatcher durchgereicht wird
 195    * @param res Http-Response, die vom Dispatcher durchgereicht wird
 196    */
 197   public void edit(HttpServletRequest req, HttpServletResponse res)
 198     throws ServletModuleException {
 199     try {
 200       String idParam = req.getParameter("id");
 201       deliver(req, res, mainModule.getById(idParam), templateObjektString);
 202     } catch(ModuleException e) {
 203       throw new ServletModuleException(e.toString());
 204     }
 205   }
 206
 207 /**
 208    *  update(req,res) - generische Updatemethode. Wennn die Funktionalitaet
 209    *  nicht reicht, muss sie in der abgeleiteten ServletModule-Klasse
 210    *  ueberschreiben werden.
 211    *
 212    * @param req Http-Request, das vom Dispatcher durchgereicht wird
 213    * @param res Http-Response, die vom Dispatcher durchgereicht wird
 214    */
 215
 216   public void update(HttpServletRequest req, HttpServletResponse res)
 217     throws ServletModuleException {
 218     try {
 219       String idParam = req.getParameter("id");
 220       HashMap withValues = getIntersectingValues(req, mainModule.getStorageObject());
 221       String id = mainModule.set(withValues);
 222       //theLog.printInfo("Showing Entity with id: " + id);
 223       //edit(req,res);
 224       String whereParam = req.getParameter("where");
 225       String orderParam = req.getParameter("order");
 226       if ((whereParam!=null && !whereParam.equals("")) || (orderParam!=null && !orderParam.equals(""))){
 227         //theLog.printDebugInfo("update to list");
 228         list(req,res);
 229       } else {
 230         edit(req, res);
 231       }
 232       //list(req,res);
 233     } catch (Exception e) {
 234       throw new ServletModuleException(e.toString());
 235     }
 236   }
 237
 238   // Hilfsprozeduren
 239   /**
 240   public void predeliver(HttpServletResponse res, TemplateModelRoot rtm, String tmpl)
 241     throws ServletModuleException {
 242     try {
 243       PrintWriter out = new LineFilterWriter(res.getWriter());
 244       StringWriter a = new StringWriter();
 245       deliver(new PrintWriter(a),rtm,tmpl);
 246       out.write(a.toString());
 247       out.flush();
 248     } catch (Exception e) {
 249       e.printStackTrace();System.err.println(e.toString());
 250     }
 251   }
 252   */
 253
 254   /**
 255    * deliver liefert das Template mit dem Filenamen templateFilename
 256    * an den HttpServletResponse res aus, nachdem es mit den Daten aus
 257    * TemplateModelRoot rtm gemischt wurde
 258    *
 259    * @param res Http-Response, die vom Dispatcher durchgereicht wird
 260    * @param rtm beinahalten das freemarker.template.TempalteModelRoot mit den
 261    *   Daten, die ins Template gemerged werden sollen.
 262    * @param tmpl Name des Templates
 263    * @exception ServletModuleException
 264    */
 265   public void deliver(HttpServletRequest req, HttpServletResponse res, TemplateModelRoot rtm, String templateFilename)
 266     throws ServletModuleException {
 267     if (rtm == null) rtm = new SimpleHash();
 268     try {
 269       //PrintWriter out =  new LineFilterWriter(res.getWriter());
 270       PrintWriter out =  res.getWriter();
 271       HTMLTemplateProcessor.process(res,getLanguage(req)+"/"+templateFilename, rtm , out);
 272       out.close();
 273     } catch (HTMLParseException e) {
 274       throw new ServletModuleException(e.toString());
 275     } catch (IOException e) {
 276       throw new ServletModuleException(e.toString());
 277     }
 278   }
 279   /**
 280    * deliver liefert das Template mit dem Filenamen templateFilename
 281    * an den HttpServletResponse res aus, nachdem es mit den Daten aus
 282    * TemplateModelRoot rtm gemischt wurde
 283    *
 284    * @param res Http-Response, die vom Dispatcher durchgereicht wird
 285    * @param rtm beinahalten das freemarker.template.TempalteModelRoot mit den
 286    *   Daten, die ins Template gemerged werden sollen.
 287    * @param tmpl Name des Templates
 288    * @exception ServletModuleException
 289    */
 290   public void deliver_compressed(HttpServletRequest req, HttpServletResponse res, TemplateModelRoot rtm, String templateFilename)
 291     throws ServletModuleException {
 292     if (rtm == null) rtm = new SimpleHash();
 293     try {
 294       PrintWriter out =  new LineFilterWriter(res.getWriter());
 295       //PrintWriter out =  res.getWriter();
 296       HTMLTemplateProcessor.process(res,getLanguage(req)+"/"+templateFilename, rtm , out);
 297       out.close();
 298     } catch (HTMLParseException e) {
 299       throw new ServletModuleException(e.toString());
 300     } catch (IOException e) {
 301       throw new ServletModuleException(e.toString());
 302     }
 303   }
 304
 305   /**
 306    * deliver liefert das Template mit dem Filenamen templateFilename
 307    * an den HttpServletResponse res aus, nachdem es mit den Daten aus
 308    * TemplateModelRoot rtm gemischt wurde
 309    *
 310    * @param out ist der OutputStream, in den die gergten Daten geschickt werden sollen.
 311    * @param rtm beinahalten das freemarker.template.TempalteModelRoot mit den
 312    *   Daten, die ins Template gemerged werden sollen.
 313    * @param tmpl Name des Templates
 314    * @exception ServletModuleException
 315    */
 316   private void deliver(HttpServletResponse res,HttpServletRequest req, PrintWriter out, TemplateModelRoot rtm, String templateFilename)
 317     throws HTMLParseException {
 318     HTMLTemplateProcessor.process(res,getLanguage(req)+"/"+templateFilename, rtm , out);
 319   }
 320
 321   /**
 322    *  Wenn die abgeleitete Klasse diese Methode ueberschreibt und einen String mit einem
 323    *  Methodennamen zurueckliefert, dann wird diese Methode bei fehlender Angabe des
 324    *  doParameters ausgefuehrt.
 325    *
 326    * @return Name der Default-Action
 327    */
 328   public String defaultAction() { return defaultAction; }
 329
 330     /**
 331    *  Hier kann vor der Datenaufbereitung schon mal ein response geschickt
 332    *  werden (um das subjektive Antwortverhalten bei langsamen Verbindungen
 333    *  zu verbessern).
 334    */
 335   public void predeliver(HttpServletRequest req, HttpServletResponse res) { ; }
 336
 337   /**
 338    * Holt die Felder aus der Metadatenfelderliste des StorageObjects, die
 339    * im HttpRequest vorkommen und liefert sie als HashMap zurueck
 340    *
 341    * @return HashMap mit den Werten
 342    */
 343   public HashMap getIntersectingValues(HttpServletRequest req, StorageObject theStorage)
 344     throws ServletModuleException {
 345     ArrayList theFieldList;
 346     try {
 347         theFieldList = theStorage.getFields();
 348     } catch (StorageObjectException e) {
 349       throw new ServletModuleException("ServletModule.getIntersectingValues: " + e.toString());
 350     }
 351
 352     HashMap withValues = new HashMap();
 353     String aField, aValue;
 354
 355     for(int i=0; i<theFieldList.size();i++) {
 356       aField = (String)theFieldList.get(i);
 357       aValue = req.getParameter(aField);
 358       if (aValue!=null) withValues.put(aField,aValue);
 359     }
 360     return withValues;
 361   }
 362
 363 }