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 {
 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     }
 137     catch (Exception e) { throw new ServletModuleException(e.toString());}
 138   }
 139
 140 /**
 141    *  delete(req,res) - generische Deletemethode. Wennn die Funktionalitaet
 142    *  nicht reicht, muss sie in der abgeleiteten ServletModule-Klasse
 143    *  ueberschreiben werden.
 144    *
 145    * @param req Http-Request, das vom Dispatcher durchgereicht wird
 146    * @param res Http-Response, die vom Dispatcher durchgereicht wird
 147    */
 148
 149   public void delete(HttpServletRequest req, HttpServletResponse res)
 150   throws ServletModuleException
 151   {
 152     try {
 153       String idParam = req.getParameter("id");
 154       if (idParam == null) throw new ServletModuleException("Falscher Aufruf: (id) nicht angegeben");
 155       // Hier code zum Loeschen
 156       String confirmParam = req.getParameter("confirm");
 157       String cancelParam = req.getParameter("cancel");
 158       if (confirmParam == null && cancelParam == null) {
 159         // HTML Ausgabe zum Confirmen!
 160         SimpleHash mergeData = new SimpleHash();
 161         String moduleClassName = mainModule.getClass().getName();
 162         int i = moduleClassName.indexOf(".Module");
 163         String moduleName = moduleClassName.substring(i+7);
 164         mergeData.put("module", moduleName);
 165         mergeData.put("infoString", moduleName + ": " + idParam);
 166         mergeData.put("id", idParam);
 167         mergeData.put("where", req.getParameter("where"));
 168         mergeData.put("order", req.getParameter("order"));
 169         mergeData.put("offset", req.getParameter("offset"));
 170         deliver(req, res, mergeData,templateConfirmString);
 171       } else {
 172         if (confirmParam!= null && !confirmParam.equals("")) {
 173           //theLog.printInfo("delete confirmed!");
 174           mainModule.deleteById(idParam);
 175           list(req,res); // back to list
 176         } else {
 177           if (req.getParameter("where") != null)
 178               list(req,res);
 179           else
 180             edit(req,res);
 181         }
 182       }
 183     } catch (Exception e) {
 184       throw new ServletModuleException(e.toString());
 185     }
 186   }
 187
 188   /**
 189    *  edit(req,res) - generische Editmethode. Wennn die Funktionalitaet
 190    *  nicht reicht, muss sie in der abgeleiteten ServletModule-Klasse
 191    *  ueberschreiben werden.
 192    *
 193    * @param req Http-Request, das vom Dispatcher durchgereicht wird
 194    * @param res Http-Response, die vom Dispatcher durchgereicht wird
 195    */
 196   public void edit(HttpServletRequest req, HttpServletResponse res)
 197     throws ServletModuleException {
 198     try {
 199       String idParam = req.getParameter("id");
 200       deliver(req, res, mainModule.getById(idParam), templateObjektString);
 201     } catch(ModuleException e) {
 202       throw new ServletModuleException(e.toString());
 203     }
 204   }
 205
 206 /**
 207    *  update(req,res) - generische Updatemethode. Wennn die Funktionalitaet
 208    *  nicht reicht, muss sie in der abgeleiteten ServletModule-Klasse
 209    *  ueberschreiben werden.
 210    *
 211    * @param req Http-Request, das vom Dispatcher durchgereicht wird
 212    * @param res Http-Response, die vom Dispatcher durchgereicht wird
 213    */
 214
 215   public void update(HttpServletRequest req, HttpServletResponse res)
 216     throws ServletModuleException {
 217     try {
 218       String idParam = req.getParameter("id");
 219       HashMap withValues = getIntersectingValues(req, mainModule.getStorageObject());
 220       String id = mainModule.set(withValues);
 221       //theLog.printInfo("Showing Entity with id: " + id);
 222       //edit(req,res);
 223       String whereParam = req.getParameter("where");
 224       String orderParam = req.getParameter("order");
 225       if ((whereParam!=null && !whereParam.equals("")) || (orderParam!=null && !orderParam.equals(""))){
 226         //theLog.printDebugInfo("update to list");
 227         list(req,res);
 228       } else {
 229         edit(req, res);
 230       }
 231       //list(req,res);
 232     } catch (Exception e) {
 233       throw new ServletModuleException(e.toString());
 234     }
 235   }
 236
 237   // Hilfsprozeduren
 238   /**
 239   public void predeliver(HttpServletResponse res, TemplateModelRoot rtm, String tmpl)
 240     throws ServletModuleException {
 241     try {
 242       PrintWriter out = new LineFilterWriter(res.getWriter());
 243       StringWriter a = new StringWriter();
 244       deliver(new PrintWriter(a),rtm,tmpl);
 245       out.write(a.toString());
 246       out.flush();
 247     } catch (Exception e) {
 248       e.printStackTrace();System.err.println(e.toString());
 249     }
 250   }
 251   */
 252
 253   /**
 254    * deliver liefert das Template mit dem Filenamen templateFilename
 255    * an den HttpServletResponse res aus, nachdem es mit den Daten aus
 256    * TemplateModelRoot rtm gemischt wurde
 257    *
 258    * @param res Http-Response, die vom Dispatcher durchgereicht wird
 259    * @param rtm beinahalten das freemarker.template.TempalteModelRoot mit den
 260    *   Daten, die ins Template gemerged werden sollen.
 261    * @param tmpl Name des Templates
 262    * @exception ServletModuleException
 263    */
 264   public void deliver(HttpServletRequest req, HttpServletResponse res, TemplateModelRoot rtm, String templateFilename)
 265     throws ServletModuleException {
 266     if (rtm == null) rtm = new SimpleHash();
 267     try {
 268       //PrintWriter out =  new LineFilterWriter(res.getWriter());
 269       PrintWriter out =  res.getWriter();
 270       HTMLTemplateProcessor.process(res,getLanguage(req)+"/"+templateFilename, rtm , out);
 271       out.close();
 272     } catch (HTMLParseException e) {
 273       throw new ServletModuleException(e.toString());
 274     } catch (IOException e) {
 275       throw new ServletModuleException(e.toString());
 276     }
 277   }
 278   /**
 279    * deliver liefert das Template mit dem Filenamen templateFilename
 280    * an den HttpServletResponse res aus, nachdem es mit den Daten aus
 281    * TemplateModelRoot rtm gemischt wurde
 282    *
 283    * @param res Http-Response, die vom Dispatcher durchgereicht wird
 284    * @param rtm beinahalten das freemarker.template.TempalteModelRoot mit den
 285    *   Daten, die ins Template gemerged werden sollen.
 286    * @param tmpl Name des Templates
 287    * @exception ServletModuleException
 288    */
 289   public void deliver_compressed(HttpServletRequest req, HttpServletResponse res, TemplateModelRoot rtm, String templateFilename)
 290     throws ServletModuleException {
 291     if (rtm == null) rtm = new SimpleHash();
 292     try {
 293       PrintWriter out =  new LineFilterWriter(res.getWriter());
 294       //PrintWriter out =  res.getWriter();
 295       HTMLTemplateProcessor.process(res,getLanguage(req)+"/"+templateFilename, rtm , out);
 296       out.close();
 297     } catch (HTMLParseException e) {
 298       throw new ServletModuleException(e.toString());
 299     } catch (IOException e) {
 300       throw new ServletModuleException(e.toString());
 301     }
 302   }
 303
 304   /**
 305    * deliver liefert das Template mit dem Filenamen templateFilename
 306    * an den HttpServletResponse res aus, nachdem es mit den Daten aus
 307    * TemplateModelRoot rtm gemischt wurde
 308    *
 309    * @param out ist der OutputStream, in den die gergten Daten geschickt werden sollen.
 310    * @param rtm beinahalten das freemarker.template.TempalteModelRoot mit den
 311    *   Daten, die ins Template gemerged werden sollen.
 312    * @param tmpl Name des Templates
 313    * @exception ServletModuleException
 314    */
 315   private void deliver(HttpServletResponse res,HttpServletRequest req, PrintWriter out, TemplateModelRoot rtm, String templateFilename)
 316     throws HTMLParseException {
 317     HTMLTemplateProcessor.process(res,getLanguage(req)+"/"+templateFilename, rtm , out);
 318   }
 319
 320   /**
 321    *  Wenn die abgeleitete Klasse diese Methode ueberschreibt und einen String mit einem
 322    *  Methodennamen zurueckliefert, dann wird diese Methode bei fehlender Angabe des
 323    *  doParameters ausgefuehrt.
 324    *
 325    * @return Name der Default-Action
 326    */
 327   public String defaultAction() { return defaultAction; }
 328
 329     /**
 330    *  Hier kann vor der Datenaufbereitung schon mal ein response geschickt
 331    *  werden (um das subjektive Antwortverhalten bei langsamen Verbindungen
 332    *  zu verbessern).
 333    */
 334   public void predeliver(HttpServletRequest req, HttpServletResponse res) { ; }
 335
 336   /**
 337    * Holt die Felder aus der Metadatenfelderliste des StorageObjects, die
 338    * im HttpRequest vorkommen und liefert sie als HashMap zurueck
 339    *
 340    * @return HashMap mit den Werten
 341    */
 342   public HashMap getIntersectingValues(HttpServletRequest req, StorageObject theStorage)
 343     throws ServletModuleException {
 344     ArrayList theFieldList;
 345     try {
 346         theFieldList = theStorage.getFields();
 347     } catch (StorageObjectException e) {
 348       throw new ServletModuleException("ServletModule.getIntersectingValues: " + e.toString());
 349     }
 350
 351     HashMap withValues = new HashMap();
 352     String aField, aValue;
 353
 354     for(int i=0; i<theFieldList.size();i++) {
 355       aField = (String)theFieldList.get(i);
 356       aValue = req.getParameter(aField);
 357       if (aValue!=null) withValues.put(aField,aValue);
 358     }
 359     return withValues;
 360   }
 361
 362 }