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.Arrays;
  34 import java.util.GregorianCalendar;
  35 import java.util.HashMap;
  36 import java.util.HashSet;
  37 import java.util.Iterator;
  38 import java.util.List;
  39 import java.util.Map;
  40 import java.util.Set;
  41 import java.util.Vector;
  42
  43 import mir.entity.Entity;
  44 import mir.entity.adapter.EntityAdapter;
  45 import mir.log.LoggerWrapper;
  46 import mir.misc.StringUtil;
  47 import mir.storage.StorageObjectFailure;
  48 import mir.util.DateTimeFunctions;
  49 import mircoders.entity.EntityComment;
  50 import mircoders.entity.EntityContent;
  51 import mircoders.global.MirGlobal;
  52 import mircoders.localizer.MirAdminInterfaceLocalizer;
  53 import mircoders.localizer.MirLocalizerExc;
  54 import mircoders.localizer.MirLocalizerFailure;
  55 import mircoders.storage.DatabaseContent;
  56
  57
  58 public class MirBasicAdminInterfaceLocalizer implements MirAdminInterfaceLocalizer {
  59   private Vector simpleCommentOperations;
  60   private Vector simpleArticleOperations;
  61   private Map simpleCommentOperationsMap;
  62   private Map simpleArticleOperationsMap;
  63   protected static LoggerWrapper logger = new LoggerWrapper("Localizer.AdminInterface");;
  64
  65   public MirBasicAdminInterfaceLocalizer() throws MirLocalizerFailure, MirLocalizerExc {
  66
  67     simpleCommentOperations = new Vector();
  68     simpleArticleOperations = new Vector();
  69     simpleCommentOperationsMap = new HashMap();
  70     simpleArticleOperationsMap = new HashMap();
  71
  72     addSimpleArticleOperation(new ChangeArticleFieldOperation("newswire", "to_article_type", "0", "1", false));
  73     addSimpleArticleOperation(new ModifyArticleFieldOperation("unhide", "is_published", "1", false));
  74     addSimpleArticleOperation(new ModifyArticleFieldOperation("hide", "is_published", "0", false));
  75
  76     addSimpleCommentOperation(new ModifyCommentFieldOperation("unhide", "is_published", "1"));
  77     addSimpleCommentOperation(new ModifyCommentFieldOperation("hide", "is_published", "0"));
  78   }
  79
  80   public String getAdminPageGenerator(String aPage, Map aTemplateData, EntityAdapter aUser, String aDefault) {
  81     return aDefault;
  82   }
  83
  84   public String makePasswordDigest(String aPassword) {
  85     return aPassword;
  86   }
  87
  88   public void initializeArticle(Map anArticle) {
  89     anArticle.put("is_published", "0");
  90     anArticle.put("date", StringUtil.date2webdbDate(new GregorianCalendar()));
  91   };
  92
  93   public List simpleCommentOperations() {
  94     return simpleCommentOperations;
  95   };
  96
  97   public List simpleArticleOperations() {
  98     return simpleArticleOperations;
  99   };
 100
 101   public MirSimpleEntityOperation simpleArticleOperationForName(String aName) {
 102     return (MirSimpleEntityOperation) simpleArticleOperationsMap.get(aName);
 103   };
 104
 105   public MirSimpleEntityOperation simpleCommentOperationForName(String aName) {
 106     return (MirSimpleEntityOperation) simpleCommentOperationsMap.get(aName);
 107   };
 108
 109   public void removeSimpleArticleOperation(String aName) {
 110     simpleArticleOperations.remove(simpleArticleOperationsMap.get(aName));
 111     simpleArticleOperationsMap.remove(aName);
 112   }
 113
 114   public void addSimpleArticleOperation(MirSimpleEntityOperation anOperation) {
 115     removeSimpleArticleOperation(anOperation.getName());
 116     simpleArticleOperationsMap.put(anOperation.getName(), anOperation);
 117     simpleArticleOperations.add(anOperation);
 118   }
 119
 120   public void removeSimpleCommentOperation(String aName) {
 121     simpleCommentOperations.remove(simpleCommentOperationsMap.get(aName));
 122     simpleCommentOperationsMap.remove(aName);
 123   }
 124
 125   public void addSimpleCommentOperation(MirSimpleEntityOperation anOperation) {
 126     removeSimpleCommentOperation(anOperation.getName());
 127     simpleCommentOperationsMap.put(anOperation.getName(), anOperation);
 128     simpleCommentOperations.add(anOperation);
 129   }
 130
 131   protected abstract static class EntityModifyingOperation implements MirSimpleEntityOperation {
 132     private String name;
 133     private boolean logOperation;
 134
 135     protected EntityModifyingOperation(String aName, boolean aLogOperation) {
 136       name = aName;
 137       logOperation = aLogOperation;
 138     }
 139
 140     public String getName() {
 141       return name;
 142     };
 143
 144     public boolean isAvailable(EntityAdapter anEntity) {
 145       try {
 146         Entity entity = anEntity.getEntity();
 147         return isAvailable(entity);
 148       }
 149       catch (Throwable t) {
 150         return false;
 151       }
 152     };
 153
 154     public void perform(EntityAdapter aUser, EntityAdapter anEntity) throws MirLocalizerExc, MirLocalizerFailure {
 155       Entity entity = anEntity.getEntity();
 156       try {
 157         performModification(aUser, entity);
 158
 159         if (logOperation) {
 160           try {
 161             StringBuffer line = new StringBuffer();
 162
 163             line.append(DateTimeFunctions.advancedDateFormat(
 164                 MirGlobal.config().getString("Mir.DefaultDateTimeFormat"),
 165                 (new GregorianCalendar()).getTime(),
 166                 MirGlobal.config().getString("Mir.DefaultTimezone")));
 167             line.append(" ");
 168             if (aUser != null)
 169               line.append(aUser.get("login"));
 170             else
 171               line.append("unknown");
 172
 173             line.append(" ");
 174             line.append(getName());
 175             entity.appendLineToField("comment", line.toString());
 176           }
 177           catch (Throwable t) {
 178             logger.error("Error while trying to log an article operation: " + t.toString());
 179           }
 180         }
 181
 182         entity.update();
 183       }
 184       catch (Throwable t) {
 185         throw new MirLocalizerFailure(t);
 186       }
 187     };
 188
 189     protected abstract boolean isAvailable(Entity anEntity) throws StorageObjectFailure ;
 190     protected abstract void performModification(EntityAdapter aUser, Entity anEntity)  throws MirLocalizerExc, MirLocalizerFailure ;
 191   }
 192
 193   public static abstract class CommentModifyingOperation extends EntityModifyingOperation {
 194     public CommentModifyingOperation(String aName, boolean aLogOperation) {
 195       super(aName, aLogOperation);
 196     }
 197
 198     public CommentModifyingOperation(String aName) {
 199       this(aName, true);
 200     }
 201
 202     protected boolean isAvailable(Entity anEntity) throws StorageObjectFailure {
 203       return anEntity instanceof EntityComment && isAvailable((EntityComment) anEntity);
 204     }
 205
 206     protected void performModification(EntityAdapter aUser, Entity anEntity) throws StorageObjectFailure {
 207       performModification(aUser, (EntityComment) anEntity);
 208       DatabaseContent.getInstance().setUnproduced("id="+anEntity.getValue("to_media"));
 209     };
 210
 211     protected abstract boolean isAvailable(EntityComment aComment) throws StorageObjectFailure ;
 212     protected abstract void performModification(EntityAdapter aUser, EntityComment aComment) throws StorageObjectFailure ;
 213   }
 214
 215   public static abstract class ArticleModifyingOperation extends EntityModifyingOperation {
 216     public ArticleModifyingOperation(String aName, boolean aLogOperation) {
 217       super(aName, aLogOperation);
 218     }
 219
 220     protected boolean isAvailable(Entity anEntity) throws StorageObjectFailure {
 221       return anEntity instanceof EntityContent && isAvailable((EntityContent) anEntity);
 222     }
 223
 224     protected void performModification(EntityAdapter aUser, Entity anEntity) throws StorageObjectFailure {
 225       performModification(aUser, (EntityContent) anEntity);
 226       anEntity.setValueForProperty("is_produced", "0");
 227     };
 228
 229     protected abstract boolean isAvailable(EntityContent anArticle) throws StorageObjectFailure ;
 230     protected abstract void performModification(EntityAdapter aUser, EntityContent anArticle) throws StorageObjectFailure ;
 231   }
 232
 233   protected static class SetCommentFieldOperation extends CommentModifyingOperation {
 234     private String field;
 235     private String value;
 236
 237     public SetCommentFieldOperation(String aName, String aField, String aValue) {
 238       super(aName);
 239
 240       field = aField;
 241       value = aValue;
 242     }
 243
 244     protected boolean isAvailable(EntityComment aComment) {
 245       return true;
 246     }
 247
 248     protected void performModification(EntityAdapter aUser, EntityComment aComment) throws StorageObjectFailure {
 249       aComment.setValueForProperty(field, value);
 250     }
 251   }
 252
 253   protected static class SetCommentFieldsOperation extends CommentModifyingOperation {
 254     private Map values;
 255
 256     public SetCommentFieldsOperation(String aName, String aFields[], String aValues[]) throws MirLocalizerExc {
 257       super(aName);
 258
 259       values = new HashMap();
 260
 261       for (int i=0; i<aFields.length; i++)
 262         values.put(aFields[i], aValues[i]);
 263     }
 264
 265     protected boolean isAvailable(EntityComment aComment) {
 266       return true;
 267     }
 268
 269     protected void performModification(EntityAdapter aUser, EntityComment aComment) throws StorageObjectFailure {
 270       Iterator i = values.entrySet().iterator();
 271
 272       while (i.hasNext()) {
 273         Map.Entry entry = (Map.Entry) i.next();
 274         aComment.setValueForProperty((String) entry.getKey(), (String) entry.getValue());
 275       }
 276     }
 277   }
 278
 279
 280   protected static class ModifyCommentFieldOperation extends CommentModifyingOperation {
 281     private String field;
 282     private String value;
 283
 284     public ModifyCommentFieldOperation(String aName, String aField, String aValue) {
 285       super(aName);
 286
 287       field = aField;
 288       value = aValue;
 289     }
 290
 291     protected boolean isAvailable(EntityComment aComment) {
 292       return aComment.getValue(field) == null || !aComment.getValue(field).equals(value);
 293     }
 294
 295     protected void performModification(EntityAdapter aUser, EntityComment aComment) throws StorageObjectFailure {
 296       aComment.setValueForProperty(field, value);
 297     }
 298   }
 299
 300   protected static class SetArticleFieldOperation extends ArticleModifyingOperation {
 301     private String field;
 302     private String value;
 303
 304     public SetArticleFieldOperation(String aName, String aField, String aValue, boolean aLogOperation) {
 305       super(aName, aLogOperation);
 306
 307       field = aField;
 308       value = aValue;
 309     }
 310
 311     protected boolean isAvailable(EntityContent anArticle) {
 312       return true;
 313     }
 314
 315     protected void performModification(EntityAdapter aUser, EntityContent anArticle) throws StorageObjectFailure {
 316       anArticle.setValueForProperty(field, value);
 317     }
 318   }
 319
 320   protected static class ModifyArticleFieldOperation extends ArticleModifyingOperation {
 321     private String field;
 322     private String value;
 323
 324     public ModifyArticleFieldOperation(String aName, String aField, String aValue, boolean aLogOperation) {
 325       super(aName, aLogOperation);
 326
 327       field = aField;
 328       value = aValue;
 329     }
 330
 331     protected boolean isAvailable(EntityContent anArticle) {
 332       return anArticle.getValue(field) == null || !anArticle.getValue(field).equals(value);
 333     }
 334
 335     protected void performModification(EntityAdapter aUser, EntityContent anArticle) throws StorageObjectFailure {
 336       anArticle.setValueForProperty(field, value);
 337     }
 338   }
 339
 340   protected static class ChangeArticleFieldOperation extends ArticleModifyingOperation {
 341     private String field;
 342     private Set oldValues;
 343     private String newValue;
 344
 345     public ChangeArticleFieldOperation(String aName, String aField, String anOldValues[], String aNewValue, boolean aLogOperation) {
 346       super(aName, aLogOperation);
 347
 348       field = aField;
 349       newValue = aNewValue;
 350       oldValues = new HashSet(Arrays.asList(anOldValues));
 351     }
 352     public ChangeArticleFieldOperation(String aName, String aField, String anOldValue, String aNewValue, boolean aLogOperation) {
 353       this(aName, aField, new String[] {anOldValue}, aNewValue, aLogOperation);
 354     }
 355
 356     protected boolean isAvailable(EntityContent anArticle) {
 357       return anArticle.getValue(field) != null && oldValues.contains(anArticle.getValue(field));
 358     }
 359
 360     protected void performModification(EntityAdapter aUser, EntityContent anArticle) throws StorageObjectFailure {
 361       anArticle.setValueForProperty(field, newValue);
 362     }
 363   }
 364 }