source/mir/servlet/AdminServletModule.java

   1 /*
   2  * Copyright (C) 2001-2006 The Mir-coders group
   3  *
   4  * This file is part of Mir.
   5  *
   6  * Mir is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * Mir is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with Mir; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  * In addition, as a special exception, The Mir-coders gives permission to link
  21  * the code of this program with  any library licensed under the Apache Software License,
  22  * and distribute linked combinations including the two.  You must obey the
  23  * GNU General Public License in all respects for all of the code used other than
  24  * the above mentioned libraries.  If you modify this file, you may extend this
  25  * exception to your version of the file, but you are not obligated to do so.
  26  * If you do not wish to do so, delete this exception statement from your version.
  27  */
  28 package mir.servlet;
  29
  30 import mir.entity.adapter.EntityAdapterEngine;
  31 import mir.entity.adapter.EntityAdapterModel;
  32 import mir.module.AbstractModule;
  33 import mir.module.ModuleExc;
  34 import mir.storage.Database;
  35 import mir.util.HTTPRequestParser;
  36 import mir.util.URLBuilder;
  37 import mir.util.StringRoutines;
  38 import mircoders.global.MirGlobal;
  39 import mircoders.localizer.MirLocalizerExc;
  40 import mircoders.servlet.ServletHelper;
  41
  42 import javax.servlet.http.HttpServletRequest;
  43 import javax.servlet.http.HttpServletResponse;
  44 import java.util.Collections;
  45 import java.util.HashMap;
  46 import java.util.HashSet;
  47 import java.util.Iterator;
  48 import java.util.List;
  49 import java.util.Map;
  50 import java.util.Set;
  51 import java.io.IOException;
  52
  53 /**
  54  *
  55  */
  56
  57 public abstract class AdminServletModule extends ServletModule {
  58   protected AbstractModule mainModule;
  59   protected String definition;
  60   private EntityAdapterModel model;
  61
  62   protected String listGenerator;
  63   protected String editGenerator;
  64   protected String deleteConfirmationGenerator;
  65   protected int nrEntitiesPerListPage;
  66
  67   /** the list of parameters that need to be propagated in the list */
  68   private Set propagatedParameters = new HashSet();
  69
  70   protected void addPropagatedParameter(String aParameter) {
  71     propagatedParameters.add(aParameter);
  72   }
  73
  74   protected AdminServletModule(){
  75     addPropagatedParameter("searchfield");
  76     addPropagatedParameter("searchtext");
  77     addPropagatedParameter("searchispublished");
  78     addPropagatedParameter("searchstatus");
  79     addPropagatedParameter("searchorder");
  80
  81     definition = null;
  82     try {
  83       model = MirGlobal.localizer().dataModel().adapterModel();
  84     }
  85     catch (MirLocalizerExc e) {
  86       getLogger().error("Can't create model: " + e.toString());
  87
  88       throw new ServletModuleFailure("Can't retrieve model", e);
  89     }
  90
  91     listGenerator = getConfiguration().getString("ServletModule." + getName() + ".ListTemplate");
  92     editGenerator = getConfiguration().getString("ServletModule." + getName() + ".EditTemplate");
  93     deleteConfirmationGenerator = getConfiguration().getString("ServletModule." + getName() + ".DeleteConfirmationTemplate");
  94     nrEntitiesPerListPage =
  95         getConfiguration().getInt("ServletModule."+getName()+".ListSize",
  96         getConfiguration().getInt("ServletModule.Default.ListSize", 20));
  97
  98   }
  99
 100   protected EntityAdapterModel getModel() {
 101     return model;
 102   }
 103
 104   protected void logAdminUsage(HttpServletRequest aRequest, String anObject, String aDescription) {
 105     MirGlobal.logAdminUsage(ServletHelper.getUser(aRequest), getName() + ":" + anObject, aDescription);
 106   }
 107
 108   /**
 109    * Function to specify the default ordering for lists. May be overridden.
 110    */
 111   protected String getDefaultListOrdering() {
 112
 113     if (mainModule!=null && mainModule.getStorageObject()!=null &&
 114         mainModule.getStorageObject().hasField("webdb_create")) {
 115       return "webdb_create desc";
 116     }
 117     else {
 118       return "id asc";
 119     }
 120   }
 121
 122   /**
 123    * Generic list servlet method
 124    */
 125
 126   public void list(HttpServletRequest aRequest, HttpServletResponse aResponse) throws ServletModuleExc {
 127     HTTPRequestParser requestParser = new HTTPRequestParser(aRequest);
 128
 129     String where = requestParser.getParameter("where");
 130     String order = requestParser.getParameterWithDefault("order", getDefaultListOrdering());
 131     int offset = requestParser.getIntegerWithDefault("offset", 0);
 132     String mainTablePrefix = requestParser.getParameter("mainTablePrefix");
 133     String extraTables = requestParser.getParameter("extraTables");
 134
 135     returnList(aRequest, aResponse, where, order, offset, Collections.EMPTY_MAP, mainTablePrefix, extraTables);
 136   }
 137
 138
 139   public void returnList(HttpServletRequest aRequest, HttpServletResponse aResponse,
 140                          String aWhereClause, String anOrderByClause, int anOffset) throws ServletModuleExc {
 141     returnList(aRequest, aResponse, aWhereClause, anOrderByClause, anOffset, Collections.EMPTY_MAP);
 142   }
 143
 144   public void returnList(HttpServletRequest aRequest, HttpServletResponse aResponse,
 145                          String aWhereClause, String anOrderByClause, int anOffset,
 146                          Map anOverridingRequestParameters) throws ServletModuleExc {
 147     returnList(aRequest, aResponse, aWhereClause, anOrderByClause, anOffset, anOverridingRequestParameters, "", null);
 148   }
 149   public void returnList(HttpServletRequest aRequest, HttpServletResponse aResponse,
 150                          String aWhereClause, String anOrderByClause, int anOffset,
 151                          Map anOverridingRequestParameters, String aMainTablePrefix, String someExtraTables) throws ServletModuleExc {
 152     HTTPRequestParser requestParser = new HTTPRequestParser(aRequest, anOverridingRequestParameters);
 153     URLBuilder urlBuilder = new URLBuilder();
 154
 155     try {
 156       Map responseData = ServletHelper.makeGenerationData(aRequest, aResponse, getLocales(aRequest));
 157
 158       List extraTables = null;
 159       if (someExtraTables!=null && someExtraTables.length() > 0) {
 160         extraTables = StringRoutines.splitString(someExtraTables, ",");
 161       }
 162
 163       List list =
 164          EntityAdapterEngine.retrieveAdapterList(model, definition, aMainTablePrefix, extraTables, aWhereClause, anOrderByClause, nrEntitiesPerListPage, anOffset);
 165
 166       responseData.put("nexturl", null);
 167       responseData.put("prevurl", null);
 168       responseData.put("module", getName());
 169
 170       urlBuilder.setValue("module", getName());
 171       urlBuilder.setValue("do", "list");
 172       urlBuilder.setValue("where", aWhereClause);
 173       urlBuilder.setValue("order", anOrderByClause);
 174       urlBuilder.setValue("extraTables", someExtraTables);
 175       urlBuilder.setValue("mainTablePrefix", aMainTablePrefix);
 176
 177
 178       urlBuilder.setValue("offset", anOffset);
 179       responseData.put("offset" , Integer.toString(anOffset));
 180       responseData.put("thisurl" , urlBuilder.getQuery());
 181
 182       propagateFields(requestParser, urlBuilder, responseData);
 183
 184       if (list.size()>=nrEntitiesPerListPage) {
 185         urlBuilder.setValue("offset", anOffset + nrEntitiesPerListPage);
 186         responseData.put("nexturl" , urlBuilder.getQuery());
 187       }
 188
 189       if (anOffset>0) {
 190         urlBuilder.setValue("offset", Math.max(anOffset - nrEntitiesPerListPage, 0));
 191         responseData.put("prevurl" , urlBuilder.getQuery());
 192       }
 193
 194       responseData.put("entities", list);
 195       responseData.put("from" , Integer.toString(anOffset+1));
 196       responseData.put("count", "?");
 197       responseData.put("to", Integer.toString(anOffset+list.size()-1));
 198
 199       ServletHelper.generateResponse(aResponse.getWriter(), responseData, listGenerator);
 200     }
 201     catch (Throwable e) {
 202       throw new ServletModuleFailure(e);
 203     }
 204   }
 205
 206   public void editObject(HttpServletRequest aRequest, HttpServletResponse aResponse, String anId) throws ServletModuleExc {
 207     try {
 208       editObject(aRequest, aResponse, model.makeEntityAdapter(definition, mainModule.getById(anId)), false, anId);
 209     }
 210     catch (Throwable t) {
 211       throw new ServletModuleFailure(t);
 212     }
 213   }
 214
 215   public void editObject(HttpServletRequest aRequest, HttpServletResponse aResponse, Object anObject, boolean anIsNew, String anId) throws ServletModuleExc {
 216     HTTPRequestParser requestParser = new HTTPRequestParser(aRequest);
 217     URLBuilder urlBuilder = new URLBuilder();
 218
 219     try {
 220       Map responseData = ServletHelper.makeGenerationData(aRequest, aResponse, getLocales(aRequest));
 221
 222       responseData.put("module", getName());
 223       responseData.put("entity", anObject);
 224       responseData.put("new", new Boolean(anIsNew));
 225
 226
 227       urlBuilder.setValue("module", getName());
 228       urlBuilder.setValue("returnurl", requestParser.getParameter("returnurl"));
 229       if (anIsNew) {
 230         urlBuilder.setValue("do", "add");
 231       }
 232       else {
 233         urlBuilder.setValue("id", anId);
 234         urlBuilder.setValue("do", "edit");
 235       }
 236       responseData.put("returnurl", requestParser.getParameter("returnurl"));
 237       responseData.put("thisurl", urlBuilder.getQuery());
 238
 239       ServletHelper.generateResponse(aResponse.getWriter(), responseData, editGenerator);
 240     }
 241     catch (Throwable e) {
 242       throw new ServletModuleFailure(e);
 243     }
 244   }
 245
 246   /**
 247    * Generic add servlet method
 248    */
 249   public void add(HttpServletRequest aRequest, HttpServletResponse aResponse)
 250       throws ServletModuleExc, ServletModuleUserExc, ServletModuleFailure  {
 251
 252     Map object = new HashMap();
 253
 254     Iterator i = mainModule.getStorageObject().getFieldNames().iterator();
 255
 256     while (i.hasNext()) {
 257       object.put(i.next(), "");
 258     }
 259
 260     initializeNewObject(object, aRequest, aResponse);
 261
 262     editObject(aRequest, aResponse, object, true, null);
 263   }
 264
 265   protected void initializeNewObject(Map aNewObject, HttpServletRequest aRequest, HttpServletResponse aResponse) {
 266   }
 267
 268   /**
 269    * Generic edit servlet method
 270    */
 271   public void edit(HttpServletRequest aRequest, HttpServletResponse aResponse) throws ServletModuleExc, ServletModuleUserExc, ServletModuleFailure  {
 272     edit(aRequest, aResponse, aRequest.getParameter("id"));
 273   }
 274
 275   /**
 276    */
 277   public void edit(HttpServletRequest aRequest, HttpServletResponse aResponse, String anIdentifier)
 278       throws ServletModuleExc, ServletModuleUserExc, ServletModuleFailure  {
 279     try {
 280       editObject(aRequest, aResponse, model.makeEntityAdapter(definition, mainModule.getById(anIdentifier)), false, anIdentifier);
 281     }
 282     catch (Throwable e) {
 283       throw new ServletModuleFailure(e);
 284     }
 285   }
 286
 287   /**
 288    * Generic update servlet method
 289    */
 290   public void update(HttpServletRequest aRequest, HttpServletResponse aResponse)
 291       throws ServletModuleExc, ServletModuleUserExc, ServletModuleFailure  {
 292     try {
 293       HTTPRequestParser requestParser = new HTTPRequestParser(aRequest);
 294
 295       String id = aRequest.getParameter("id");
 296       Map withValues = getIntersectingValues(aRequest, mainModule.getStorageObject());
 297       mainModule.set(withValues);
 298
 299       logAdminUsage(aRequest, id, "object modified");
 300
 301       String returnUrl = requestParser.getParameter("returnurl");
 302
 303       if (returnUrl!=null) {
 304         ServletHelper.redirect(aResponse, returnUrl);
 305       }
 306       else {
 307         edit(aRequest, aResponse, id);
 308       }
 309     }
 310     catch (Throwable e) {
 311       throw new ServletModuleFailure(e);
 312     }
 313   }
 314
 315   /**
 316    * Generic insert servlet method
 317    */
 318   public void insert(HttpServletRequest aRequest, HttpServletResponse aResponse)
 319       throws ServletModuleExc, ServletModuleUserExc, ServletModuleFailure  {
 320     try {
 321       HTTPRequestParser requestParser = new HTTPRequestParser(aRequest);
 322
 323       Map object = getIntersectingValues(aRequest, mainModule.getStorageObject());
 324
 325       String id = processInstertedObject(object, aRequest, aResponse);
 326
 327       logAdminUsage(aRequest, id, "object inserted");
 328
 329       String returnUrl = requestParser.getParameter("returnurl");
 330
 331       if (returnUrl!=null) {
 332         ServletHelper.redirect(aResponse, returnUrl);
 333       }
 334       else {
 335         edit(aRequest, aResponse, id);
 336       }
 337     }
 338     catch (Throwable e) {
 339       throw new ServletModuleFailure(e);
 340     }
 341   }
 342
 343   /**
 344    *
 345    */
 346   public String processInstertedObject(Map anObject, HttpServletRequest aRequest, HttpServletResponse aResponse) {
 347     try {
 348       return mainModule.add(anObject);
 349     }
 350     catch (ModuleExc t) {
 351       throw new ServletModuleFailure(t);
 352     }
 353   }
 354
 355   /**
 356    * Generic delete confirmation servlet method
 357    */
 358   public void confirmdelete(HttpServletRequest aRequest, HttpServletResponse aResponse) {
 359     try {
 360       String idParam = aRequest.getParameter("id");
 361       String confirmParam = aRequest.getParameter("confirm");
 362
 363       if (confirmParam != null && !"".equals(confirmParam)) {
 364         mainModule.deleteById(idParam);
 365         logAdminUsage(aRequest, idParam, "object deleted");
 366         ServletHelper.redirect(aResponse, aRequest.getParameter("okurl"));
 367       }
 368       else {
 369         ServletHelper.redirect(aResponse, aRequest.getParameter("cancelurl"));
 370       }
 371     }
 372     catch (Throwable t) {
 373       throw new ServletModuleFailure(t);
 374     }
 375   }
 376
 377   /**
 378    * Generic delete servlet method
 379    */
 380   public void delete(HttpServletRequest aRequest, HttpServletResponse aResponse)
 381       throws ServletModuleExc, ServletModuleUserExc, ServletModuleFailure  {
 382     String idParam = aRequest.getParameter("id");
 383
 384     if (idParam == null) {
 385       throw new ServletModuleExc("Invalid call to delete: no id supplied");
 386     }
 387
 388     Map responseData = ServletHelper.makeGenerationData(aRequest, aResponse, getLocales(aRequest));
 389
 390     responseData.put("module", getName());
 391     responseData.put("id", idParam);
 392     responseData.put("cancelurl", aRequest.getParameter("cancelurl"));
 393     responseData.put("okurl", aRequest.getParameter("okurl"));
 394
 395     try {
 396       ServletHelper.generateResponse(aResponse.getWriter(), responseData, deleteConfirmationGenerator);
 397     }
 398     catch (IOException e) {
 399       throw new ServletModuleFailure(e);
 400     }
 401   }
 402
 403   /**
 404    * Gets the fields from a httprequest and matches them with the metadata from
 405    * the database object. Returns the keys that match, with their values.
 406    *
 407    * @return Map with the values
 408    */
 409   public Map getIntersectingValues(HttpServletRequest aRequest, Database aDatabase)
 410       throws ServletModuleExc, ServletModuleFailure {
 411
 412     HTTPRequestParser parser = new HTTPRequestParser(aRequest);
 413
 414     List fields = aDatabase.getFieldNames();
 415
 416     Map result = new HashMap();
 417     for (int i = 0; i < fields.size(); i++) {
 418       String aField = (String) fields.get(i);
 419
 420       String aValue = parser.getParameter(aField);
 421       if (aValue != null) {
 422         result.put(aField, aValue);
 423       }
 424     }
 425
 426     return result;
 427   }
 428
 429   private void propagateFields(HTTPRequestParser aRequest, URLBuilder aUrlBuilder, Map aResponseData) {
 430     Iterator i = propagatedParameters.iterator();
 431     while (i.hasNext()) {
 432       String parameter = (String) i.next();
 433       String value = aRequest.getParameter(parameter);
 434       aUrlBuilder.setValue(parameter, value);
 435       aResponseData.put(parameter, value);
 436     }
 437   }
 438 }