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