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