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