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   /**
 207    * return a page allowing the user to edit an object
 208    *
 209    * @param aRequest
 210    * @param aResponse
 211    * @param anId   the id of the object that is being edited
 212    * @param aTemplate the template to use (or null to use the default template)
 213    * @throws ServletModuleExc
 214    */
 215   public void editObject(HttpServletRequest aRequest, HttpServletResponse aResponse, String anId, String aTemplate) throws ServletModuleExc {
 216     try {
 217       editObject(aRequest, aResponse, model.makeEntityAdapter(definition, mainModule.getById(anId)), aTemplate, false, anId);
 218     }
 219     catch (Throwable t) {
 220       throw new ServletModuleFailure(t);
 221     }
 222   }
 223
 224   /**
 225    * return a page allowing the user to edit an object
 226    */
 227   public void editObject(HttpServletRequest aRequest, HttpServletResponse aResponse, Object anObject,
 228                          String aTemplate, boolean anIsNew, String anId) throws ServletModuleExc {
 229     HTTPRequestParser requestParser = new HTTPRequestParser(aRequest);
 230     URLBuilder urlBuilder = new URLBuilder();
 231
 232     try {
 233       Map responseData = ServletHelper.makeGenerationData(aRequest, aResponse, getLocales(aRequest));
 234
 235       responseData.put("module", getName());
 236       responseData.put("entity", anObject);
 237       responseData.put("new", Boolean.valueOf(anIsNew));
 238
 239
 240       urlBuilder.setValue("module", getName());
 241       urlBuilder.setValue("returnurl", requestParser.getParameter("returnurl"));
 242       if (anIsNew) {
 243         urlBuilder.setValue("do", "add");
 244       }
 245       else {
 246         urlBuilder.setValue("id", anId);
 247         urlBuilder.setValue("do", "edit");
 248       }
 249       responseData.put("returnurl", requestParser.getParameter("returnurl"));
 250       responseData.put("thisurl", urlBuilder.getQuery());
 251
 252       if (aTemplate == null) {
 253         aTemplate = editGenerator;
 254       }
 255
 256       ServletHelper.generateResponse(aResponse.getWriter(), responseData, aTemplate);
 257     }
 258     catch (Throwable e) {
 259       throw new ServletModuleFailure(e);
 260     }
 261   }
 262
 263   /**
 264    * Generic add servlet method
 265    */
 266   public void add(HttpServletRequest aRequest, HttpServletResponse aResponse)
 267       throws ServletModuleExc, ServletModuleUserExc, ServletModuleFailure  {
 268
 269     Map object = new HashMap();
 270
 271     Iterator i = mainModule.getStorageObject().getFieldNames().iterator();
 272     while (i.hasNext()) {
 273       object.put(i.next(), "");
 274     }
 275
 276     initializeNewObject(object, aRequest, aResponse);
 277
 278     editObject(aRequest, aResponse, object, null, true, null);
 279   }
 280
 281   protected void initializeNewObject(Map aNewObject, HttpServletRequest aRequest, HttpServletResponse aResponse) {
 282   }
 283
 284   /**
 285    * Generic edit servlet method
 286    */
 287   public void edit(HttpServletRequest aRequest, HttpServletResponse aResponse) throws ServletModuleExc, ServletModuleUserExc, ServletModuleFailure  {
 288     edit(aRequest, aResponse, aRequest.getParameter("id"));
 289   }
 290
 291   /**
 292    */
 293   public void edit(HttpServletRequest aRequest, HttpServletResponse aResponse, String anIdentifier)
 294       throws ServletModuleExc, ServletModuleUserExc, ServletModuleFailure  {
 295
 296     try {
 297       editObject(aRequest, aResponse, model.makeEntityAdapter(definition, mainModule.getById(anIdentifier)), null, false, anIdentifier);
 298     }
 299     catch (Throwable e) {
 300       throw new ServletModuleFailure(e);
 301     }
 302   }
 303
 304   /**
 305    * Generic update servlet method
 306    */
 307   public void update(HttpServletRequest aRequest, HttpServletResponse aResponse)
 308       throws ServletModuleExc, ServletModuleUserExc, ServletModuleFailure  {
 309     try {
 310       HTTPRequestParser requestParser = new HTTPRequestParser(aRequest);
 311
 312       String id = aRequest.getParameter("id");
 313       Map withValues = getIntersectingValues(aRequest, mainModule.getStorageObject());
 314       mainModule.set(withValues);
 315
 316       logAdminUsage(aRequest, id, "object modified");
 317
 318       String returnUrl = requestParser.getParameter("returnurl");
 319
 320       if (returnUrl!=null) {
 321         ServletHelper.redirect(aResponse, returnUrl);
 322       }
 323       else {
 324         edit(aRequest, aResponse, id);
 325       }
 326     }
 327     catch (Throwable e) {
 328       throw new ServletModuleFailure(e);
 329     }
 330   }
 331
 332   /**
 333    * Generic insert servlet method
 334    */
 335   public void insert(HttpServletRequest aRequest, HttpServletResponse aResponse)
 336       throws ServletModuleExc, ServletModuleUserExc, ServletModuleFailure  {
 337     try {
 338       HTTPRequestParser requestParser = new HTTPRequestParser(aRequest);
 339
 340       Map object = getIntersectingValues(aRequest, mainModule.getStorageObject());
 341
 342       String id = processInstertedObject(object, aRequest, aResponse);
 343
 344       logAdminUsage(aRequest, id, "object inserted");
 345
 346       String returnUrl = requestParser.getParameter("returnurl");
 347
 348       if (returnUrl!=null) {
 349         ServletHelper.redirect(aResponse, returnUrl);
 350       }
 351       else {
 352         edit(aRequest, aResponse, id);
 353       }
 354     }
 355     catch (Throwable e) {
 356       throw new ServletModuleFailure(e);
 357     }
 358   }
 359
 360   /**
 361    *
 362    */
 363   public String processInstertedObject(Map anObject, HttpServletRequest aRequest, HttpServletResponse aResponse) {
 364     try {
 365       return mainModule.add(anObject);
 366     }
 367     catch (ModuleExc t) {
 368       throw new ServletModuleFailure(t);
 369     }
 370   }
 371
 372   /**
 373    * Generic delete confirmation servlet method
 374    */
 375   public void confirmdelete(HttpServletRequest aRequest, HttpServletResponse aResponse) {
 376     try {
 377       String idParam = aRequest.getParameter("id");
 378       String confirmParam = aRequest.getParameter("confirm");
 379
 380       if (confirmParam != null && !"".equals(confirmParam)) {
 381         mainModule.deleteById(idParam);
 382         logAdminUsage(aRequest, idParam, "object deleted");
 383         ServletHelper.redirect(aResponse, aRequest.getParameter("okurl"));
 384       }
 385       else {
 386         ServletHelper.redirect(aResponse, aRequest.getParameter("cancelurl"));
 387       }
 388     }
 389     catch (Throwable t) {
 390       throw new ServletModuleFailure(t);
 391     }
 392   }
 393
 394   /**
 395    * Generic delete servlet method
 396    */
 397   public void delete(HttpServletRequest aRequest, HttpServletResponse aResponse)
 398       throws ServletModuleExc, ServletModuleUserExc, ServletModuleFailure  {
 399     String idParam = aRequest.getParameter("id");
 400
 401     if (idParam == null) {
 402       throw new ServletModuleExc("Invalid call to delete: no id supplied");
 403     }
 404
 405     Map responseData = ServletHelper.makeGenerationData(aRequest, aResponse, getLocales(aRequest));
 406
 407     responseData.put("module", getName());
 408     responseData.put("id", idParam);
 409     responseData.put("cancelurl", aRequest.getParameter("cancelurl"));
 410     responseData.put("okurl", aRequest.getParameter("okurl"));
 411
 412     try {
 413       ServletHelper.generateResponse(aResponse.getWriter(), responseData, deleteConfirmationGenerator);
 414     }
 415     catch (IOException e) {
 416       throw new ServletModuleFailure(e);
 417     }
 418   }
 419
 420   /**
 421    * Gets the fields from a httprequest and matches them with the metadata from
 422    * the database object. Returns the keys that match, with their values.
 423    *
 424    * @return Map with the values
 425    */
 426   public Map getIntersectingValues(HttpServletRequest aRequest, Database aDatabase)
 427       throws ServletModuleExc, ServletModuleFailure {
 428
 429     HTTPRequestParser parser = new HTTPRequestParser(aRequest);
 430
 431     List fields = aDatabase.getFieldNames();
 432
 433     Map result = new HashMap();
 434     for (int i = 0; i < fields.size(); i++) {
 435       String aField = (String) fields.get(i);
 436
 437       String aValue = parser.getParameter(aField);
 438       if (aValue != null) {
 439         result.put(aField, aValue);
 440       }
 441     }
 442
 443     return result;
 444   }
 445
 446   private void propagateFields(HTTPRequestParser aRequest, URLBuilder aUrlBuilder, Map aResponseData) {
 447     Iterator i = propagatedParameters.iterator();
 448     while (i.hasNext()) {
 449       String parameter = (String) i.next();
 450       String value = aRequest.getParameter(parameter);
 451       aUrlBuilder.setValue(parameter, value);
 452       aResponseData.put(parameter, value);
 453     }
 454   }
 455 }