source/mircoders/localizer/basic/MirBasicAdminInterfaceLocalizer.java

   1 /*
   2  * Copyright (C) 2001, 2002 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  * The Sun (tm) Java Advanced Imaging library (JAI), The Sun JIMI library
  23  * (or with modified versions of the above that use the same license as the above),
  24  * and distribute linked combinations including the two.  You must obey the
  25  * GNU General Public License in all respects for all of the code used other than
  26  * the above mentioned libraries.  If you modify this file, you may extend this
  27  * exception to your version of the file, but you are not obligated to do so.
  28  * If you do not wish to do so, delete this exception statement from your version.
  29  */
  30
  31 package mircoders.localizer.basic;
  32
  33 import mir.bundle.Bundle;
  34 import mir.config.MirPropertiesConfiguration;
  35 import mir.entity.Entity;
  36 import mir.entity.adapter.EntityAdapter;
  37 import mir.entity.adapter.EntityAdapterExc;
  38 import mir.generator.Generator;
  39 import mir.generator.GeneratorExc;
  40 import mir.log.LoggerWrapper;
  41 import mir.misc.StringUtil;
  42 import mir.module.ModuleExc;
  43 import mir.storage.StorageObjectFailure;
  44 import mir.util.DateTimeFunctions;
  45 import mir.util.EntityUtility;
  46 import mir.util.StringRoutines;
  47 import mir.util.generator.BundleGeneratorFunction;
  48 import mircoders.entity.EntityComment;
  49 import mircoders.entity.EntityContent;
  50 import mircoders.global.MirGlobal;
  51 import mircoders.localizer.MirAdminInterfaceLocalizer;
  52 import mircoders.localizer.MirLocalizerExc;
  53 import mircoders.localizer.MirLocalizerFailure;
  54 import mircoders.module.ModuleLanguage;
  55 import mircoders.storage.DatabaseContent;
  56
  57 import java.util.*;
  58
  59
  60 public class MirBasicAdminInterfaceLocalizer implements MirAdminInterfaceLocalizer {
  61   /** preview page name (String) -> generator name (String) */
  62   private Map previewPages;
  63   private List previewPageNames;
  64
  65   private List simpleCommentOperations;
  66   private List simpleArticleOperations;
  67   private Map simpleCommentOperationsMap;
  68   private Map simpleArticleOperationsMap;
  69
  70   protected static LoggerWrapper logger = new LoggerWrapper("Localizer.AdminInterface");;
  71   protected MirPropertiesConfiguration configuration = MirPropertiesConfiguration.instance();
  72
  73   public MirBasicAdminInterfaceLocalizer() throws MirLocalizerFailure {
  74
  75     simpleCommentOperations = new ArrayList();
  76     simpleArticleOperations = new ArrayList();
  77     simpleCommentOperationsMap = new HashMap();
  78     simpleArticleOperationsMap = new HashMap();
  79
  80     previewPages = new HashMap();
  81     previewPageNames = new ArrayList();
  82
  83     String[] previewConfiguration = configuration.getStringArray("Mir.Localizer.Admin.ArticlePreview");
  84
  85     for (int i = 0; i<previewConfiguration.length; i++) {
  86       try {
  87         List parts = StringRoutines.separateString(previewConfiguration[i], "=");
  88         if (parts.size() == 2) {
  89           String key = ((String) parts.get(0)).trim();
  90           previewPages.put(key,((String) parts.get(1)).trim());
  91           previewPageNames.add(key);
  92         }
  93         else {
  94           throw new Exception("'=' expected");
  95         }
  96       }
  97       catch (Exception e) {
  98         logger.error("Error while processing preview configuration '" + previewConfiguration[i] + "': " + e.toString());
  99       }
 100     }
 101
 102     addSimpleArticleOperation(new ChangeArticleFieldOperation("newswire", "to_article_type", "0", "1", false));
 103     addSimpleArticleOperation(new ModifyArticleFieldOperation("unhide", "is_published", "1", false));
 104     addSimpleArticleOperation(new ModifyArticleFieldOperation("hide", "is_published", "0", false));
 105
 106     addSimpleCommentOperation(new ModifyCommentFieldOperation("unhide", "is_published", "1"));
 107     addSimpleCommentOperation(new ModifyCommentFieldOperation("hide", "is_published", "0"));
 108   }
 109
 110   /** {@inheritDoc} */
 111   public String getAdminPageGenerator(String aPage, Map aTemplateData, EntityAdapter aUser, String aDefault) throws MirLocalizerExc {
 112     return aDefault;
 113   }
 114
 115   /** {@inheritDoc} */
 116   public Generator prepareArticlePreview(String aPreviewPage, EntityAdapter anArticle, Map aContext) throws MirLocalizerExc {
 117     MirGlobal.localizer().producerAssistant().initializeGenerationValueSet(aContext);
 118     aContext.put("article", anArticle);
 119
 120
 121     try {
 122       aContext.put(
 123           "language",
 124           MirGlobal.localizer().dataModel().adapterModel().makeEntityAdapter("language",
 125               new ModuleLanguage().languageForCode(configuration.getString("Mir.Localizer.Admin.ArticlePreviewLanguage"))));
 126     }
 127     catch (EntityAdapterExc e) {
 128       throw new MirLocalizerFailure("Can't create entity adapter", e);
 129     }
 130     catch (ModuleExc e) {
 131       throw new MirLocalizerFailure("Can't find language", e);
 132     }
 133     aContext.put("pathprefix", configuration.getString("Mir.Localizer.Admin.ArticlePreviewLanguage"));
 134
 135     aContext.put("lang",
 136         new BundleGeneratorFunction(
 137             new Bundle[] {
 138               MirGlobal.getBundleFactory().getBundle(
 139                   "etc/bundles/producer",
 140                   new String[] {
 141                     configuration.getString("Mir.Localizer.Admin.ArticlePreviewLanguage") }) }));
 142
 143
 144     if (previewPages.containsKey(aPreviewPage)) {
 145       try {
 146         return MirGlobal.localizer().generators().makeAdminGeneratorLibrary().makeGenerator((String) previewPages.get(aPreviewPage));
 147       }
 148       catch (GeneratorExc e) {
 149         throw new MirLocalizerFailure(e);
 150       }
 151     }
 152     else {
 153       throw new MirLocalizerExc("Unknown preview: " + aPreviewPage);
 154     }
 155   }
 156
 157   /** {@inheritDoc} */
 158   public List getPreviewPages(EntityAdapter anArticle) throws MirLocalizerExc{
 159     return Collections.unmodifiableList(previewPageNames);
 160   }
 161
 162   /** {@inheritDoc} */
 163   public String makePasswordDigest(String aPassword) {
 164     return aPassword;
 165   }
 166
 167   public void initializeArticle(Map anArticle) {
 168     anArticle.put("is_published", "0");
 169     anArticle.put("date", StringUtil.date2webdbDate(new GregorianCalendar()));
 170   };
 171
 172   public List simpleCommentOperations() {
 173     return Collections.unmodifiableList(simpleCommentOperations);
 174   };
 175
 176   public List simpleArticleOperations() {
 177     return Collections.unmodifiableList(simpleArticleOperations);
 178   };
 179
 180   public MirSimpleEntityOperation simpleArticleOperationForName(String aName) {
 181     return (MirSimpleEntityOperation) simpleArticleOperationsMap.get(aName);
 182   };
 183
 184   public MirSimpleEntityOperation simpleCommentOperationForName(String aName) {
 185     return (MirSimpleEntityOperation) simpleCommentOperationsMap.get(aName);
 186   };
 187
 188   public void removeSimpleArticleOperation(String aName) {
 189     simpleArticleOperations.remove(simpleArticleOperationsMap.get(aName));
 190     simpleArticleOperationsMap.remove(aName);
 191   }
 192
 193   public void addSimpleArticleOperation(MirSimpleEntityOperation anOperation) {
 194     removeSimpleArticleOperation(anOperation.getName());
 195     simpleArticleOperationsMap.put(anOperation.getName(), anOperation);
 196     simpleArticleOperations.add(anOperation);
 197   }
 198
 199   public void removeSimpleCommentOperation(String aName) {
 200     simpleCommentOperations.remove(simpleCommentOperationsMap.get(aName));
 201     simpleCommentOperationsMap.remove(aName);
 202   }
 203
 204   public void addSimpleCommentOperation(MirSimpleEntityOperation anOperation) {
 205     removeSimpleCommentOperation(anOperation.getName());
 206     simpleCommentOperationsMap.put(anOperation.getName(), anOperation);
 207     simpleCommentOperations.add(anOperation);
 208   }
 209
 210   protected abstract static class EntityModifyingOperation implements MirSimpleEntityOperation {
 211     private String name;
 212     private boolean logOperation;
 213
 214     protected EntityModifyingOperation(String aName, boolean aLogOperation) {
 215       name = aName;
 216       logOperation = aLogOperation;
 217     }
 218
 219     public String getName() {
 220       return name;
 221     };
 222
 223     public boolean isAvailable(EntityAdapter anEntity) {
 224       try {
 225         Entity entity = anEntity.getEntity();
 226         return isAvailable(entity);
 227       }
 228       catch (Throwable t) {
 229         return false;
 230       }
 231     };
 232
 233     public void perform(EntityAdapter aUser, EntityAdapter anEntity) throws MirLocalizerExc, MirLocalizerFailure {
 234       Entity entity = anEntity.getEntity();
 235       try {
 236         performModification(aUser, entity);
 237
 238         if (logOperation) {
 239           try {
 240             StringBuffer line = new StringBuffer();
 241
 242             line.append(DateTimeFunctions.advancedDateFormat(
 243                 MirGlobal.config().getString("Mir.DefaultDateTimeFormat"),
 244                 (new GregorianCalendar()).getTime(),
 245                 MirGlobal.config().getString("Mir.DefaultTimezone")));
 246             line.append(" ");
 247             if (aUser != null)
 248               line.append(aUser.get("login"));
 249             else
 250               line.append("unknown");
 251
 252             line.append(" ");
 253             line.append(getName());
 254             EntityUtility.appendLineToField(entity, "comment", line.toString());
 255           }
 256           catch (Throwable t) {
 257             logger.error("Error while trying to log an article operation: " + t.toString());
 258           }
 259         }
 260
 261         entity.update();
 262       }
 263       catch (Throwable t) {
 264         throw new MirLocalizerFailure(t);
 265       }
 266     };
 267
 268     protected abstract boolean isAvailable(Entity anEntity) throws StorageObjectFailure ;
 269     protected abstract void performModification(EntityAdapter aUser, Entity anEntity)  throws MirLocalizerExc, MirLocalizerFailure ;
 270   }
 271
 272   public static abstract class CommentModifyingOperation extends EntityModifyingOperation {
 273     public CommentModifyingOperation(String aName, boolean aLogOperation) {
 274       super(aName, aLogOperation);
 275     }
 276
 277     public CommentModifyingOperation(String aName) {
 278       this(aName, true);
 279     }
 280
 281     protected boolean isAvailable(Entity anEntity) throws StorageObjectFailure {
 282       return anEntity instanceof EntityComment && isAvailable((EntityComment) anEntity);
 283     }
 284
 285     protected void performModification(EntityAdapter aUser, Entity anEntity) throws StorageObjectFailure {
 286       performModification(aUser, (EntityComment) anEntity);
 287       DatabaseContent.getInstance().setUnproduced("id="+anEntity.getFieldValue("to_media"));
 288     };
 289
 290     protected abstract boolean isAvailable(EntityComment aComment) throws StorageObjectFailure ;
 291     protected abstract void performModification(EntityAdapter aUser, EntityComment aComment) throws StorageObjectFailure ;
 292   }
 293
 294   public static abstract class ArticleModifyingOperation extends EntityModifyingOperation {
 295     public ArticleModifyingOperation(String aName, boolean aLogOperation) {
 296       super(aName, aLogOperation);
 297     }
 298
 299     protected boolean isAvailable(Entity anEntity) throws StorageObjectFailure {
 300       return anEntity instanceof EntityContent && isAvailable((EntityContent) anEntity);
 301     }
 302
 303     protected void performModification(EntityAdapter aUser, Entity anEntity) throws StorageObjectFailure {
 304       performModification(aUser, (EntityContent) anEntity);
 305       anEntity.setFieldValue("is_produced", "0");
 306     };
 307
 308     protected abstract boolean isAvailable(EntityContent anArticle) throws StorageObjectFailure ;
 309     protected abstract void performModification(EntityAdapter aUser, EntityContent anArticle) throws StorageObjectFailure ;
 310   }
 311
 312   protected static class SetCommentFieldOperation extends CommentModifyingOperation {
 313     private String field;
 314     private String value;
 315
 316     public SetCommentFieldOperation(String aName, String aField, String aValue) {
 317       super(aName);
 318
 319       field = aField;
 320       value = aValue;
 321     }
 322
 323     protected boolean isAvailable(EntityComment aComment) {
 324       return true;
 325     }
 326
 327     protected void performModification(EntityAdapter aUser, EntityComment aComment) throws StorageObjectFailure {
 328       aComment.setFieldValue(field, value);
 329     }
 330   }
 331
 332   protected static class SetCommentFieldsOperation extends CommentModifyingOperation {
 333     private Map values;
 334
 335     public SetCommentFieldsOperation(String aName, String aFields[], String aValues[]) {
 336       super(aName);
 337
 338       values = new HashMap();
 339
 340       for (int i=0; i<aFields.length; i++)
 341         values.put(aFields[i], aValues[i]);
 342     }
 343
 344     protected boolean isAvailable(EntityComment aComment) {
 345       return true;
 346     }
 347
 348     protected void performModification(EntityAdapter aUser, EntityComment aComment) throws StorageObjectFailure {
 349       Iterator i = values.entrySet().iterator();
 350
 351       while (i.hasNext()) {
 352         Map.Entry entry = (Map.Entry) i.next();
 353         aComment.setFieldValue((String) entry.getKey(), (String) entry.getValue());
 354       }
 355     }
 356   }
 357
 358
 359   protected static class ModifyCommentFieldOperation extends CommentModifyingOperation {
 360     private String field;
 361     private String value;
 362
 363     public ModifyCommentFieldOperation(String aName, String aField, String aValue) {
 364       super(aName);
 365
 366       field = aField;
 367       value = aValue;
 368     }
 369
 370     protected boolean isAvailable(EntityComment aComment) {
 371       return aComment.getFieldValue(field) == null || !aComment.getFieldValue(field).equals(value);
 372     }
 373
 374     protected void performModification(EntityAdapter aUser, EntityComment aComment) throws StorageObjectFailure {
 375       aComment.setFieldValue(field, value);
 376     }
 377   }
 378
 379   protected static class SetArticleFieldOperation extends ArticleModifyingOperation {
 380     private String field;
 381     private String value;
 382
 383     public SetArticleFieldOperation(String aName, String aField, String aValue, boolean aLogOperation) {
 384       super(aName, aLogOperation);
 385
 386       field = aField;
 387       value = aValue;
 388     }
 389
 390     protected boolean isAvailable(EntityContent anArticle) {
 391       return true;
 392     }
 393
 394     protected void performModification(EntityAdapter aUser, EntityContent anArticle) throws StorageObjectFailure {
 395       anArticle.setFieldValue(field, value);
 396     }
 397   }
 398
 399   protected static class ModifyArticleFieldOperation extends ArticleModifyingOperation {
 400     private String field;
 401     private String value;
 402
 403     public ModifyArticleFieldOperation(String aName, String aField, String aValue, boolean aLogOperation) {
 404       super(aName, aLogOperation);
 405
 406       field = aField;
 407       value = aValue;
 408     }
 409
 410     protected boolean isAvailable(EntityContent anArticle) {
 411       return anArticle.getFieldValue(field) == null || !anArticle.getFieldValue(field).equals(value);
 412     }
 413
 414     protected void performModification(EntityAdapter aUser, EntityContent anArticle) throws StorageObjectFailure {
 415       anArticle.setFieldValue(field, value);
 416     }
 417   }
 418
 419   protected static class ChangeArticleFieldOperation extends ArticleModifyingOperation {
 420     private String field;
 421     private Set oldValues;
 422     private String newValue;
 423
 424     public ChangeArticleFieldOperation(String aName, String aField, String anOldValues[], String aNewValue, boolean aLogOperation) {
 425       super(aName, aLogOperation);
 426
 427       field = aField;
 428       newValue = aNewValue;
 429       oldValues = new HashSet(Arrays.asList(anOldValues));
 430     }
 431     public ChangeArticleFieldOperation(String aName, String aField, String anOldValue, String aNewValue, boolean aLogOperation) {
 432       this(aName, aField, new String[] {anOldValue}, aNewValue, aLogOperation);
 433     }
 434
 435     protected boolean isAvailable(EntityContent anArticle) {
 436       return anArticle.getFieldValue(field) != null && oldValues.contains(anArticle.getFieldValue(field));
 437     }
 438
 439     protected void performModification(EntityAdapter aUser, EntityContent anArticle) throws StorageObjectFailure {
 440       anArticle.setFieldValue(field, newValue);
 441     }
 442   }
 443 }