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