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(false);
  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 && !offsetParam.equals("")){
  80         offset = Integer.parseInt(offsetParam);
  81       }
  82       if (req.getParameter("next") != null){
  83           offset=Integer.parseInt(req.getParameter("nextoffset"));
  84       } else {
  85           if (req.getParameter("prev") != null){
  86             offset = Integer.parseInt(req.getParameter("prevoffset"));
  87           }
  88       }
  89       theList = mainModule.getByWhereClause(null, offset);
  90       //theList = mainModule.getByWhereClause((String)null, offset);
  91       if (theList == null || theList.getCount() == 0 || theList.getCount()>1){
  92         HTMLTemplateProcessor.process(res,getLanguage(req)+"/"+templateListString, theList, out);
  93       } else {
  94         deliver(req, res, theList.elementAt(0), templateObjektString);
  95       }
  96     } catch (Exception e) {
  97       throw new ServletModuleException(e.toString());
  98     }
  99   }
 100
 101   /**
 102    *  add(req,res) - generische Addmethode. Wennn die Funktionalitaet
 103    *  nicht reicht, muss sie in der abgeleiteten ServletModule-Klasse
 104    *  ueberschreiben werden.
 105    * @param req Http-Request, das vom Dispatcher durchgereicht wird
 106    * @param res Http-Response, die vom Dispatcher durchgereicht wird
 107    */
 108   public void add(HttpServletRequest req, HttpServletResponse res)
 109     throws ServletModuleException {
 110
 111     try {
 112       SimpleHash mergeData = new SimpleHash();
 113       mergeData.put("new", "1");
 114       deliver(req, res, mergeData, templateObjektString);
 115     } catch (Exception e) {
 116       throw new ServletModuleException(e.toString());
 117     }
 118   }
 119
 120   /**
 121    *  insert(req,res) - generische Insertmethode, folgt auf add.
 122    *  Wennn die Funktionalitaet
 123    *  nicht reicht, muss sie in der abgeleiteten ServletModule-Klasse
 124    *  ueberschreiben werden.
 125    *
 126    * @param req Http-Request, das vom Dispatcher durchgereicht wird
 127    * @param res Http-Response, die vom Dispatcher durchgereicht wird
 128    */
 129   public void insert(HttpServletRequest req, HttpServletResponse res)
 130     throws ServletModuleException {
 131     try {
 132       HashMap withValues = getIntersectingValues(req, mainModule.getStorageObject());
 133       String id = mainModule.add(withValues);
 134       // theLog.printDebugInfo("--trying to deliver..."+id);
 135       list(req,res);
 136       //deliver(req, res, mainModule.getById(id), templateObjektString);
 137     }
 138     catch (Exception e) { throw new ServletModuleException(e.toString());}
 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 entity Entity, aus der die Daten, die ins Template gemerged werden sollen.
 286    * @param tmpl Name des Templates
 287    * @exception ServletModuleException
 288    */
 289   public void deliver(HttpServletRequest req, HttpServletResponse res, Entity ent, String templateFilename)
 290     throws ServletModuleException {
 291     deliver(req, res,HTMLTemplateProcessor.makeSimpleHash(ent), templateFilename);
 292   }
 293   /**
 294    * deliver liefert das Template mit dem Filenamen templateFilename
 295    * an den HttpServletResponse res aus, nachdem es mit den Daten aus
 296    * TemplateModelRoot rtm gemischt wurde
 297    *
 298    * @param out ist der OutputStream, in den die gergten Daten geschickt werden sollen.
 299    * @param rtm beinahalten das freemarker.template.TempalteModelRoot mit den
 300    *   Daten, die ins Template gemerged werden sollen.
 301    * @param tmpl Name des Templates
 302    * @exception ServletModuleException
 303    */
 304   private void deliver(HttpServletResponse res,HttpServletRequest req, PrintWriter out, TemplateModelRoot rtm, String templateFilename)
 305     throws HTMLParseException {
 306     HTMLTemplateProcessor.process(res,getLanguage(req)+"/"+templateFilename, rtm , out);
 307   }
 308
 309   /**
 310    *  Wenn die abgeleitete Klasse diese Methode ueberschreibt und einen String mit einem
 311    *  Methodennamen zurueckliefert, dann wird diese Methode bei fehlender Angabe des
 312    *  doParameters ausgefuehrt.
 313    *
 314    * @return Name der Default-Action
 315    */
 316   public String defaultAction() { return defaultAction; }
 317
 318     /**
 319    *  Hier kann vor der Datenaufbereitung schon mal ein response geschickt
 320    *  werden (um das subjektive Antwortverhalten bei langsamen Verbindungen
 321    *  zu verbessern).
 322    */
 323   public void predeliver(HttpServletRequest req, HttpServletResponse res) { ; }
 324
 325   /**
 326    * Holt die Felder aus der Metadatenfelderliste des StorageObjects, die
 327    * im HttpRequest vorkommen und liefert sie als HashMap zurueck
 328    *
 329    * @return HashMap mit den Werten
 330    */
 331   public HashMap getIntersectingValues(HttpServletRequest req, StorageObject theStorage)
 332     throws ServletModuleException {
 333     ArrayList theFieldList;
 334     try {
 335         theFieldList = theStorage.getFields();
 336     } catch (StorageObjectException e) {
 337       throw new ServletModuleException("ServletModule.getIntersectingValues: " + e.toString());
 338     }
 339
 340     HashMap withValues = new HashMap();
 341     String aField, aValue;
 342
 343     for(int i=0; i<theFieldList.size();i++) {
 344       aField = (String)theFieldList.get(i);
 345       aValue = req.getParameter(aField);
 346       if (aValue!=null) withValues.put(aField,aValue);
 347     }
 348     return withValues;
 349   }
 350
 351 }