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