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 ModifyCommentFieldOperation extends CommentModifyingOperation {
 240     private String field;
 241     private String value;
 242
 243     public ModifyCommentFieldOperation(String aName, String aField, String aValue) {
 244       super(aName);
 245
 246       field = aField;
 247       value = aValue;
 248     }
 249
 250     protected boolean isAvailable(EntityComment aComment) {
 251       return aComment.getValue(field) == null || !aComment.getValue(field).equals(value);
 252     }
 253
 254     protected void performModification(EntityAdapter aUser, EntityComment aComment) throws StorageObjectFailure {
 255       aComment.setValueForProperty(field, value);
 256     }
 257   }
 258
 259   protected static class SetArticleFieldOperation extends ArticleModifyingOperation {
 260     private String field;
 261     private String value;
 262
 263     public SetArticleFieldOperation(String aName, String aField, String aValue, boolean aLogOperation) {
 264       super(aName, aLogOperation);
 265
 266       field = aField;
 267       value = aValue;
 268     }
 269
 270     protected boolean isAvailable(EntityContent anArticle) {
 271       return true;
 272     }
 273
 274     protected void performModification(EntityAdapter aUser, EntityContent anArticle) throws StorageObjectFailure {
 275       anArticle.setValueForProperty(field, value);
 276     }
 277   }
 278
 279   protected static class ModifyArticleFieldOperation extends ArticleModifyingOperation {
 280     private String field;
 281     private String value;
 282
 283     public ModifyArticleFieldOperation(String aName, String aField, String aValue, boolean aLogOperation) {
 284       super(aName, aLogOperation);
 285
 286       field = aField;
 287       value = aValue;
 288     }
 289
 290     protected boolean isAvailable(EntityContent anArticle) {
 291       return anArticle.getValue(field) == null || !anArticle.getValue(field).equals(value);
 292     }
 293
 294     protected void performModification(EntityAdapter aUser, EntityContent anArticle) throws StorageObjectFailure {
 295       anArticle.setValueForProperty(field, value);
 296     }
 297   }
 298
 299   protected static class ChangeArticleFieldOperation extends ArticleModifyingOperation {
 300     private String field;
 301     private Set oldValues;
 302     private String newValue;
 303
 304     public ChangeArticleFieldOperation(String aName, String aField, String anOldValues[], String aNewValue, boolean aLogOperation) {
 305       super(aName, aLogOperation);
 306
 307       field = aField;
 308       newValue = aNewValue;
 309       oldValues = new HashSet(Arrays.asList(anOldValues));
 310     }
 311     public ChangeArticleFieldOperation(String aName, String aField, String anOldValue, String aNewValue, boolean aLogOperation) {
 312       this(aName, aField, new String[] {anOldValue}, aNewValue, aLogOperation);
 313     }
 314
 315     protected boolean isAvailable(EntityContent anArticle) {
 316       return anArticle.getValue(field) != null && oldValues.contains(anArticle.getValue(field));
 317     }
 318
 319     protected void performModification(EntityAdapter aUser, EntityContent anArticle) throws StorageObjectFailure {
 320       anArticle.setValueForProperty(field, newValue);
 321     }
 322   }
 323 }