source/mir/misc/HTMLTemplateProcessor.java

   1 /*
   2  * put your module comment here
   3  */
   4
   5
   6 package mir.misc;
   7
   8 import  java.lang.*;
   9 import  java.util.*;
  10 import  java.io.*;
  11 import  java.net.*;
  12 import  freemarker.template.*;
  13 import  mir.entity.*;
  14 import  mir.storage.*;
  15 import javax.servlet.http.*;
  16
  17
  18 /**
  19  * Hilfsklasse zum Mergen von Template und Daten
  20  */
  21 public final class HTMLTemplateProcessor {
  22
  23     public static String                templateDir;
  24                 private static FileTemplateCache    templateCache;
  25                 private static Logfile                theLog;
  26                 private static String                 docRoot;
  27                 private static String                 actionRoot;
  28                 private static String                 productionHost;
  29                 private static String               audioHost;
  30                 private static String               videoHost;
  31                 private static String               imageHost;
  32                 private static String                             openAction;
  33     protected static String producerDocRoot = Configuration.getProperty("Producer.DocRoot");
  34         protected static String producerStorageRoot = Configuration.getProperty("Producer.StorageRoot");
  35
  36
  37                 //
  38                 // Initialisierung
  39
  40                 static {
  41       templateDir = Configuration.getProperty("Home") + Configuration.getProperty("HTMLTemplateProcessor.Dir");
  42                         templateCache = new FileTemplateCache(templateDir);
  43                         templateCache.setLoadingPolicy(templateCache.LOAD_ON_DEMAND);
  44                         //templateCache.startAutoUpdate();
  45                         theLog = Logfile.getInstance(Configuration.getProperty("Home") + Configuration.getProperty("HTMLTemplateProcessor.Logfile"));
  46                         docRoot = Configuration.getProperty("HTMLTemplateProcessor.DocRoot");
  47                         actionRoot = Configuration.getProperty("HTMLTemplateProcessor.ActionRoot");
  48                         openAction = Configuration.getProperty("Producer.OpenAction");
  49                         productionHost = Configuration.getProperty("Producer.ProductionHost");
  50                         videoHost = Configuration.getProperty("Producer.VideoHost");
  51                         audioHost = Configuration.getProperty("Producer.AudioHost");
  52                         imageHost = Configuration.getProperty("Producer.Image.Host");
  53       producerDocRoot = Configuration.getProperty("Producer.DocRoot");
  54       producerStorageRoot = Configuration.getProperty("Producer.StorageRoot");
  55
  56
  57                 }
  58
  59   /**
  60          * Privater Konstruktor, um versehentliche Instantiierung zu verhindern
  61          */
  62         private HTMLTemplateProcessor () {
  63         }
  64
  65
  66                 //
  67                 //  process-Methoden zum Mischen verschiedener Datenstrukturen mit HTML-Templates
  68
  69
  70         /**
  71          * Wandelt <code>anEntity</code> in freemarker-Struktur um, mischt die Daten mit
  72          * Template <code>templateFilename</code> und gibt das Ergebnis an den PrintWriter
  73          * <code>out</code>
  74          *
  75          * @param templateFilename
  76          * @param anEntity
  77          * @param out
  78          * @exception HTMLParseException
  79          */
  80
  81                 public static void process(String templateFilename, Entity anEntity, PrintWriter out)
  82                         throws HTMLParseException {
  83                                 if (anEntity == null)  throw new HTMLParseException("Entity leer!");
  84                                 else process(templateFilename, anEntity, out);
  85                 }
  86
  87
  88         /**
  89          * Wandelt Liste mit Entities <code>entList</code> in freemarker-Struktur um, mischt die Daten mit
  90          * Template <code>templateFilename</code> und gibt das Ergebnis an den PrintWriter
  91          * <code>out</code>
  92          *
  93          * @param templateFilename
  94          * @param entList
  95          * @param out
  96          * @exception HTMLParseException
  97          */
  98                 public static void process(HttpServletResponse res,String templateFilename, EntityList entList, PrintWriter out)
  99                         throws HTMLParseException {
 100                         process(res, templateFilename,  entList,  (String)null, (TemplateModelRoot)null,  out);
 101                 }
 102
 103         /**
 104          * Wandelt Entitylist in freemarker-Struktur um, fügt <code>additionalModel</code>
 105          * unter dem Namen <code>additionalModelName</code> ein und mischt die Daten mit
 106          * Template <code>templateFilename</code> und gibt das Ergebnis an den PrintWriter
 107          * <code>out</code>
 108          *
 109          * @param templateFilename
 110          * @param entList
 111          * @param additionalModelName
 112          * @param additionalModel
 113          * @param out
 114          * @exception HTMLParseException
 115          */
 116                 public static void process(HttpServletResponse res,String templateFilename, EntityList entList, String additionalModelName,
 117                                                  TemplateModelRoot additionalModel, PrintWriter out)
 118                         throws HTMLParseException {
 119
 120                         SimpleHash modelRoot = new SimpleHash();
 121
 122                         if (entList == null) {
 123                                  //theLog.printInfo("Keine Daten! Suche erfolglos.");
 124                                  process(null,templateFilename, modelRoot, out);
 125                         } else {
 126                                 try {
 127                                         modelRoot = makeSimpleHashWithEntitylistInfos(entList);
 128                                         //
 129                                         // Hilfskruecke um mal ein Popup mit reinzunhemen ..
 130                                         if (additionalModelName != null && additionalModel != null)
 131                                                         modelRoot.put(additionalModelName, additionalModel);
 132
 133                                         process(res,templateFilename, modelRoot, out);
 134                                 } catch (StorageObjectException e) {
 135                                         throw new HTMLParseException(e.toString());
 136                                 }
 137                         }
 138                 }
 139
 140         /**
 141          * Wandelt HashMap <code>mergeData</code> in freemarker-Struktur und mischt diese mit
 142          * Template <code>templateFilename</code> und gibt das Ergebnis an den PrintWriter
 143          * <code>out</code>
 144          *
 145          * @param templateFilename
 146          * @param mergeData
 147          * @param out
 148          * @exception HTMLParseException
 149          */
 150                 public static void process(HttpServletResponse res,String templateFilename, HashMap mergeData, PrintWriter out)
 151                         throws HTMLParseException {
 152                         process(res,templateFilename, makeSimpleHash(mergeData), out);
 153                 }
 154
 155         /**
 156          * Gibt Template <code>templateFilename</code> an den PrintWriter
 157          * <code>out</code>
 158          *
 159          * @param templateFilename
 160          * @param mergeData
 161          * @param out
 162          * @exception HTMLParseException
 163          */
 164                 public static void process(String templateFilename, PrintWriter out)
 165                         throws HTMLParseException {
 166                         process(null,templateFilename, (TemplateModelRoot)null, out);
 167                 }
 168
 169
 170         /**
 171          * Mischt die freemarker-Struktur <code>tmr</code> mit
 172          * Template <code>templateFilename</code> und gibt das Ergebnis an den PrintWriter
 173          * <code>out</code>
 174          *
 175          * @param templateFilename
 176          * @param mergeData
 177          * @param out
 178          * @exception HTMLParseException
 179          */
 180                 public static void process(HttpServletResponse res,String templateFilename, TemplateModelRoot tmr, PrintWriter out)
 181                         throws HTMLParseException {
 182                         if (out==null) throw new HTMLParseException("KEIN OUTPUTSTREAM");
 183                         Template tmpl = getTemplateFor(templateFilename);
 184                         if (tmpl == null) throw new HTMLParseException("KEIN TEMPLATE: " + templateFilename);
 185                         if (tmr==null) tmr = new SimpleHash();
 186                         String session=null;
 187                         if (res!=null) {
 188                                 session=res.encodeURL("");
 189                         }
 190
 191       // put standard configuration into tempalteRootmodel
 192                         SimpleHash configHash = new SimpleHash();
 193                         configHash.put("docroot", new SimpleScalar(producerDocRoot));
 194                         configHash.put("storageroot", new SimpleScalar(producerStorageRoot));
 195                         configHash.put("productionhost", new SimpleScalar(productionHost));
 196                         configHash.put("openaction", new SimpleScalar(openAction));
 197
 198
 199       tmr.put("docRoot", new SimpleScalar(docRoot));
 200                         tmr.put("now", new SimpleScalar(StringUtil.date2readableDateTime(new GregorianCalendar())));
 201                         tmr.put("actionRoot", new SimpleScalar(actionRoot+session));
 202                         tmr.put("openAction", new SimpleScalar(openAction));
 203                         tmr.put("productionHost", new SimpleScalar(productionHost));
 204                         tmr.put("videoHost", new SimpleScalar(videoHost));
 205                         tmr.put("audioHost", new SimpleScalar(audioHost));
 206                         tmr.put("imageHost", new SimpleScalar(imageHost));
 207
 208       tmr.put("config", configHash);
 209                         tmpl.process(tmr, out);
 210
 211                 }
 212
 213
 214   /**
 215          *   Wandelt eine Entity-Liste in eine SimpleList von SimpleHashes um.
 216          *   @param aList ist eine Liste von Entity
 217          *   @return eine freemarker.template.SimpleList von SimpleHashes.
 218          */
 219         public static SimpleList makeSimpleList(EntityList aList) throws StorageObjectException
 220         {
 221                 SimpleList      simpleList = new SimpleList();
 222                 if (aList != null) {
 223                         for(int i=0;i<aList.size();i++){
 224                                 simpleList.add(makeSimpleHash(aList.elementAt(i)));
 225                         }
 226                 }
 227                 return simpleList;
 228         }
 229
 230         /**
 231          *  Konvertiert ein EntityList in ein freemarker.template.SimpleHash-Modell. Im Hash
 232          *  sind die einzelnen Entities ueber ihre id zu erreichen.
 233          *  @param aList ist die EntityList
 234          *  @return SimpleHash mit den entsprechenden freemarker Daten
 235          *
 236          */
 237         public static SimpleHash makeSimpleHash(EntityList aList) throws StorageObjectException
 238         {
 239                 SimpleHash      simpleHash = new SimpleHash();
 240                 Entity          currentEntity;
 241
 242                 if (aList != null) {
 243                         for (int i=0;i<aList.size();i++) {
 244                                  currentEntity = (Entity)aList.elementAt(i);
 245                                  simpleHash.put(currentEntity.getId(), makeSimpleHash(currentEntity));
 246                         }
 247                 }
 248                 return simpleHash;
 249         }
 250
 251         /**
 252          *  Konvertiert ein Entity in ein freemarker.template.SimpleHash-Modell
 253          *  @param entity ist die Entity
 254          *  @return SimpleHash mit den entsprechenden freemarker Daten
 255          *
 256          */
 257                 public static SimpleHash makeSimpleHash(Entity entity) {
 258                         if (entity != null) {
 259                                 return makeSimpleHash(entity.getValues());
 260                         }
 261                         else {
 262                                 //theLog.printWarning("Entity ist <null>");
 263                                 return null;
 264                         }
 265                 }
 266
 267         /**
 268          *  Konvertiert ein Hashtable mit den keys und values als String
 269          *  in ein freemarker.template.SimpleHash-Modell
 270          *  @param mergeData der HashMap mit den String / String Daten
 271          *  @return SimpleHash mit den entsprechenden freemarker Daten
 272          *
 273          */
 274         public static SimpleHash makeSimpleHash(HashMap mergeData)
 275         {
 276                 SimpleHash modelRoot = new SimpleHash();
 277                 String aField;
 278                 if (mergeData != null) {
 279                         Set set = mergeData.keySet();
 280                         Iterator it =  set.iterator();
 281                         for (int i=0; i<set.size();i++)  {
 282                                 aField = (String)it.next();
 283                                 modelRoot.put(aField, (String)mergeData.get(aField));
 284                         }
 285                 }
 286                 return modelRoot;
 287         }
 288
 289
 290         /**
 291          * Wandelt EntityListe in SimpleHash um, und versieht die Liste mit StandardInfos,
 292          * die aus EntityList kommen.
 293          *
 294          * @param entList
 295          * @return SimpleHash mit Entity-Daten und ZusatzInfos.
 296          * @exception StorageObjectException
 297          */
 298                 public static SimpleHash makeSimpleHashWithEntitylistInfos(EntityList entList) throws StorageObjectException {
 299                         SimpleHash modelRoot = new SimpleHash();
 300                         if (entList!=null) {
 301                                                                 modelRoot.put("contentlist", makeSimpleList(entList));
 302                                                                 modelRoot.put("count", new SimpleScalar((new Integer(entList.getCount())).toString()));
 303                                         if (entList.getWhere()!=null) {
 304                                                 modelRoot.put("where", new SimpleScalar(entList.getWhere()));
 305                                                 modelRoot.put("where_encoded", new SimpleScalar(URLEncoder.encode(entList.getWhere())));
 306                                         }
 307
 308                                         if(entList.getOrder()!=null) {
 309                                                 modelRoot.put("order", new SimpleScalar(entList.getOrder()));
 310                                                 modelRoot.put("order_encoded", new SimpleScalar(URLEncoder.encode(entList.getOrder())));
 311                                         }
 312                                         modelRoot.put("from", new SimpleScalar((new Integer(entList.getFrom())).toString()));
 313                                         modelRoot.put("to", new SimpleScalar((new Integer(entList.getTo())).toString()));
 314
 315                                         if (entList.hasNextBatch())
 316                                                 modelRoot.put("next", new SimpleScalar((new Integer(entList.getNextBatch())).toString()));
 317                                         if (entList.hasPrevBatch())
 318                                                 modelRoot.put("prev", new SimpleScalar((new Integer(entList.getPrevBatch())).toString()));
 319                         }
 320                         return modelRoot;
 321                 }
 322
 323         /**
 324          * Private Methode, um für templateFilename das Template zu bekommen.
 325          * @param templateFilename
 326          * @return Template
 327          * @exception HTMLParseException
 328          */
 329         private static Template getTemplateFor(String templateFilename) throws HTMLParseException
 330                 {
 331                         if (templateFilename!=null) return templateCache.getTemplate(templateFilename);
 332                         else {
 333                                 theLog.printError("CACHE (ERR): Unknown template: " + templateFilename);
 334                                 throw new HTMLParseException("Templatedatei: "+ templateFilename + " nicht gefunden!");
 335                         }
 336                 }
 337
 338
 339     public static void stopAutoUpdate(){
 340       templateCache.stopAutoUpdate();
 341       templateCache=null;
 342     }
 343 }