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 mir.util.StructuredContentParser;
  49 import mircoders.entity.EntityUploadedMedia;
  50 import mircoders.global.MirGlobal;
  51 import mircoders.localizer.MirAdminInterfaceLocalizer;
  52 import mircoders.localizer.MirDataModelLocalizer;
  53 import mircoders.localizer.MirLocalizerExc;
  54 import mircoders.localizer.MirLocalizerFailure;
  55 import mircoders.storage.DatabaseArticleType;
  56 import mircoders.storage.DatabaseAudio;
  57 import mircoders.storage.DatabaseBreaking;
  58 import mircoders.storage.DatabaseComment;
  59 import mircoders.storage.DatabaseCommentStatus;
  60 import mircoders.storage.DatabaseContent;
  61 import mircoders.storage.DatabaseContentToMedia;
  62 import mircoders.storage.DatabaseContentToTopics;
  63 import mircoders.storage.DatabaseImageType;
  64 import mircoders.storage.DatabaseImages;
  65 import mircoders.storage.DatabaseLanguage;
  66 import mircoders.storage.DatabaseMediaType;
  67 import mircoders.storage.DatabaseMediafolder;
  68 import mircoders.storage.DatabaseMessages;
  69 import mircoders.storage.DatabaseOther;
  70 import mircoders.storage.DatabaseTopics;
  71 import mircoders.storage.DatabaseUploadedMedia;
  72 import mircoders.storage.DatabaseUsers;
  73 import mircoders.storage.DatabaseVideo;
  74
  75 public class MirBasicDataModelLocalizer implements MirDataModelLocalizer {
  76   protected LoggerWrapper logger;
  77   protected MirPropertiesConfiguration configuration;
  78
  79   public MirBasicDataModelLocalizer() throws MirLocalizerFailure, MirLocalizerExc {
  80     logger = new LoggerWrapper("Localizer.DataModel");
  81
  82     try {
  83       configuration = MirPropertiesConfiguration.instance();
  84     }
  85     catch (Throwable e) {
  86       throw new MirLocalizerFailure("Can't get configuration: " + e.getMessage(), e);
  87     }
  88   }
  89
  90   protected void constructContentAdapterDefinition(EntityAdapterDefinition anEntityAdapterDefinition) throws MirLocalizerFailure, MirLocalizerExc {
  91     try {
  92       anEntityAdapterDefinition.addDBDateField("creationdate", "webdb_create", configuration.getString("Mir.DefaultTimezone"));
  93       anEntityAdapterDefinition.addDBDateField("changedate", "webdb_lastchange", configuration.getString("Mir.DefaultTimezone"));
  94       anEntityAdapterDefinition.addMirDateField("date", "date", configuration.getString("Mir.DefaultTimezone"));
  95       anEntityAdapterDefinition.addCalculatedField("to_topics", new ContentToTopicsField());
  96       anEntityAdapterDefinition.addCalculatedField("to_comments", new ContentToCommentsField());
  97       anEntityAdapterDefinition.addCalculatedField("language", new ContentToLanguageField());
  98
  99       anEntityAdapterDefinition.addCalculatedField("commentcount", new ContentCommentCountField(" and is_published='1'"));
 100       anEntityAdapterDefinition.addCalculatedField("fullcommentcount", new ContentCommentCountField(""));
 101
 102       anEntityAdapterDefinition.addCalculatedField("to_uploaded_media", new ContentToMediaField( "uploadedMedia" ));
 103       anEntityAdapterDefinition.addCalculatedField("to_media_images",  new ContentToMediaField( "image" ));
 104       anEntityAdapterDefinition.addCalculatedField("to_media_audio", new ContentToMediaField( "audio" ));
 105       anEntityAdapterDefinition.addCalculatedField("to_media_video", new ContentToMediaField( "video" ));
 106       anEntityAdapterDefinition.addCalculatedField("to_media_other", new ContentToMediaField( "otherMedia" ));
 107       anEntityAdapterDefinition.addCalculatedField("to_all_uploaded_media", new ContentToMediaField( "uploadedMedia", false));
 108       anEntityAdapterDefinition.addCalculatedField("to_all_media_images",  new ContentToMediaField( "image", false));
 109       anEntityAdapterDefinition.addCalculatedField("to_all_media_audio", new ContentToMediaField( "audio", false));
 110       anEntityAdapterDefinition.addCalculatedField("to_all_media_video", new ContentToMediaField( "video", false));
 111       anEntityAdapterDefinition.addCalculatedField("to_all_media_other", new ContentToMediaField( "otherMedia", false));
 112       anEntityAdapterDefinition.addCalculatedField("to_media_icon", new ContentToIconField());
 113
 114       anEntityAdapterDefinition.addCalculatedField("article_type", new ContentToArticleTypeField());
 115
 116       anEntityAdapterDefinition.addCalculatedField("description_parsed", new FilteredField("description"));
 117       anEntityAdapterDefinition.addCalculatedField("content_data_parsed", new FilteredField("content_data"));
 118
 119       anEntityAdapterDefinition.addCalculatedField("children", new ContentToChildrenField());
 120       anEntityAdapterDefinition.addCalculatedField("parent", new ContentToParentField());
 121
 122       anEntityAdapterDefinition.addCalculatedField("publicurl", new ExpandedField(configuration.getString("Article.PublicUrl")));
 123
 124       anEntityAdapterDefinition.addCalculatedField("operations",
 125           new EntityToSimpleOperationsField(MirGlobal.localizer().adminInterface().simpleArticleOperations()));
 126     }
 127     catch (Throwable t) {
 128       throw new MirLocalizerFailure(t.getMessage(), t);
 129     }
 130   }
 131
 132   protected void constructCommentAdapterDefinition(EntityAdapterDefinition anEntityAdapterDefinition) throws MirLocalizerFailure {
 133     try {
 134       anEntityAdapterDefinition.addDBDateField("creationdate", "webdb_create", configuration.getString("Mir.DefaultTimezone"));
 135       anEntityAdapterDefinition.addCalculatedField("to_content", new CommentToContentField());
 136       anEntityAdapterDefinition.addCalculatedField("status", new CommentToStatusField());
 137
 138       anEntityAdapterDefinition.addCalculatedField("to_uploaded_media", new CommentToMediaField( "uploadedMedia" ));
 139       anEntityAdapterDefinition.addCalculatedField("to_media_images",  new CommentToMediaField( "image" ));
 140       anEntityAdapterDefinition.addCalculatedField("to_media_audio", new CommentToMediaField( "audio" ));
 141       anEntityAdapterDefinition.addCalculatedField("to_media_video", new CommentToMediaField( "video" ));
 142       anEntityAdapterDefinition.addCalculatedField("to_media_other", new CommentToMediaField( "otherMedia" ));
 143       anEntityAdapterDefinition.addCalculatedField("to_all_uploaded_media", new CommentToMediaField( "uploadedMedia", false));
 144       anEntityAdapterDefinition.addCalculatedField("to_all_media_images",  new CommentToMediaField( "image", false));
 145       anEntityAdapterDefinition.addCalculatedField("to_all_media_audio", new CommentToMediaField( "audio", false));
 146       anEntityAdapterDefinition.addCalculatedField("to_all_media_video", new CommentToMediaField( "video", false));
 147       anEntityAdapterDefinition.addCalculatedField("to_all_media_other", new CommentToMediaField( "otherMedia", false));
 148
 149       anEntityAdapterDefinition.addCalculatedField("publicurl", new ExpandedField(configuration.getString("Comment.PublicUrl")));
 150
 151       anEntityAdapterDefinition.addCalculatedField("description_parsed", new FilteredField("description"));
 152       anEntityAdapterDefinition.addCalculatedField("operations",
 153           new EntityToSimpleOperationsField(MirGlobal.localizer().adminInterface().simpleCommentOperations()));
 154     }
 155     catch (Throwable t) {
 156       throw new MirLocalizerFailure(t.getMessage(), t);
 157     }
 158   }
 159
 160   public EntityAdapterModel adapterModel() throws MirLocalizerFailure, MirLocalizerExc {
 161     EntityAdapterModel result = new EntityAdapterModel();
 162
 163     try {
 164       EntityAdapterDefinition definition;
 165
 166       definition = new EntityAdapterDefinition();
 167       constructContentAdapterDefinition( definition );
 168       result.addMapping( "content", DatabaseContent.getInstance(), definition);
 169
 170       definition = new EntityAdapterDefinition();
 171       constructCommentAdapterDefinition( definition );
 172       result.addMapping( "comment", DatabaseComment.getInstance(), definition);
 173
 174       result.addMapping( "articleType", DatabaseArticleType.getInstance(), new EntityAdapterDefinition());
 175       result.addMapping( "commentStatus", DatabaseCommentStatus.getInstance(), new EntityAdapterDefinition());
 176
 177       definition = new EntityAdapterDefinition();
 178       definition.addDBDateField("creationdate", "webdb_create", configuration.getString("Mir.DefaultTimezone"));
 179       result.addMapping( "breakingNews", DatabaseBreaking.getInstance(), definition);
 180
 181       definition = new EntityAdapterDefinition();
 182       definition.addDBDateField("creationdate", "webdb_create", configuration.getString("Mir.DefaultTimezone"));
 183       result.addMapping( "internalMessage", DatabaseMessages.getInstance(), definition);
 184
 185       definition = new EntityAdapterDefinition();
 186       definition.addCalculatedField("mediafolder", new MediaToMediaFolderField());
 187       result.addMapping( "uploadedMedia", DatabaseUploadedMedia.getInstance(), definition);
 188       definition = new EntityAdapterDefinition();
 189       definition.addCalculatedField("mediafolder", new MediaToMediaFolderField());
 190       result.addMapping( "image", DatabaseImages.getInstance(), definition);
 191       definition = new EntityAdapterDefinition();
 192       definition.addCalculatedField("mediafolder", new MediaToMediaFolderField());
 193       result.addMapping( "audio", DatabaseAudio.getInstance(), definition);
 194       definition = new EntityAdapterDefinition();
 195       definition.addCalculatedField("mediafolder", new MediaToMediaFolderField());
 196       result.addMapping( "video", DatabaseVideo.getInstance(), definition);
 197       definition = new EntityAdapterDefinition();
 198       definition.addCalculatedField("mediafolder", new MediaToMediaFolderField());
 199       result.addMapping( "otherMedia", DatabaseOther.getInstance(), definition);
 200
 201
 202       result.addMapping( "mediaFolder", DatabaseMediafolder.getInstance(), new EntityAdapterDefinition());
 203       result.addMapping( "imageType", DatabaseImageType.getInstance(), new EntityAdapterDefinition());
 204       result.addMapping( "language", DatabaseLanguage.getInstance(), new EntityAdapterDefinition());
 205       result.addMapping( "mediaType", DatabaseMediaType.getInstance(), new EntityAdapterDefinition());
 206       result.addMapping( "topic", DatabaseTopics.getInstance(), new EntityAdapterDefinition());
 207       result.addMapping( "user", DatabaseUsers.getInstance(), new EntityAdapterDefinition());
 208       result.addMapping( "otherMedia", DatabaseOther.getInstance(), new EntityAdapterDefinition());
 209
 210       result.addMapping( "content_x_topic", DatabaseContentToTopics.getInstance(), new EntityAdapterDefinition());
 211
 212     }
 213     catch (Throwable t) {
 214       throw new MirLocalizerFailure(t.getMessage(), t);
 215     }
 216
 217     return result;
 218   }
 219
 220   protected class CommentToContentField implements EntityAdapterDefinition.CalculatedField {
 221     public Object getValue(EntityAdapter anEntityAdapter) {
 222       try {
 223         return anEntityAdapter.getToOneRelation(
 224                     "id="+anEntityAdapter.get("to_media"),
 225                     "id",
 226                     "content" );
 227       }
 228       catch (Throwable t) {
 229         throw new RuntimeException(t.getMessage());
 230       }
 231     }
 232   }
 233
 234   protected class CommentToStatusField implements EntityAdapterDefinition.CalculatedField {
 235     public Object getValue(EntityAdapter anEntityAdapter) {
 236       try {
 237         return anEntityAdapter.getToOneRelation(
 238                     "id="+anEntityAdapter.get("to_comment_status"),
 239                     "id",
 240                     "commentStatus" );
 241       }
 242       catch (Throwable t) {
 243         throw new RuntimeException(t.getMessage());
 244       }
 245     }
 246   }
 247
 248   protected class EntityToSimpleOperationsField implements EntityAdapterDefinition.CalculatedField {
 249     private List operations;
 250
 251     public EntityToSimpleOperationsField(List anOperations) {
 252       operations = anOperations;
 253     }
 254
 255     public Object getValue(EntityAdapter anEntityAdapter) {
 256       try {
 257         Iterator i = operations.iterator();
 258         List availableOperations = new Vector();
 259
 260         while (i.hasNext()) {
 261           MirAdminInterfaceLocalizer.MirSimpleEntityOperation operation =
 262             (MirAdminInterfaceLocalizer.MirSimpleEntityOperation) i.next();
 263
 264           if (operation.isAvailable(anEntityAdapter)) {
 265             availableOperations.add(operation.getName());
 266           }
 267         };
 268
 269         return availableOperations;
 270       }
 271       catch (Throwable t) {
 272         throw new RuntimeException(t.getMessage());
 273       }
 274     }
 275   }
 276
 277   protected class FilteredField implements EntityAdapterDefinition.CalculatedField {
 278     private String fieldName;
 279
 280     public FilteredField(String aFieldName) {
 281       fieldName = aFieldName;
 282     }
 283
 284     public Object getValue(EntityAdapter anEntityAdapter) {
 285       try {
 286         if (anEntityAdapter.get("is_html")!=null && anEntityAdapter.get("is_html").equals("1")) {
 287           return MirGlobal.localizer().producerAssistant().filterHTMLText((String) anEntityAdapter.get(fieldName));
 288         }
 289         else {
 290           return MirGlobal.localizer().producerAssistant().filterNonHTMLText((String) anEntityAdapter.get(fieldName));
 291         }
 292       }
 293       catch (Throwable t) {
 294         throw new RuntimeException(t.getMessage());
 295       }
 296     }
 297   }
 298
 299   protected class StructuredContentField implements EntityAdapterDefinition.CalculatedField {
 300     private String expression;
 301
 302     public StructuredContentField(String anExpression) {
 303       expression = anExpression;
 304     }
 305
 306     public Object getValue(EntityAdapter anEntityAdapter) {
 307       try {
 308         return StructuredContentParser.parse(ParameterExpander.evaluateStringExpression(anEntityAdapter, expression));
 309       }
 310       catch (Throwable t) {
 311         throw new RuntimeException(t.getMessage());
 312       }
 313     }
 314   }
 315
 316   protected class ExpandedField implements EntityAdapterDefinition.CalculatedField {
 317     private String expression;
 318
 319     public ExpandedField(String anExpression) {
 320       expression = anExpression;
 321     }
 322
 323     public Object getValue(EntityAdapter anEntityAdapter) {
 324       try {
 325         return ParameterExpander.expandExpression(anEntityAdapter, expression);
 326       }
 327       catch (Throwable t) {
 328         throw new RuntimeException(t.getMessage());
 329       }
 330     }
 331   }
 332
 333   protected class EvaluatedField implements EntityAdapterDefinition.CalculatedField {
 334     private String expression;
 335
 336     public EvaluatedField(String anExpression) {
 337       expression = anExpression;
 338     }
 339
 340     public Object getValue(EntityAdapter anEntityAdapter) {
 341       try {
 342         return ParameterExpander.evaluateExpression(anEntityAdapter, expression);
 343       }
 344       catch (Throwable t) {
 345         throw new RuntimeException(t.getMessage());
 346       }
 347     }
 348   }
 349
 350   protected class ContentToParentField implements EntityAdapterDefinition.CalculatedField {
 351     public Object getValue(EntityAdapter anEntityAdapter) {
 352       try {
 353         logger.debug("ContentToParentField.getValue");
 354         return anEntityAdapter.getToOneRelation(
 355                     "id="+anEntityAdapter.get("to_content"),
 356                     "id",
 357                     "content" );
 358       }
 359       catch (Throwable t) {
 360         throw new RuntimeException(t.getMessage());
 361       }
 362     }
 363   }
 364
 365   protected class ContentToChildrenField implements EntityAdapterDefinition.CalculatedField {
 366     public Object getValue(EntityAdapter anEntityAdapter) {
 367       try {
 368         return anEntityAdapter.getRelation(
 369                     "to_content="+anEntityAdapter.get("id"),
 370                     "id",
 371                     "content" );
 372       }
 373       catch (Throwable t) {
 374         throw new RuntimeException(t.getMessage());
 375       }
 376     }
 377   }
 378
 379   protected class ContentToLanguageField implements EntityAdapterDefinition.CalculatedField {
 380     public Object getValue(EntityAdapter anEntityAdapter) {
 381       try {
 382         return anEntityAdapter.getToOneRelation(
 383                     "id="+anEntityAdapter.get("to_language"),
 384                     "id",
 385                     "language" );
 386       }
 387       catch (Throwable t) {
 388         throw new RuntimeException(t.getMessage());
 389       }
 390     }
 391   }
 392
 393   protected class ContentToArticleTypeField implements EntityAdapterDefinition.CalculatedField {
 394     public Object getValue(EntityAdapter anEntityAdapter) {
 395       try {
 396         return anEntityAdapter.getToOneRelation(
 397                     "id="+anEntityAdapter.get("to_article_type"),
 398                     "id",
 399                     "articleType" );
 400       }
 401       catch (Throwable t) {
 402         throw new RuntimeException(t.getMessage());
 403       }
 404     }
 405   }
 406
 407   protected class MediaToMediaFolderField implements EntityAdapterDefinition.CalculatedField {
 408     public Object getValue(EntityAdapter anEntityAdapter) {
 409       try {
 410         return anEntityAdapter.getToOneRelation(
 411                     "id="+anEntityAdapter.get("to_media_folder"),
 412                     "id",
 413                     "mediaFolder" );
 414       }
 415       catch (Throwable t) {
 416         throw new RuntimeException(t.getMessage());
 417       }
 418     }
 419   }
 420
 421   protected class ContentToCommentsField implements EntityAdapterDefinition.CalculatedField {
 422     private String extracondition;
 423     private String order;
 424
 425     public ContentToCommentsField() {
 426       this ( " and is_published='1'", "webdb_create");
 427     }
 428
 429     public ContentToCommentsField(String anExtraCondition, String anOrder) {
 430       order = anOrder;
 431       extracondition = anExtraCondition;
 432     }
 433
 434     public Object getValue(EntityAdapter anEntityAdapter) {
 435       try {
 436         return anEntityAdapter.getRelation(
 437                     "to_media="+anEntityAdapter.get("id")+" " + extracondition,
 438                     order,
 439                     "comment" );
 440       }
 441       catch (Throwable t) {
 442         throw new RuntimeException(t.getMessage());
 443       }
 444     }
 445   }
 446
 447   protected class ContentToTopicsField implements EntityAdapterDefinition.CalculatedField {
 448     private String topicCondition;
 449     private String topicOrder;
 450
 451     public ContentToTopicsField() {
 452       this(null);
 453     }
 454
 455     public ContentToTopicsField(String aTopicCondition) {
 456       this(aTopicCondition, "title");
 457     }
 458
 459     public ContentToTopicsField(String aTopicCondition, String aTopicOrder) {
 460       topicCondition = aTopicCondition;
 461       topicOrder = aTopicOrder;
 462     }
 463
 464          // TODO rewrite as relational select
 465     public Object getValue(EntityAdapter anEntityAdapter) {
 466       try {
 467         String condition = "exists (select * from content_x_topic where content_id="+anEntityAdapter.get("id")+" and topic_id=id)";
 468         if (topicCondition!=null && topicCondition.length()>0)
 469           condition = "(" + topicCondition + ") and " + condition;
 470
 471         return anEntityAdapter.getRelation(
 472                     condition,
 473                     topicOrder,
 474                     "topic" );
 475       }
 476       catch (Throwable t) {
 477         throw new RuntimeException(t.getMessage());
 478       }
 479     }
 480   }
 481
 482   protected class ContentToMediaField implements EntityAdapterDefinition.CalculatedField {
 483     private String definition;
 484     private boolean published;
 485
 486     public ContentToMediaField(String aDefinition, boolean anOnlyPublished) {
 487       definition = aDefinition;
 488       published = anOnlyPublished;
 489     }
 490
 491     public ContentToMediaField(String aDefinition) {
 492       this(aDefinition, true);
 493     }
 494
 495     public Object getValue(EntityAdapter anEntityAdapter) {
 496       try {
 497         // TODO rewrite as relational select
 498         // select * from content where exists
 499         // (select * from content_x_media where content_id="+
 500         // anEntityAdapter.get("id")+" and media_id=id)
 501         String condition = "cxm.content_id="+ anEntityAdapter.get("id") +
 502           "cxm.media_id = m.id";
 503         List extraTables = new Vector();
 504         extraTables.add("content_x_media cxm");
 505         // String condition = "exists (select * from content_x_media where content_id="+anEntityAdapter.get("id")+" and media_id=id)";
 506         if (published)
 507           condition = "is_published='t' and " + condition;
 508         // return anEntityAdapter.getRelation(
 509         //    condition, "id", definition);
 510
 511         return anEntityAdapter.getComplexRelation("m", extraTables, condition, "id", definition);
 512       }
 513       catch (Throwable t) {
 514         throw new RuntimeException(t.getMessage());
 515       }
 516     }
 517   }
 518
 519   protected class CommentToMediaField implements EntityAdapterDefinition.CalculatedField {
 520     private String definition;
 521     private boolean published;
 522
 523     public CommentToMediaField(String aDefinition, boolean anOnlyPublished) {
 524       definition = aDefinition;
 525       published = anOnlyPublished;
 526     }
 527
 528     public CommentToMediaField(String aDefinition) {
 529       this(aDefinition, true);
 530     }
 531
 532     public Object getValue(EntityAdapter anEntityAdapter) {
 533       try {
 534                 // TODO rewrite as relational select
 535         String condition = "exists (select * from comment_x_media where comment_id="+anEntityAdapter.get("id")+" and media_id=id)";
 536         if (published)
 537           condition = "is_published='t' and " + condition;
 538         return anEntityAdapter.getRelation(
 539            condition,
 540           "id",
 541           definition);
 542       }
 543       catch (Throwable t) {
 544         throw new RuntimeException(t.getMessage());
 545       }
 546     }
 547   }
 548
 549   protected class ContentToIconField implements EntityAdapterDefinition.CalculatedField {
 550     public Object getValue(EntityAdapter anEntityAdapter) {
 551       EntityAdapter media;
 552       Entity mediaType;
 553       RewindableIterator iterator;
 554       Map result;
 555       MirMedia mediaHandler;
 556       String tinyIcon;
 557       String iconAlt;
 558
 559       try {
 560         iterator = (RewindableIterator) (anEntityAdapter.get("to_uploaded_media"));
 561         iterator.rewind();
 562
 563         tinyIcon = MirGlobal.config().getString("Producer.Icon.TinyText");
 564         iconAlt = "Text";
 565
 566         if (iterator.hasNext()) {
 567           media = (EntityAdapter) iterator.next();
 568
 569           mediaType = ((EntityUploadedMedia) (media.getEntity())).getMediaType();
 570           mediaHandler = MediaHelper.getHandler( mediaType );
 571
 572           if (mediaHandler.isVideo()) {
 573             tinyIcon = MirGlobal.config().getString("Producer.Icon.TinyVideo");
 574             iconAlt = "Video";
 575           }
 576           else if (mediaHandler.isAudio()) {
 577             tinyIcon = MirGlobal.config().getString("Producer.Icon.TinyAudio");
 578             iconAlt = "Audio";
 579           }
 580           else if (mediaHandler.isImage()) {
 581             tinyIcon = MirGlobal.config().getString("Producer.Icon.TinyImage");
 582             iconAlt = "Image";
 583           }
 584           else {
 585             tinyIcon = mediaHandler.getTinyIconName();
 586             iconAlt = mediaHandler.getIconAltName();
 587           }
 588
 589         }
 590       }
 591       catch (Throwable t) {
 592         logger.error("ContentToIconField: " +t.getMessage());
 593         throw new RuntimeException(t.getMessage());
 594       }
 595
 596       result = new HashMap();
 597       result.put("tiny_icon", MirGlobal.config().getString("Producer.ImageRoot") + "/" + tinyIcon);
 598       result.put("icon_alt", iconAlt);
 599
 600       return result;
 601     }
 602   }
 603
 604   protected class ContentCommentCountField implements EntityAdapterDefinition.CalculatedField {
 605     private String extraCondition;
 606
 607     public ContentCommentCountField(String anExtraCondition) {
 608       super();
 609
 610       extraCondition = anExtraCondition;
 611     }
 612
 613     public Object getValue(EntityAdapter anEntityAdapter) {
 614       try {
 615         return Integer.toString(
 616             DatabaseComment.getInstance().getSize(
 617                   "to_media="+anEntityAdapter.get("id")+" " + extraCondition));
 618       }
 619       catch (Throwable t) {
 620         throw new RuntimeException(t.getMessage());
 621       }
 622     }
 623   }
 624
 625   protected class ContentMediaCountField implements EntityAdapterDefinition.CalculatedField {
 626     private String table;
 627     private boolean published;
 628
 629     public ContentMediaCountField(String aTable, boolean anOnlyPublished) {
 630       table = aTable;
 631       published = anOnlyPublished;
 632     }
 633
 634     public ContentMediaCountField(String aTable) {
 635       this(aTable, true);
 636     }
 637
 638     public Object getValue(EntityAdapter anEntityAdapter) {
 639       try {
 640         String subQuery = "select * from "+table+" where id = media_id";
 641         if (published)
 642           subQuery = subQuery + " and is_published='t'";
 643
 644         return Integer.toString(
 645             DatabaseContentToMedia.getInstance().getSize(
 646                   "exists ("+subQuery+")"));
 647       }
 648       catch (Throwable t) {
 649         throw new RuntimeException(t.getMessage());
 650       }
 651     }
 652   }
 653 }