source/mircoders/localizer/basic/MirBasicDataModelLocalizer.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.util.HashMap;
  35 import java.util.Iterator;
  36 import java.util.List;
  37 import java.util.Map;
  38 import java.util.Vector;
  39
  40 import mir.entity.Entity;
  41 import mir.entity.adapter.EntityAdapter;
  42 import mir.entity.adapter.EntityAdapterDefinition;
  43 import mir.entity.adapter.EntityAdapterModel;
  44 import mir.log.LoggerWrapper;
  45 import mir.media.MediaHelper;
  46 import mir.media.MirMedia;
  47 import mir.util.RewindableIterator;
  48 import mircoders.entity.EntityUploadedMedia;
  49 import mircoders.global.MirGlobal;
  50 import mircoders.localizer.MirAdminInterfaceLocalizer;
  51 import mircoders.localizer.MirDataModelLocalizer;
  52 import mircoders.localizer.MirLocalizerFailure;
  53 import mircoders.storage.DatabaseArticleType;
  54 import mircoders.storage.DatabaseAudio;
  55 import mircoders.storage.DatabaseBreaking;
  56 import mircoders.storage.DatabaseComment;
  57 import mircoders.storage.DatabaseCommentStatus;
  58 import mircoders.storage.DatabaseContent;
  59 import mircoders.storage.DatabaseImageType;
  60 import mircoders.storage.DatabaseImages;
  61 import mircoders.storage.DatabaseLanguage;
  62 import mircoders.storage.DatabaseMedia;
  63 import mircoders.storage.DatabaseMediaType;
  64 import mircoders.storage.DatabaseMediafolder;
  65 import mircoders.storage.DatabaseMessages;
  66 import mircoders.storage.DatabaseOther;
  67 import mircoders.storage.DatabaseTopics;
  68 import mircoders.storage.DatabaseUploadedMedia;
  69 import mircoders.storage.DatabaseUsers;
  70 import mircoders.storage.DatabaseVideo;
  71
  72 public class MirBasicDataModelLocalizer implements MirDataModelLocalizer {
  73   private EntityAdapterModel model;
  74   protected LoggerWrapper logger;
  75
  76   public MirBasicDataModelLocalizer() {
  77     model=null;
  78     logger = new LoggerWrapper("Localizer.DataModel");
  79   }
  80
  81   public EntityAdapterModel adapterModel() throws MirLocalizerFailure {
  82     if (model==null)
  83       model = buildModel();
  84
  85     return model;
  86   };
  87
  88   protected void constructContentAdapterDefinition(EntityAdapterDefinition anEntityAdapterDefinition) throws MirLocalizerFailure {
  89     try {
  90       anEntityAdapterDefinition.addDBDateField("creationdate", "webdb_create");
  91       anEntityAdapterDefinition.addDBDateField("changedate", "webdb_lastchange");
  92       anEntityAdapterDefinition.addMirDateField("date", "date");
  93       anEntityAdapterDefinition.addCalculatedField("to_topics", new ContentToTopicsField());
  94       anEntityAdapterDefinition.addCalculatedField("to_comments", new ContentToCommentsField());
  95       anEntityAdapterDefinition.addCalculatedField("language", new ContentToLanguageField());
  96
  97       anEntityAdapterDefinition.addCalculatedField("commentcount", new ContentCommentCountField(" and is_published='1'"));
  98       anEntityAdapterDefinition.addCalculatedField("fullcommentcount", new ContentCommentCountField(""));
  99
 100       anEntityAdapterDefinition.addCalculatedField("to_uploaded_media", new ContentToMediaField( "uploadedMedia" ));
 101       anEntityAdapterDefinition.addCalculatedField("to_media_images",  new ContentToMediaField( "image" ));
 102       anEntityAdapterDefinition.addCalculatedField("to_media_audio", new ContentToMediaField( "audio" ));
 103       anEntityAdapterDefinition.addCalculatedField("to_media_video", new ContentToMediaField( "video" ));
 104       anEntityAdapterDefinition.addCalculatedField("to_media_other", new ContentToMediaField( "otherMedia" ));
 105       anEntityAdapterDefinition.addCalculatedField("to_all_uploaded_media", new ContentToMediaField( "uploadedMedia", false));
 106       anEntityAdapterDefinition.addCalculatedField("to_all_media_images",  new ContentToMediaField( "image", false));
 107       anEntityAdapterDefinition.addCalculatedField("to_all_media_audio", new ContentToMediaField( "audio", false));
 108       anEntityAdapterDefinition.addCalculatedField("to_all_media_video", new ContentToMediaField( "video", false));
 109       anEntityAdapterDefinition.addCalculatedField("to_all_media_other", new ContentToMediaField( "otherMedia", false));
 110       anEntityAdapterDefinition.addCalculatedField("to_media_icon", new ContentToIconField());
 111
 112       anEntityAdapterDefinition.addCalculatedField("article_type", new ContentToArticleTypeField());
 113
 114       anEntityAdapterDefinition.addCalculatedField("description_parsed", new FilteredField("description"));
 115       anEntityAdapterDefinition.addCalculatedField("content_data_parsed", new FilteredField("content_data"));
 116
 117       anEntityAdapterDefinition.addCalculatedField("children", new ContentToChildrenField());
 118       anEntityAdapterDefinition.addCalculatedField("parent", new ContentToParentField());
 119
 120       anEntityAdapterDefinition.addCalculatedField("operations",
 121           new EntityToSimpleOperationsField(MirGlobal.localizer().adminInterface().simpleArticleOperations()));
 122     }
 123     catch (Throwable t) {
 124       throw new MirLocalizerFailure(t.getMessage(), t);
 125     }
 126   }
 127
 128   protected void constructCommentAdapterDefinition(EntityAdapterDefinition anEntityAdapterDefinition) throws MirLocalizerFailure {
 129     try {
 130       anEntityAdapterDefinition.addDBDateField("creationdate", "webdb_create");
 131       anEntityAdapterDefinition.addCalculatedField("to_content", new CommentToContentField());
 132       anEntityAdapterDefinition.addCalculatedField("status", new CommentToStatusField());
 133
 134       anEntityAdapterDefinition.addCalculatedField("to_uploaded_media", new CommentToMediaField( "uploadedMedia" ));
 135       anEntityAdapterDefinition.addCalculatedField("to_media_images",  new CommentToMediaField( "image" ));
 136       anEntityAdapterDefinition.addCalculatedField("to_media_audio", new CommentToMediaField( "audio" ));
 137       anEntityAdapterDefinition.addCalculatedField("to_media_video", new CommentToMediaField( "video" ));
 138       anEntityAdapterDefinition.addCalculatedField("to_media_other", new CommentToMediaField( "otherMedia" ));
 139       anEntityAdapterDefinition.addCalculatedField("to_all_uploaded_media", new CommentToMediaField( "uploadedMedia", false));
 140       anEntityAdapterDefinition.addCalculatedField("to_all_media_images",  new CommentToMediaField( "image", false));
 141       anEntityAdapterDefinition.addCalculatedField("to_all_media_audio", new CommentToMediaField( "audio", false));
 142       anEntityAdapterDefinition.addCalculatedField("to_all_media_video", new CommentToMediaField( "video", false));
 143       anEntityAdapterDefinition.addCalculatedField("to_all_media_other", new CommentToMediaField( "otherMedia", false));
 144
 145       anEntityAdapterDefinition.addCalculatedField("description_parsed", new FilteredField("description"));
 146       anEntityAdapterDefinition.addCalculatedField("operations",
 147           new EntityToSimpleOperationsField(MirGlobal.localizer().adminInterface().simpleCommentOperations()));
 148     }
 149     catch (Throwable t) {
 150       throw new MirLocalizerFailure(t.getMessage(), t);
 151     }
 152   }
 153
 154   protected EntityAdapterModel buildModel() throws MirLocalizerFailure {
 155     EntityAdapterModel result = new EntityAdapterModel();
 156
 157     try {
 158       EntityAdapterDefinition definition;
 159
 160       definition = new EntityAdapterDefinition();
 161       constructContentAdapterDefinition( definition );
 162       result.addMapping( "content", DatabaseContent.getInstance(), definition);
 163
 164       definition = new EntityAdapterDefinition();
 165       constructCommentAdapterDefinition( definition );
 166       result.addMapping( "comment", DatabaseComment.getInstance(), definition);
 167
 168       result.addMapping( "articleType", DatabaseArticleType.getInstance(), new EntityAdapterDefinition());
 169       result.addMapping( "commentStatus", DatabaseCommentStatus.getInstance(), new EntityAdapterDefinition());
 170
 171       definition = new EntityAdapterDefinition();
 172       definition.addDBDateField("creationdate", "webdb_create");
 173       result.addMapping( "breakingNews", DatabaseBreaking.getInstance(), definition);
 174
 175       result.addMapping( "imageType", DatabaseImageType.getInstance(), new EntityAdapterDefinition());
 176       result.addMapping( "language", DatabaseLanguage.getInstance(), new EntityAdapterDefinition());
 177       result.addMapping( "mediaFolder", DatabaseMediafolder.getInstance(), new EntityAdapterDefinition());
 178       result.addMapping( "mediaType", DatabaseMediaType.getInstance(), new EntityAdapterDefinition());
 179       result.addMapping( "internalMessage", DatabaseMessages.getInstance(), new EntityAdapterDefinition());
 180       result.addMapping( "topic", DatabaseTopics.getInstance(), new EntityAdapterDefinition());
 181       result.addMapping( "user", DatabaseUsers.getInstance(), new EntityAdapterDefinition());
 182       result.addMapping( "media", DatabaseMedia.getInstance(), new EntityAdapterDefinition());
 183       result.addMapping( "uploadedMedia", DatabaseUploadedMedia.getInstance(), new EntityAdapterDefinition());
 184       result.addMapping( "image", DatabaseImages.getInstance(), new EntityAdapterDefinition());
 185       result.addMapping( "audio", DatabaseAudio.getInstance(), new EntityAdapterDefinition());
 186       result.addMapping( "video", DatabaseVideo.getInstance(), new EntityAdapterDefinition());
 187       result.addMapping( "otherMedia", DatabaseOther.getInstance(), new EntityAdapterDefinition());
 188     }
 189     catch (Throwable t) {
 190       throw new MirLocalizerFailure(t.getMessage(), t);
 191     }
 192
 193     return result;
 194   }
 195
 196   protected class CommentToContentField implements EntityAdapterDefinition.CalculatedField {
 197     public Object getValue(EntityAdapter anEntityAdapter) {
 198       try {
 199         return anEntityAdapter.getToOneRelation(
 200                     "id="+anEntityAdapter.get("to_media"),
 201                     "id",
 202                     "content" );
 203       }
 204       catch (Throwable t) {
 205         throw new RuntimeException(t.getMessage());
 206       }
 207     }
 208   }
 209
 210   protected class CommentToStatusField implements EntityAdapterDefinition.CalculatedField {
 211     public Object getValue(EntityAdapter anEntityAdapter) {
 212       try {
 213         return anEntityAdapter.getToOneRelation(
 214                     "id="+anEntityAdapter.get("to_comment_status"),
 215                     "id",
 216                     "commentStatus" );
 217       }
 218       catch (Throwable t) {
 219         throw new RuntimeException(t.getMessage());
 220       }
 221     }
 222   }
 223
 224   protected class EntityToSimpleOperationsField implements EntityAdapterDefinition.CalculatedField {
 225     private List operations;
 226
 227     public EntityToSimpleOperationsField(List anOperations) {
 228       operations = anOperations;
 229     }
 230
 231     public Object getValue(EntityAdapter anEntityAdapter) {
 232       try {
 233         Iterator i = operations.iterator();
 234         List availableOperations = new Vector();
 235
 236         while (i.hasNext()) {
 237           MirAdminInterfaceLocalizer.MirSimpleEntityOperation operation =
 238             (MirAdminInterfaceLocalizer.MirSimpleEntityOperation) i.next();
 239
 240           if (operation.isAvailable(anEntityAdapter)) {
 241             availableOperations.add(operation.getName());
 242           }
 243         };
 244
 245         return availableOperations;
 246       }
 247       catch (Throwable t) {
 248         throw new RuntimeException(t.getMessage());
 249       }
 250     }
 251   }
 252
 253   protected class FilteredField implements EntityAdapterDefinition.CalculatedField {
 254     String fieldName;
 255
 256     public FilteredField(String aFieldName) {
 257       fieldName = aFieldName;
 258     }
 259
 260     public Object getValue(EntityAdapter anEntityAdapter) {
 261       try {
 262         if (anEntityAdapter.get("is_html")!=null && anEntityAdapter.get("is_html").equals("1")) {
 263           return anEntityAdapter.get(fieldName);
 264         }
 265         else {
 266           return MirGlobal.localizer().producerAssistant().filterText((String) anEntityAdapter.get(fieldName));
 267         }
 268       }
 269       catch (Throwable t) {
 270         throw new RuntimeException(t.getMessage());
 271       }
 272     }
 273   }
 274
 275   protected class ContentToParentField implements EntityAdapterDefinition.CalculatedField {
 276     public Object getValue(EntityAdapter anEntityAdapter) {
 277       try {
 278         logger.debug("ContentToParentField.getValue");
 279         return anEntityAdapter.getToOneRelation(
 280                     "id="+anEntityAdapter.get("to_content"),
 281                     "id",
 282                     "content" );
 283       }
 284       catch (Throwable t) {
 285         throw new RuntimeException(t.getMessage());
 286       }
 287     }
 288   }
 289
 290   protected class ContentToChildrenField implements EntityAdapterDefinition.CalculatedField {
 291     public Object getValue(EntityAdapter anEntityAdapter) {
 292       try {
 293         return anEntityAdapter.getRelation(
 294                     "to_content="+anEntityAdapter.get("id"),
 295                     "id",
 296                     "content" );
 297       }
 298       catch (Throwable t) {
 299         throw new RuntimeException(t.getMessage());
 300       }
 301     }
 302   }
 303
 304   protected class ContentToLanguageField implements EntityAdapterDefinition.CalculatedField {
 305     public Object getValue(EntityAdapter anEntityAdapter) {
 306       try {
 307         return anEntityAdapter.getToOneRelation(
 308                     "id="+anEntityAdapter.get("to_language"),
 309                     "id",
 310                     "language" );
 311       }
 312       catch (Throwable t) {
 313         throw new RuntimeException(t.getMessage());
 314       }
 315     }
 316   }
 317
 318   protected class ContentToArticleTypeField implements EntityAdapterDefinition.CalculatedField {
 319     public Object getValue(EntityAdapter anEntityAdapter) {
 320       try {
 321         return anEntityAdapter.getToOneRelation(
 322                     "id="+anEntityAdapter.get("to_article_type"),
 323                     "id",
 324                     "articleType" );
 325       }
 326       catch (Throwable t) {
 327         throw new RuntimeException(t.getMessage());
 328       }
 329     }
 330   }
 331
 332   protected class ContentToCommentsField implements EntityAdapterDefinition.CalculatedField {
 333     public Object getValue(EntityAdapter anEntityAdapter) {
 334       try {
 335         return anEntityAdapter.getRelation(
 336                     "to_media="+anEntityAdapter.get("id")+" and is_published='1'",
 337                     "webdb_create",
 338                     "comment" );
 339       }
 340       catch (Throwable t) {
 341         throw new RuntimeException(t.getMessage());
 342       }
 343     }
 344   }
 345
 346   protected class ContentToTopicsField implements EntityAdapterDefinition.CalculatedField {
 347     public Object getValue(EntityAdapter anEntityAdapter) {
 348       try {
 349         return anEntityAdapter.getRelation(
 350                     "exists (select * from content_x_topic where content_id="+anEntityAdapter.get("id")+" and topic_id=id)",
 351                     "title",
 352                     "topic" );
 353       }
 354       catch (Throwable t) {
 355         throw new RuntimeException(t.getMessage());
 356       }
 357     }
 358   }
 359
 360   protected class ContentToMediaField implements EntityAdapterDefinition.CalculatedField {
 361     private String definition;
 362     private boolean published;
 363
 364     public ContentToMediaField(String aDefinition, boolean anOnlyPublished) {
 365       definition = aDefinition;
 366       published = anOnlyPublished;
 367     }
 368
 369     public ContentToMediaField(String aDefinition) {
 370       this(aDefinition, true);
 371     }
 372
 373     public Object getValue(EntityAdapter anEntityAdapter) {
 374       try {
 375         String condition = "exists (select * from content_x_media where content_id="+anEntityAdapter.get("id")+" and media_id=id)";
 376         if (published)
 377           condition = "is_published='t' and " + condition;
 378         return anEntityAdapter.getRelation(
 379            condition,
 380           "id",
 381           definition);
 382       }
 383       catch (Throwable t) {
 384         throw new RuntimeException(t.getMessage());
 385       }
 386     }
 387   }
 388
 389   protected class CommentToMediaField implements EntityAdapterDefinition.CalculatedField {
 390     private String definition;
 391     private boolean published;
 392
 393     public CommentToMediaField(String aDefinition, boolean anOnlyPublished) {
 394       definition = aDefinition;
 395       published = anOnlyPublished;
 396     }
 397
 398     public CommentToMediaField(String aDefinition) {
 399       this(aDefinition, true);
 400     }
 401
 402     public Object getValue(EntityAdapter anEntityAdapter) {
 403       try {
 404         String condition = "exists (select * from comment_x_media where comment_id="+anEntityAdapter.get("id")+" and media_id=id)";
 405         if (published)
 406           condition = "is_published='t' and " + condition;
 407         return anEntityAdapter.getRelation(
 408            condition,
 409           "id",
 410           definition);
 411       }
 412       catch (Throwable t) {
 413         throw new RuntimeException(t.getMessage());
 414       }
 415     }
 416   }
 417
 418   protected class ContentToIconField implements EntityAdapterDefinition.CalculatedField {
 419     public Object getValue(EntityAdapter anEntityAdapter) {
 420       EntityAdapter media;
 421       Entity mediaType;
 422       RewindableIterator iterator;
 423       Map result;
 424       MirMedia mediaHandler;
 425       String tinyIcon;
 426       String iconAlt;
 427
 428       try {
 429         iterator = (RewindableIterator) (anEntityAdapter.get("to_uploaded_media"));
 430         iterator.rewind();
 431
 432         tinyIcon = MirGlobal.config().getString("Producer.Icon.TinyText");
 433         iconAlt = "Text";
 434
 435         if (iterator.hasNext()) {
 436           media = (EntityAdapter) iterator.next();
 437
 438           mediaType = ((EntityUploadedMedia) (media.getEntity())).getMediaType();
 439           mediaHandler = MediaHelper.getHandler( mediaType );
 440
 441           if (mediaHandler.isVideo()) {
 442             tinyIcon = MirGlobal.config().getString("Producer.Icon.TinyVideo");
 443             iconAlt = "Video";
 444           }
 445           else if (mediaHandler.isAudio()) {
 446             tinyIcon = MirGlobal.config().getString("Producer.Icon.TinyAudio");
 447             iconAlt = "Audio";
 448           }
 449           else if (mediaHandler.isImage()) {
 450             tinyIcon = MirGlobal.config().getString("Producer.Icon.TinyImage");
 451             iconAlt = "Image";
 452           }
 453           else {
 454             tinyIcon = mediaHandler.getTinyIconName();
 455             iconAlt = mediaHandler.getIconAltName();
 456           }
 457
 458         }
 459       }
 460       catch (Throwable t) {
 461         logger.error("ContentToIconField: " +t.getMessage());
 462         throw new RuntimeException(t.getMessage());
 463       }
 464
 465       result = new HashMap();
 466       result.put("tiny_icon", MirGlobal.config().getString("Producer.ImageRoot") + "/" + tinyIcon);
 467       result.put("icon_alt", iconAlt);
 468
 469       return result;
 470     }
 471   }
 472
 473   protected class ContentCommentCountField implements EntityAdapterDefinition.CalculatedField {
 474     private String extraCondition;
 475
 476     public ContentCommentCountField(String anExtraCondition) {
 477       super();
 478
 479       extraCondition = anExtraCondition;
 480     }
 481
 482     public Object getValue(EntityAdapter anEntityAdapter) {
 483       try {
 484         return Integer.toString(
 485             DatabaseComment.getInstance().getSize(
 486                   "to_media="+anEntityAdapter.get("id")+" " + extraCondition));
 487       }
 488       catch (Throwable t) {
 489         throw new RuntimeException(t.getMessage());
 490       }
 491     }
 492   }
 493 }