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