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 the com.oreilly.servlet library, any library
  22  * licensed under the Apache Software License, The Sun (tm) Java Advanced
  23  * Imaging library (JAI), The Sun JIMI library (or with modified versions of
  24  * the above that use the same license as the above), and distribute linked
  25  * combinations including the two.  You must obey the GNU General Public
  26  * License in all respects for all of the code used other than the above
  27  * mentioned libraries.  If you modify this file, you may extend this exception
  28  * to your version of the file, but you are not obligated to do so.  If you do
  29  * not wish to do so, delete this exception statement from your version.
  30  */
  31
  32 package mircoders.localizer.basic;
  33
  34 import java.text.SimpleDateFormat;
  35 import java.util.GregorianCalendar;
  36 import java.util.HashMap;
  37 import java.util.List;
  38 import java.util.Map;
  39 import java.util.Vector;
  40
  41 import mir.entity.Entity;
  42 import mir.entity.adapter.EntityAdapter;
  43 import mir.misc.StringUtil;
  44 import mir.storage.StorageObjectFailure;
  45 import mir.util.StringRoutines;
  46 import mircoders.entity.EntityComment;
  47 import mircoders.entity.EntityContent;
  48 import mircoders.localizer.MirAdminInterfaceLocalizer;
  49 import mircoders.localizer.MirLocalizerExc;
  50 import mircoders.localizer.MirLocalizerFailure;
  51 import mircoders.storage.DatabaseContent;
  52
  53
  54 public class MirBasicAdminInterfaceLocalizer implements MirAdminInterfaceLocalizer {
  55   private Vector simpleCommentOperations;
  56   private Vector simpleArticleOperations;
  57   private Map simpleCommentOperationsMap;
  58   private Map simpleArticleOperationsMap;
  59   private static SimpleDateFormat dateFormatter = new SimpleDateFormat("dd.MM.yyyy HH:mm");
  60
  61   public MirBasicAdminInterfaceLocalizer() throws MirLocalizerFailure, MirLocalizerExc {
  62     simpleCommentOperations = new Vector();
  63     simpleArticleOperations = new Vector();
  64     simpleCommentOperationsMap = new HashMap();
  65     simpleArticleOperationsMap = new HashMap();
  66
  67     addSimpleArticleOperation(new ChangeArticleFieldOperation("newswire", "to_article_type", "0", "1", false));
  68     addSimpleArticleOperation(new ModifyArticleFieldOperation("unhide", "is_published", "1", false));
  69     addSimpleArticleOperation(new ModifyArticleFieldOperation("hide", "is_published", "0", false));
  70
  71     addSimpleCommentOperation(new ModifyCommentFieldOperation("unhide", "is_published", "1"));
  72     addSimpleCommentOperation(new ModifyCommentFieldOperation("hide", "is_published", "0"));
  73   }
  74
  75   public String makePasswordDigest(String aPassword) {
  76     return aPassword;
  77   }
  78
  79   public void initializeArticle(Map anArticle) {
  80     anArticle.put("is_published", "0");
  81     anArticle.put("date", StringUtil.date2webdbDate(new GregorianCalendar()));
  82   };
  83
  84   public List simpleCommentOperations() {
  85     return simpleCommentOperations;
  86   };
  87
  88   public List simpleArticleOperations() {
  89     return simpleArticleOperations;
  90   };
  91
  92   public MirSimpleEntityOperation simpleArticleOperationForName(String aName) {
  93     return (MirSimpleEntityOperation) simpleArticleOperationsMap.get(aName);
  94   };
  95
  96   public MirSimpleEntityOperation simpleCommentOperationForName(String aName) {
  97     return (MirSimpleEntityOperation) simpleCommentOperationsMap.get(aName);
  98   };
  99
 100   public void removeSimpleArticleOperation(String aName) {
 101     simpleArticleOperations.remove(simpleArticleOperationsMap.get(aName));
 102     simpleArticleOperationsMap.remove(aName);
 103   }
 104
 105   public void addSimpleArticleOperation(MirSimpleEntityOperation anOperation) {
 106     removeSimpleArticleOperation(anOperation.getName());
 107     simpleArticleOperationsMap.put(anOperation.getName(), anOperation);
 108     simpleArticleOperations.add(anOperation);
 109   }
 110
 111   public void removeSimpleCommentOperation(String aName) {
 112     simpleCommentOperations.remove(simpleCommentOperationsMap.get(aName));
 113     simpleCommentOperationsMap.remove(aName);
 114   }
 115
 116   public void addSimpleCommentOperation(MirSimpleEntityOperation anOperation) {
 117     removeSimpleCommentOperation(anOperation.getName());
 118     simpleCommentOperationsMap.put(anOperation.getName(), anOperation);
 119     simpleCommentOperations.add(anOperation);
 120   }
 121
 122   protected abstract static class EntityModifyingOperation implements MirSimpleEntityOperation {
 123     private String name;
 124
 125     protected EntityModifyingOperation(String aName) {
 126       name = aName;
 127     }
 128
 129     public String getName() {
 130       return name;
 131     };
 132
 133     public boolean isAvailable(EntityAdapter anEntity) {
 134       try {
 135         Entity entity = anEntity.getEntity();
 136         return isAvailable(entity);
 137       }
 138       catch (Throwable t) {
 139         return false;
 140       }
 141     };
 142
 143     public void perform(EntityAdapter aUser, EntityAdapter anEntity) {
 144       Entity entity = anEntity.getEntity();
 145       try {
 146         performModification(aUser, entity);
 147         entity.update();
 148       }
 149       catch (Throwable t) {
 150       }
 151     };
 152
 153     protected abstract boolean isAvailable(Entity anEntity) throws StorageObjectFailure ;
 154     protected abstract void performModification(EntityAdapter aUser, Entity anEntity) throws StorageObjectFailure ;
 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 String oldValue;
 302     private String newValue;
 303
 304     public ChangeArticleFieldOperation(String aName, String aField, String anOldValue, String aNewValue, boolean aLogOperation) {
 305       super(aName, aLogOperation);
 306
 307       field = aField;
 308       newValue = aNewValue;
 309       oldValue = anOldValue;
 310     }
 311
 312     protected boolean isAvailable(EntityContent anArticle) {
 313       return anArticle.getValue(field) != null && anArticle.getValue(field).equals(oldValue);
 314     }
 315
 316     protected void performModification(EntityAdapter aUser, EntityContent anArticle) throws StorageObjectFailure {
 317       anArticle.setValueForProperty(field, newValue);
 318     }
 319   }
 320 }