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