source/mir/servlet/ServletModule.java

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