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.*;
  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.*;
  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, MirLocalizerExc {
  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 adapterModel() 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       result.addMapping( "content_x_topic", DatabaseContentToTopics.getInstance(), new EntityAdapterDefinition());
 194
 195     }
 196     catch (Throwable t) {
 197       throw new MirLocalizerFailure(t.getMessage(), t);
 198     }
 199
 200     return result;
 201   }
 202
 203   protected class CommentToContentField implements EntityAdapterDefinition.CalculatedField {
 204     public Object getValue(EntityAdapter anEntityAdapter) {
 205       try {
 206         return anEntityAdapter.getToOneRelation(
 207                     "id="+anEntityAdapter.get("to_media"),
 208                     "id",
 209                     "content" );
 210       }
 211       catch (Throwable t) {
 212         throw new RuntimeException(t.getMessage());
 213       }
 214     }
 215   }
 216
 217   protected class CommentToStatusField implements EntityAdapterDefinition.CalculatedField {
 218     public Object getValue(EntityAdapter anEntityAdapter) {
 219       try {
 220         return anEntityAdapter.getToOneRelation(
 221                     "id="+anEntityAdapter.get("to_comment_status"),
 222                     "id",
 223                     "commentStatus" );
 224       }
 225       catch (Throwable t) {
 226         throw new RuntimeException(t.getMessage());
 227       }
 228     }
 229   }
 230
 231   protected class EntityToSimpleOperationsField implements EntityAdapterDefinition.CalculatedField {
 232     private List operations;
 233
 234     public EntityToSimpleOperationsField(List anOperations) {
 235       operations = anOperations;
 236     }
 237
 238     public Object getValue(EntityAdapter anEntityAdapter) {
 239       try {
 240         Iterator i = operations.iterator();
 241         List availableOperations = new Vector();
 242
 243         while (i.hasNext()) {
 244           MirAdminInterfaceLocalizer.MirSimpleEntityOperation operation =
 245             (MirAdminInterfaceLocalizer.MirSimpleEntityOperation) i.next();
 246
 247           if (operation.isAvailable(anEntityAdapter)) {
 248             availableOperations.add(operation.getName());
 249           }
 250         };
 251
 252         return availableOperations;
 253       }
 254       catch (Throwable t) {
 255         throw new RuntimeException(t.getMessage());
 256       }
 257     }
 258   }
 259
 260   protected class FilteredField implements EntityAdapterDefinition.CalculatedField {
 261     private String fieldName;
 262
 263     public FilteredField(String aFieldName) {
 264       fieldName = aFieldName;
 265     }
 266
 267     public Object getValue(EntityAdapter anEntityAdapter) {
 268       try {
 269         if (anEntityAdapter.get("is_html")!=null && anEntityAdapter.get("is_html").equals("1")) {
 270           return MirGlobal.localizer().producerAssistant().filterHTMLText((String) anEntityAdapter.get(fieldName));
 271         }
 272         else {
 273           return MirGlobal.localizer().producerAssistant().filterNonHTMLText((String) anEntityAdapter.get(fieldName));
 274         }
 275       }
 276       catch (Throwable t) {
 277         throw new RuntimeException(t.getMessage());
 278       }
 279     }
 280   }
 281
 282   protected class StructuredContentField implements EntityAdapterDefinition.CalculatedField {
 283     private String expression;
 284
 285     public StructuredContentField(String anExpression) {
 286       expression = anExpression;
 287     }
 288
 289     public Object getValue(EntityAdapter anEntityAdapter) {
 290       try {
 291         return StructuredContentParser.parse(ParameterExpander.expandExpression(anEntityAdapter, expression));
 292       }
 293       catch (Throwable t) {
 294         throw new RuntimeException(t.getMessage());
 295       }
 296     }
 297   }
 298
 299   protected class ExpandedField implements EntityAdapterDefinition.CalculatedField {
 300     private String expression;
 301
 302     public ExpandedField(String anExpression) {
 303       expression = anExpression;
 304     }
 305
 306     public Object getValue(EntityAdapter anEntityAdapter) {
 307       try {
 308         return ParameterExpander.expandExpression(anEntityAdapter, expression);
 309       }
 310       catch (Throwable t) {
 311         throw new RuntimeException(t.getMessage());
 312       }
 313     }
 314   }
 315
 316   protected class EvaluatedField implements EntityAdapterDefinition.CalculatedField {
 317     private String expression;
 318
 319     public EvaluatedField(String anExpression) {
 320       expression = anExpression;
 321     }
 322
 323     public Object getValue(EntityAdapter anEntityAdapter) {
 324       try {
 325         return ParameterExpander.evaluateExpression(anEntityAdapter, expression);
 326       }
 327       catch (Throwable t) {
 328         throw new RuntimeException(t.getMessage());
 329       }
 330     }
 331   }
 332
 333   protected class ContentToParentField implements EntityAdapterDefinition.CalculatedField {
 334     public Object getValue(EntityAdapter anEntityAdapter) {
 335       try {
 336         logger.debug("ContentToParentField.getValue");
 337         return anEntityAdapter.getToOneRelation(
 338                     "id="+anEntityAdapter.get("to_content"),
 339                     "id",
 340                     "content" );
 341       }
 342       catch (Throwable t) {
 343         throw new RuntimeException(t.getMessage());
 344       }
 345     }
 346   }
 347
 348   protected class ContentToChildrenField implements EntityAdapterDefinition.CalculatedField {
 349     public Object getValue(EntityAdapter anEntityAdapter) {
 350       try {
 351         return anEntityAdapter.getRelation(
 352                     "to_content="+anEntityAdapter.get("id"),
 353                     "id",
 354                     "content" );
 355       }
 356       catch (Throwable t) {
 357         throw new RuntimeException(t.getMessage());
 358       }
 359     }
 360   }
 361
 362   protected class ContentToLanguageField implements EntityAdapterDefinition.CalculatedField {
 363     public Object getValue(EntityAdapter anEntityAdapter) {
 364       try {
 365         return anEntityAdapter.getToOneRelation(
 366                     "id="+anEntityAdapter.get("to_language"),
 367                     "id",
 368                     "language" );
 369       }
 370       catch (Throwable t) {
 371         throw new RuntimeException(t.getMessage());
 372       }
 373     }
 374   }
 375
 376   protected class ContentToArticleTypeField implements EntityAdapterDefinition.CalculatedField {
 377     public Object getValue(EntityAdapter anEntityAdapter) {
 378       try {
 379         return anEntityAdapter.getToOneRelation(
 380                     "id="+anEntityAdapter.get("to_article_type"),
 381                     "id",
 382                     "articleType" );
 383       }
 384       catch (Throwable t) {
 385         throw new RuntimeException(t.getMessage());
 386       }
 387     }
 388   }
 389
 390   protected class ContentToCommentsField implements EntityAdapterDefinition.CalculatedField {
 391     public Object getValue(EntityAdapter anEntityAdapter) {
 392       try {
 393         return anEntityAdapter.getRelation(
 394                     "to_media="+anEntityAdapter.get("id")+" and is_published='1'",
 395                     "webdb_create",
 396                     "comment" );
 397       }
 398       catch (Throwable t) {
 399         throw new RuntimeException(t.getMessage());
 400       }
 401     }
 402   }
 403
 404   protected class ContentToTopicsField implements EntityAdapterDefinition.CalculatedField {
 405     private String topicCondition;
 406
 407     public ContentToTopicsField() {
 408       this(null);
 409     }
 410
 411     public ContentToTopicsField(String aTopicCondition) {
 412       topicCondition = aTopicCondition;
 413     }
 414
 415     public Object getValue(EntityAdapter anEntityAdapter) {
 416       try {
 417         String condition = "exists (select * from content_x_topic where content_id="+anEntityAdapter.get("id")+" and topic_id=id)";
 418         if (topicCondition!=null && topicCondition.length()>0)
 419           condition = "(" + topicCondition + ") and " + condition;
 420
 421         return anEntityAdapter.getRelation(
 422                     condition,
 423                     "title",
 424                     "topic" );
 425       }
 426       catch (Throwable t) {
 427         throw new RuntimeException(t.getMessage());
 428       }
 429     }
 430   }
 431
 432   protected class ContentToMediaField implements EntityAdapterDefinition.CalculatedField {
 433     private String definition;
 434     private boolean published;
 435
 436     public ContentToMediaField(String aDefinition, boolean anOnlyPublished) {
 437       definition = aDefinition;
 438       published = anOnlyPublished;
 439     }
 440
 441     public ContentToMediaField(String aDefinition) {
 442       this(aDefinition, true);
 443     }
 444
 445     public Object getValue(EntityAdapter anEntityAdapter) {
 446       try {
 447         String condition = "exists (select * from content_x_media where content_id="+anEntityAdapter.get("id")+" and media_id=id)";
 448         if (published)
 449           condition = "is_published='t' and " + condition;
 450         return anEntityAdapter.getRelation(
 451            condition,
 452           "id",
 453           definition);
 454       }
 455       catch (Throwable t) {
 456         throw new RuntimeException(t.getMessage());
 457       }
 458     }
 459   }
 460
 461   protected class CommentToMediaField implements EntityAdapterDefinition.CalculatedField {
 462     private String definition;
 463     private boolean published;
 464
 465     public CommentToMediaField(String aDefinition, boolean anOnlyPublished) {
 466       definition = aDefinition;
 467       published = anOnlyPublished;
 468     }
 469
 470     public CommentToMediaField(String aDefinition) {
 471       this(aDefinition, true);
 472     }
 473
 474     public Object getValue(EntityAdapter anEntityAdapter) {
 475       try {
 476         String condition = "exists (select * from comment_x_media where comment_id="+anEntityAdapter.get("id")+" and media_id=id)";
 477         if (published)
 478           condition = "is_published='t' and " + condition;
 479         return anEntityAdapter.getRelation(
 480            condition,
 481           "id",
 482           definition);
 483       }
 484       catch (Throwable t) {
 485         throw new RuntimeException(t.getMessage());
 486       }
 487     }
 488   }
 489
 490   protected class ContentToIconField implements EntityAdapterDefinition.CalculatedField {
 491     public Object getValue(EntityAdapter anEntityAdapter) {
 492       EntityAdapter media;
 493       Entity mediaType;
 494       RewindableIterator iterator;
 495       Map result;
 496       MirMedia mediaHandler;
 497       String tinyIcon;
 498       String iconAlt;
 499
 500       try {
 501         iterator = (RewindableIterator) (anEntityAdapter.get("to_uploaded_media"));
 502         iterator.rewind();
 503
 504         tinyIcon = MirGlobal.config().getString("Producer.Icon.TinyText");
 505         iconAlt = "Text";
 506
 507         if (iterator.hasNext()) {
 508           media = (EntityAdapter) iterator.next();
 509
 510           mediaType = ((EntityUploadedMedia) (media.getEntity())).getMediaType();
 511           mediaHandler = MediaHelper.getHandler( mediaType );
 512
 513           if (mediaHandler.isVideo()) {
 514             tinyIcon = MirGlobal.config().getString("Producer.Icon.TinyVideo");
 515             iconAlt = "Video";
 516           }
 517           else if (mediaHandler.isAudio()) {
 518             tinyIcon = MirGlobal.config().getString("Producer.Icon.TinyAudio");
 519             iconAlt = "Audio";
 520           }
 521           else if (mediaHandler.isImage()) {
 522             tinyIcon = MirGlobal.config().getString("Producer.Icon.TinyImage");
 523             iconAlt = "Image";
 524           }
 525           else {
 526             tinyIcon = mediaHandler.getTinyIconName();
 527             iconAlt = mediaHandler.getIconAltName();
 528           }
 529
 530         }
 531       }
 532       catch (Throwable t) {
 533         logger.error("ContentToIconField: " +t.getMessage());
 534         throw new RuntimeException(t.getMessage());
 535       }
 536
 537       result = new HashMap();
 538       result.put("tiny_icon", MirGlobal.config().getString("Producer.ImageRoot") + "/" + tinyIcon);
 539       result.put("icon_alt", iconAlt);
 540
 541       return result;
 542     }
 543   }
 544
 545   protected class ContentCommentCountField implements EntityAdapterDefinition.CalculatedField {
 546     private String extraCondition;
 547
 548     public ContentCommentCountField(String anExtraCondition) {
 549       super();
 550
 551       extraCondition = anExtraCondition;
 552     }
 553
 554     public Object getValue(EntityAdapter anEntityAdapter) {
 555       try {
 556         return Integer.toString(
 557             DatabaseComment.getInstance().getSize(
 558                   "to_media="+anEntityAdapter.get("id")+" " + extraCondition));
 559       }
 560       catch (Throwable t) {
 561         throw new RuntimeException(t.getMessage());
 562       }
 563     }
 564   }
 565 }