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 mir.config.MirPropertiesConfiguration;
  33 import mir.entity.Entity;
  34 import mir.entity.adapter.EntityAdapter;
  35 import mir.entity.adapter.EntityAdapterDefinition;
  36 import mir.entity.adapter.EntityAdapterModel;
  37 import mir.entity.adapter.ToManyRelationField;
  38 import mir.entity.adapter.ToOneRelationField;
  39 import mir.generator.Generator;
  40 import mir.generator.GeneratorExc;
  41 import mir.generator.GeneratorFailure;
  42 import mir.log.LoggerWrapper;
  43 import mir.media.MediaHandler;
  44 import mir.misc.NumberUtils;
  45 import mir.util.JDBCStringRoutines;
  46 import mir.util.ParameterExpander;
  47 import mir.util.StructuredContentParser;
  48 import mircoders.entity.EntityContent;
  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.media.MediaHelper;
  56 import mircoders.module.ModuleContent;
  57 import mircoders.module.ModuleLanguage;
  58 import mircoders.storage.*;
  59 import multex.Failure;
  60
  61 import java.util.ArrayList;
  62 import java.util.Collections;
  63 import java.util.HashMap;
  64 import java.util.Iterator;
  65 import java.util.List;
  66 import java.util.Map;
  67
  68 public class MirBasicDataModelLocalizer implements MirDataModelLocalizer {
  69   protected LoggerWrapper logger = new LoggerWrapper("Localizer.DataModel");
  70   protected MirPropertiesConfiguration configuration = MirPropertiesConfiguration.instance();
  71   protected ModuleLanguage languageModule = new ModuleLanguage();
  72
  73   protected void constructContentAdapterDefinition(EntityAdapterDefinition anEntityAdapterDefinition) throws MirLocalizerFailure, MirLocalizerExc {
  74     try {
  75       anEntityAdapterDefinition.addDBDateField("creationdate", "webdb_create", configuration.getString("Mir.DefaultTimezone"));
  76       anEntityAdapterDefinition.addDBDateField("changedate", "webdb_lastchange", configuration.getString("Mir.DefaultTimezone"));
  77       anEntityAdapterDefinition.addMirDateField("date", "date", configuration.getString("Mir.DefaultTimezone"));
  78
  79       anEntityAdapterDefinition.addCalculatedField("lockinguser", new ToOneRelationField("to_locking_user", "id", "user"));
  80       anEntityAdapterDefinition.addCalculatedField("is_locked", new ContentToIsLockedField());
  81
  82       anEntityAdapterDefinition.addCalculatedField("to_topics", new ContentToTopicsField());
  83       anEntityAdapterDefinition.addCalculatedField("to_comments", new ContentToCommentsField());
  84       anEntityAdapterDefinition.addCalculatedField("language", new ToOneRelationField("to_language", "language", "id"));
  85       anEntityAdapterDefinition.addCalculatedField("commentcount", new ContentCommentCountField(" and is_published='1'"));
  86       anEntityAdapterDefinition.addCalculatedField("fullcommentcount", new ContentCommentCountField(""));
  87
  88
  89       anEntityAdapterDefinition.addCalculatedField("mediacount", new ContentMediaCountField("uploaded_media", true));
  90       anEntityAdapterDefinition.addCalculatedField("fullmediacount", new ContentMediaCountField("uploaded_media", false));
  91
  92       anEntityAdapterDefinition.addCalculatedField("to_uploaded_media", new ContentToMediaField( "uploadedMedia" ));
  93       anEntityAdapterDefinition.addCalculatedField("to_media_images",  new ContentToMediaField( "image" ));
  94       anEntityAdapterDefinition.addCalculatedField("to_media_audio", new ContentToMediaField( "audio" ));
  95       anEntityAdapterDefinition.addCalculatedField("to_media_video", new ContentToMediaField( "video" ));
  96       anEntityAdapterDefinition.addCalculatedField("to_media_other", new ContentToMediaField( "otherMedia" ));
  97
  98       anEntityAdapterDefinition.addCalculatedField("firstImage",  new ContentToFirstMediaField( "image" ));
  99       anEntityAdapterDefinition.addCalculatedField("firstAudio", new ContentToFirstMediaField( "audio" ));
 100       anEntityAdapterDefinition.addCalculatedField("firstVideo", new ContentToFirstMediaField( "video" ));
 101       anEntityAdapterDefinition.addCalculatedField("firstOther", new ContentToFirstMediaField( "otherMedia" ));
 102
 103       anEntityAdapterDefinition.addCalculatedField("to_all_uploaded_media", new ContentToMediaField( "uploadedMedia", false));
 104       anEntityAdapterDefinition.addCalculatedField("to_all_media_images",  new ContentToMediaField( "image", false));
 105       anEntityAdapterDefinition.addCalculatedField("to_all_media_audio", new ContentToMediaField( "audio", false));
 106       anEntityAdapterDefinition.addCalculatedField("to_all_media_video", new ContentToMediaField( "video", false));
 107       anEntityAdapterDefinition.addCalculatedField("to_all_media_other", new ContentToMediaField( "otherMedia", false));
 108       anEntityAdapterDefinition.addCalculatedField("to_media_icon", new ContentToIconField());
 109
 110       anEntityAdapterDefinition.addCalculatedField("article_type", new ToOneRelationField("to_article_type", "articleType", "id"));
 111
 112       anEntityAdapterDefinition.addCalculatedField("description_parsed", new FilteredField("description"));
 113       anEntityAdapterDefinition.addCalculatedField("content_data_parsed", new FilteredField("content_data"));
 114
 115       anEntityAdapterDefinition.addCalculatedField("children", new ContentToChildrenField());
 116       anEntityAdapterDefinition.addCalculatedField("parent", new ToOneRelationField("to_content", "content", "id"));
 117
 118       anEntityAdapterDefinition.addCalculatedField("publicurl", new ExpandedField(configuration.getString("Article.PublicUrl")));
 119
 120       anEntityAdapterDefinition.addCalculatedField("operations",
 121           new EntityToSimpleOperationsField(MirGlobal.localizer().adminInterface().simpleArticleOperations()));
 122
 123       anEntityAdapterDefinition.addCalculatedField("languagename", new ContentToLanguageNameField());
 124
 125       anEntityAdapterDefinition.addCalculatedField("is_original", new ContentIsOriginalField());
 126       anEntityAdapterDefinition.addCalculatedField("to_original", new ContentToOriginalField());
 127       anEntityAdapterDefinition.addCalculatedField("to_translations", new ContentToTranslationsField());
 128       anEntityAdapterDefinition.addCalculatedField("to_translation", new ContentToTranslationField());
 129
 130       anEntityAdapterDefinition.addCalculatedField("allow_publication",
 131           new EntityAdapterDefinition.CalculatedField() {
 132
 133             public Object getValue(EntityAdapter anEntityAdapter) {
 134               try {
 135                 return new Boolean(MirGlobal.localizer().openPostings().
 136                     allowArticlePublication((EntityContent) anEntityAdapter.getEntity()));
 137               }
 138               catch (Throwable t) {
 139                 return  Boolean.FALSE;
 140               }
 141             }
 142           }
 143       );
 144
 145       anEntityAdapterDefinition.addCalculatedField("previews", new EntityAdapterDefinition.CalculatedField() {
 146         public Object getValue(EntityAdapter anEntityAdapter) {
 147           try {
 148             return MirGlobal.localizer().adminInterface().getPreviewPages(anEntityAdapter);
 149           }
 150           catch (MirLocalizerExc e) {
 151             throw new Failure("Cannot get previews for article", e);
 152           }
 153         }
 154       });
 155     }
 156     catch (Throwable t) {
 157       throw new MirLocalizerFailure(t.getMessage(), t);
 158     }
 159   }
 160
 161
 162
 163   protected void constructCommentAdapterDefinition(EntityAdapterDefinition anEntityAdapterDefinition) throws MirLocalizerFailure {
 164     try {
 165       anEntityAdapterDefinition.addDBDateField("creationdate", "webdb_create", configuration.getString("Mir.DefaultTimezone"));
 166       anEntityAdapterDefinition.addCalculatedField("to_content", new ToOneRelationField("to_media", "content", "id"));
 167       anEntityAdapterDefinition.addCalculatedField("status", new CommentToStatusField());
 168
 169       anEntityAdapterDefinition.addCalculatedField("to_uploaded_media", new CommentToMediaField( "uploadedMedia" ));
 170       anEntityAdapterDefinition.addCalculatedField("to_media_images",  new CommentToMediaField( "image" ));
 171       anEntityAdapterDefinition.addCalculatedField("to_media_audio", new CommentToMediaField( "audio" ));
 172       anEntityAdapterDefinition.addCalculatedField("to_media_video", new CommentToMediaField( "video" ));
 173       anEntityAdapterDefinition.addCalculatedField("to_media_other", new CommentToMediaField( "otherMedia" ));
 174       anEntityAdapterDefinition.addCalculatedField("to_all_uploaded_media", new CommentToMediaField( "uploadedMedia", false));
 175       anEntityAdapterDefinition.addCalculatedField("to_all_media_images",  new CommentToMediaField( "image", false));
 176       anEntityAdapterDefinition.addCalculatedField("to_all_media_audio", new CommentToMediaField( "audio", false));
 177       anEntityAdapterDefinition.addCalculatedField("to_all_media_video", new CommentToMediaField( "video", false));
 178       anEntityAdapterDefinition.addCalculatedField("to_all_media_other", new CommentToMediaField( "otherMedia", false));
 179
 180       anEntityAdapterDefinition.addCalculatedField("publicurl", new ExpandedField(configuration.getString("Comment.PublicUrl")));
 181
 182       anEntityAdapterDefinition.addCalculatedField("description_parsed", new FilteredField("description"));
 183       anEntityAdapterDefinition.addCalculatedField("operations",
 184           new EntityToSimpleOperationsField(MirGlobal.localizer().adminInterface().simpleCommentOperations()));
 185     }
 186     catch (Throwable t) {
 187       throw new MirLocalizerFailure(t.getMessage(), t);
 188     }
 189   }
 190
 191   public EntityAdapterModel adapterModel() throws MirLocalizerFailure, MirLocalizerExc {
 192     EntityAdapterModel result = new EntityAdapterModel();
 193
 194     try {
 195       EntityAdapterDefinition definition;
 196
 197       definition = new EntityAdapterDefinition();
 198       constructContentAdapterDefinition( definition );
 199       result.addMapping( "content", DatabaseContent.getInstance(), definition);
 200
 201       definition = new EntityAdapterDefinition();
 202       constructCommentAdapterDefinition( definition );
 203       result.addMapping( "comment", DatabaseComment.getInstance(), definition);
 204       result.addMapping( "commentStatus", DatabaseCommentStatus.getInstance(), new EntityAdapterDefinition());
 205
 206       result.addMapping( "articleType", DatabaseArticleType.getInstance(), new EntityAdapterDefinition());
 207
 208       result.addMapping( "mediaType", DatabaseMediaType.getInstance(), new EntityAdapterDefinition());
 209
 210
 211       definition = new EntityAdapterDefinition();
 212       definition.addDBDateField("creationdate", "webdb_create", configuration.getString("Mir.DefaultTimezone"));
 213       result.addMapping( "breakingNews", DatabaseBreaking.getInstance(), definition);
 214
 215       definition = new EntityAdapterDefinition();
 216       definition.addDBDateField("creationdate", "webdb_create", configuration.getString("Mir.DefaultTimezone"));
 217       result.addMapping( "internalMessage", DatabaseMessages.getInstance(), definition);
 218
 219       definition = new EntityAdapterDefinition();
 220       definition.addCalculatedField("mediafolder", new ToOneRelationField("to_media_folder", "mediaFolder", "id"));
 221       definition.addCalculatedField("human_readable_size", new HumanReadableSizeField("value"));
 222       definition.addDBDateField("creationdate", "webdb_create", configuration.getString("Mir.DefaultTimezone"));
 223       definition.addCalculatedField("info", new MediaToMediaInfoField());
 224       result.addMapping( "uploadedMedia", DatabaseUploadedMedia.getInstance(), definition);
 225       definition = new EntityAdapterDefinition();
 226       definition.addCalculatedField("mediafolder", new ToOneRelationField("to_media_folder", "mediaFolder", "id"));
 227       definition.addCalculatedField("human_readable_size", new HumanReadableSizeField("value"));
 228       definition.addDBDateField("creationdate", "webdb_create", configuration.getString("Mir.DefaultTimezone"));
 229       definition.addCalculatedField("info", new MediaToMediaInfoField());
 230       definition.addCalculatedField("big_icon", new MediaToBigIconField());
 231       result.addMapping( "image", DatabaseImages.getInstance(), definition);
 232       definition = new EntityAdapterDefinition();
 233       definition.addCalculatedField("mediafolder", new ToOneRelationField("to_media_folder", "mediaFolder", "id"));
 234       definition.addCalculatedField("human_readable_size", new HumanReadableSizeField("value"));
 235       definition.addDBDateField("creationdate", "webdb_create", configuration.getString("Mir.DefaultTimezone"));
 236       definition.addCalculatedField("info", new MediaToMediaInfoField());
 237       definition.addCalculatedField("big_icon", new MediaToBigIconField());
 238       result.addMapping( "audio", DatabaseAudio.getInstance(), definition);
 239       definition = new EntityAdapterDefinition();
 240       definition.addCalculatedField("mediafolder", new ToOneRelationField("to_media_folder", "mediaFolder", "id"));
 241       definition.addCalculatedField("human_readable_size", new HumanReadableSizeField("value"));
 242       definition.addDBDateField("creationdate", "webdb_create", configuration.getString("Mir.DefaultTimezone"));
 243       definition.addCalculatedField("info", new MediaToMediaInfoField());
 244       definition.addCalculatedField("big_icon", new MediaToBigIconField());
 245       result.addMapping( "video", DatabaseVideo.getInstance(), definition);
 246
 247       definition = new EntityAdapterDefinition();
 248       definition.addCalculatedField("mediafolder", new ToOneRelationField("to_media_folder", "mediaFolder", "id"));
 249       definition.addCalculatedField("human_readable_size", new HumanReadableSizeField("value"));
 250       definition.addDBDateField("creationdate", "webdb_create", configuration.getString("Mir.DefaultTimezone"));
 251       definition.addCalculatedField("info", new MediaToMediaInfoField());
 252       definition.addCalculatedField("big_icon", new MediaToBigIconField());
 253       result.addMapping( "otherMedia", DatabaseOther.getInstance(), definition);
 254
 255
 256       result.addMapping( "mediaFolder", DatabaseMediafolder.getInstance(), new EntityAdapterDefinition());
 257       result.addMapping( "imageType", DatabaseImageType.getInstance(), new EntityAdapterDefinition());
 258       result.addMapping( "language", DatabaseLanguage.getInstance(), new EntityAdapterDefinition());
 259       result.addMapping( "mediaType", DatabaseMediaType.getInstance(), new EntityAdapterDefinition());
 260       result.addMapping( "topic", DatabaseTopics.getInstance(), new EntityAdapterDefinition());
 261
 262       definition = new EntityAdapterDefinition();
 263       definition.addDBDateField("creationdate", "webdb_create", configuration.getString("Mir.DefaultTimezone"));
 264       definition.addDBDateField("lastlogindate", "lastlogin", configuration.getString("Mir.DefaultTimezone"));
 265       definition.addCalculatedField("structuredProfile", new StructuredContentField("profile"));
 266       result.addMapping( "user", DatabaseUsers.getInstance(), definition);
 267
 268       result.addMapping( "content_x_topic", DatabaseContentToTopics.getInstance(), new EntityAdapterDefinition());
 269
 270       definition = new EntityAdapterDefinition();
 271       definition.addCalculatedField("to_filters",
 272           new ToManyRelationField("id", "filter", "filter_group_id", "priority asc"));
 273       result.addMapping("filterGroup", DatabaseFilterGroup.getInstance(), definition);
 274       definition = new EntityAdapterDefinition();
 275       definition.addDBDateField("lasthit", "last_hit", configuration.getString("Mir.DefaultTimezone"));
 276       definition.addCalculatedField("to_filter_group",
 277           new ToOneRelationField("filter_group_id", "filter_group", "id"));
 278       result.addMapping("filter", DatabaseFilter.getInstance(), definition);
 279     }
 280     catch (Throwable t) {
 281       throw new MirLocalizerFailure(t.getMessage(), t);
 282     }
 283
 284     return result;
 285   }
 286
 287   protected class CommentToStatusField implements EntityAdapterDefinition.CalculatedField {
 288     public Object getValue(EntityAdapter anEntityAdapter) {
 289       try {
 290         return anEntityAdapter.getToOneRelation(
 291                     "id="+anEntityAdapter.get("to_comment_status"),
 292                     "id",
 293                     "commentStatus" );
 294       }
 295       catch (Throwable t) {
 296         throw new RuntimeException(t.getMessage());
 297       }
 298     }
 299   }
 300
 301   protected class EntityToSimpleOperationsField implements EntityAdapterDefinition.CalculatedField {
 302     private List operations;
 303
 304     public EntityToSimpleOperationsField(List anOperations) {
 305       operations = anOperations;
 306     }
 307
 308     public Object getValue(EntityAdapter anEntityAdapter) {
 309       try {
 310         Iterator i = operations.iterator();
 311         List availableOperations = new ArrayList();
 312
 313         while (i.hasNext()) {
 314           MirAdminInterfaceLocalizer.MirSimpleEntityOperation operation =
 315             (MirAdminInterfaceLocalizer.MirSimpleEntityOperation) i.next();
 316
 317           if (operation.isAvailable(anEntityAdapter)) {
 318             availableOperations.add(operation.getName());
 319           }
 320         }
 321
 322         return availableOperations;
 323       }
 324       catch (Throwable t) {
 325         throw new RuntimeException(t.getMessage());
 326       }
 327     }
 328   }
 329
 330   protected class FilteredField implements EntityAdapterDefinition.CalculatedField {
 331     private String fieldName;
 332
 333     public FilteredField(String aFieldName) {
 334       fieldName = aFieldName;
 335     }
 336
 337     public Object getValue(EntityAdapter anEntityAdapter) {
 338       try {
 339         if (anEntityAdapter.get("is_html")!=null && anEntityAdapter.get("is_html").equals("1")) {
 340           return MirGlobal.localizer().producerAssistant().filterHTMLText((String) anEntityAdapter.get(fieldName));
 341         }
 342                                 return MirGlobal.localizer().producerAssistant().filterNonHTMLText((String) anEntityAdapter.get(fieldName));
 343       }
 344       catch (Throwable t) {
 345         throw new RuntimeException(t.getMessage());
 346       }
 347     }
 348   }
 349
 350   protected class StructuredContentField implements EntityAdapterDefinition.CalculatedField {
 351     private String expression;
 352
 353     public StructuredContentField(String anExpression) {
 354       expression = anExpression;
 355     }
 356
 357     public Object getValue(EntityAdapter anEntityAdapter) {
 358       try {
 359         return StructuredContentParser.parse(ParameterExpander.evaluateStringExpression(anEntityAdapter, expression));
 360       }
 361       catch (Throwable t) {
 362         throw new RuntimeException(t.getMessage());
 363       }
 364     }
 365   }
 366
 367   protected class ExpandedField implements EntityAdapterDefinition.CalculatedField {
 368     private String expression;
 369
 370     public ExpandedField(String anExpression) {
 371       expression = anExpression;
 372     }
 373
 374     public Object getValue(EntityAdapter anEntityAdapter) {
 375       try {
 376         return ParameterExpander.expandExpression(anEntityAdapter, expression);
 377       }
 378       catch (Throwable t) {
 379         throw new RuntimeException(t.getMessage());
 380       }
 381     }
 382   }
 383
 384   protected class EvaluatedField implements EntityAdapterDefinition.CalculatedField {
 385     private String expression;
 386
 387     public EvaluatedField(String anExpression) {
 388       expression = anExpression;
 389     }
 390
 391     public Object getValue(EntityAdapter anEntityAdapter) {
 392       try {
 393         return ParameterExpander.evaluateExpression(anEntityAdapter, expression);
 394       }
 395       catch (Throwable t) {
 396         throw new RuntimeException(t.getMessage());
 397       }
 398     }
 399   }
 400
 401   protected class ContentToChildrenField implements EntityAdapterDefinition.CalculatedField {
 402     public Object getValue(EntityAdapter anEntityAdapter) {
 403       try {
 404         return anEntityAdapter.getRelation(
 405                     "to_content="+anEntityAdapter.get("id"),
 406                     "id",
 407                     "content" );
 408       }
 409       catch (Throwable t) {
 410         throw new RuntimeException(t.getMessage());
 411       }
 412     }
 413   }
 414   public static class MediaInfo {
 415     private MediaHandler mediaHandler;
 416
 417     public MediaInfo(MediaHandler aHandler) {
 418       mediaHandler = aHandler;
 419     }
 420     public String getBigIcon() {
 421       if (mediaHandler == null)
 422         return "bla";
 423                         return mediaHandler.getBigIconName();
 424     }
 425
 426     public String getSmallIcon() {
 427       if (mediaHandler == null)
 428         return "bla";
 429                         return mediaHandler.getTinyIconName();
 430     }
 431
 432     public String getMediaType() {
 433       return "";
 434     }
 435   }
 436
 437   protected class MediaToMediaInfoField implements EntityAdapterDefinition.CalculatedField {
 438     public Object getValue(EntityAdapter anEntityAdapter) {
 439       try {
 440         MediaHandler mediaHandler = MediaHelper.getHandler(((EntityUploadedMedia) anEntityAdapter.getEntity()).getMediaType());
 441
 442         return new MediaInfo(mediaHandler);
 443       }
 444       catch (Throwable t) {
 445         throw new RuntimeException(t.getMessage());
 446       }
 447     }
 448   }
 449
 450   protected class MediaToBigIconField implements EntityAdapterDefinition.CalculatedField {
 451     public Object getValue(EntityAdapter anEntityAdapter) {
 452       try {
 453         return MediaHelper.getHandler(((EntityUploadedMedia) anEntityAdapter.getEntity()).getMediaType()).getBigIconName();
 454       }
 455       catch (Throwable t) {
 456         throw new RuntimeException(t.getMessage());
 457       }
 458     }
 459   }
 460
 461   protected class ContentToCommentsField implements EntityAdapterDefinition.CalculatedField {
 462     private String extracondition;
 463     private String order;
 464
 465     public ContentToCommentsField() {
 466       this ( " and is_published='1'", "webdb_create");
 467     }
 468
 469     public ContentToCommentsField(String anExtraCondition, String anOrder) {
 470       order = anOrder;
 471       extracondition = anExtraCondition;
 472     }
 473
 474     public Object getValue(EntityAdapter anEntityAdapter) {
 475       try {
 476         return anEntityAdapter.getRelation(
 477                     "to_media="+anEntityAdapter.get("id")+" " + extracondition,
 478                     order,
 479                     "comment" );
 480       }
 481       catch (Throwable t) {
 482         throw new RuntimeException(t.getMessage());
 483       }
 484     }
 485   }
 486
 487   protected class ContentToTopicsField implements EntityAdapterDefinition.CalculatedField {
 488     private String topicCondition;
 489     private String topicOrder;
 490
 491     public ContentToTopicsField() {
 492       this(null);
 493     }
 494
 495     public ContentToTopicsField(String aTopicCondition) {
 496       this(aTopicCondition, "title");
 497     }
 498
 499     public ContentToTopicsField(String aTopicCondition, String aTopicOrder) {
 500       topicCondition = aTopicCondition;
 501       topicOrder = aTopicOrder;
 502     }
 503
 504     public Object getValue(EntityAdapter anEntityAdapter) {
 505       try {
 506
 507
 508         String condition = "cxt.content_id="+anEntityAdapter.get("id")+
 509           " and cxt.topic_id=t.id";
 510
 511         if (topicCondition!=null && topicCondition.length()>0)
 512           condition = "(" + topicCondition + ") and " + condition;
 513
 514         return anEntityAdapter.getComplexRelation("t", Collections.singletonList("content_x_topic cxt"),
 515                     condition, topicOrder, "topic" );
 516       }
 517       catch (Throwable t) {
 518         throw new RuntimeException(t.getMessage());
 519       }
 520     }
 521   }
 522
 523   protected class ContentToMediaField implements EntityAdapterDefinition.CalculatedField {
 524     private String definition;
 525     private boolean published;
 526
 527     public ContentToMediaField(String aDefinition, boolean anOnlyPublished) {
 528       definition = aDefinition;
 529       published = anOnlyPublished;
 530     }
 531
 532     public ContentToMediaField(String aDefinition) {
 533       this(aDefinition, true);
 534     }
 535
 536     public Object getValue(EntityAdapter anEntityAdapter) {
 537       try {
 538         String condition = "cxm.content_id="+ anEntityAdapter.get("id") +
 539           " and cxm.media_id = m.id";
 540
 541         if (published) {
 542           condition = "is_published='t' and " + condition;
 543         }
 544
 545         List extraTables = new ArrayList();
 546         extraTables.add("content_x_media cxm");
 547
 548         return anEntityAdapter.getComplexRelation("m", extraTables, condition, "id", definition);
 549       }
 550       catch (Throwable t) {
 551         throw new RuntimeException(t.getMessage());
 552       }
 553     }
 554   }
 555
 556   protected class ContentToFirstMediaField implements EntityAdapterDefinition.CalculatedField {
 557     private String definition;
 558     private boolean published;
 559
 560     public ContentToFirstMediaField(String aDefinition, boolean anOnlyPublished) {
 561       definition = aDefinition;
 562       published = anOnlyPublished;
 563     }
 564
 565     public ContentToFirstMediaField(String aDefinition) {
 566       this(aDefinition, true);
 567     }
 568
 569     public Object getValue(EntityAdapter anEntityAdapter) {
 570       try {
 571         String condition = "cxm.content_id="+ anEntityAdapter.get("id") +
 572           " and cxm.media_id = m.id";
 573         if (published)
 574           condition = "is_published='t' and " + condition;
 575
 576         List extraTables = new ArrayList();
 577         extraTables.add("content_x_media cxm");
 578
 579         return anEntityAdapter.getComplexToOneRelation("m", extraTables, condition, "id", definition);
 580       }
 581       catch (Throwable t) {
 582         throw new RuntimeException(t.getMessage());
 583       }
 584     }
 585   }
 586
 587   protected class CommentToMediaField implements EntityAdapterDefinition.CalculatedField {
 588     private String definition;
 589     private boolean published;
 590
 591     public CommentToMediaField(String aDefinition, boolean anOnlyPublished) {
 592       definition = aDefinition;
 593       published = anOnlyPublished;
 594     }
 595
 596     public CommentToMediaField(String aDefinition) {
 597       this(aDefinition, true);
 598     }
 599
 600     public Object getValue(EntityAdapter anEntityAdapter) {
 601       try {
 602
 603         String condition = "cxm.comment_id = " + anEntityAdapter.get("id") + " and cxm.media_id = m.id";
 604
 605         if (published) {
 606            condition = "is_published='t' and " + condition;
 607         }
 608
 609         return anEntityAdapter.getComplexRelation("m", Collections.singletonList("comment_x_media cxm"),
 610             condition, "id", definition);
 611       }
 612       catch (Throwable t) {
 613         throw new RuntimeException(t.getMessage());
 614       }
 615     }
 616   }
 617
 618   protected class ContentToIconField implements EntityAdapterDefinition.CalculatedField {
 619     public Object getValue(EntityAdapter anEntityAdapter) {
 620       String tinyIcon;
 621       String iconAlt;
 622
 623       try {
 624         tinyIcon = MirGlobal.config().getString("Producer.Icon.TinyText");
 625         iconAlt = "Text";
 626
 627         Iterator iterator = anEntityAdapter.getIterator("to_media_video");
 628         if (!iterator.hasNext()) {
 629           iterator = anEntityAdapter.getIterator("to_media_audio");
 630         }
 631         if (!iterator.hasNext()) {
 632           iterator = anEntityAdapter.getIterator("to_media_images");
 633         }
 634         if (!iterator.hasNext()) {
 635           iterator = anEntityAdapter.getIterator("to_media_other");
 636         }
 637
 638         if (iterator.hasNext()) {
 639           EntityAdapter media = (EntityAdapter) iterator.next();
 640
 641           Entity mediaType = ((EntityUploadedMedia) (media.getEntity())).getMediaType();
 642           MediaHandler mediaHandler = MediaHelper.getHandler(mediaType);
 643
 644           tinyIcon = mediaHandler.getTinyIconName();
 645           iconAlt = mediaHandler.getIconAltName();
 646         }
 647       }
 648       catch (Throwable t) {
 649         logger.error("ContentToIconField: ", t);
 650
 651         throw new RuntimeException(t.getMessage());
 652       }
 653
 654       Map result = new HashMap();
 655       result.put("tiny_icon", MirGlobal.config().getString("Producer.ImageRoot") + "/" + tinyIcon);
 656       result.put("icon_alt", iconAlt);
 657
 658       return result;
 659     }
 660   }
 661
 662   protected class ContentCommentCountField implements EntityAdapterDefinition.CalculatedField {
 663     private String extraCondition;
 664
 665     public ContentCommentCountField(String anExtraCondition) {
 666       super();
 667
 668       extraCondition = anExtraCondition;
 669     }
 670
 671     public Object getValue(EntityAdapter anEntityAdapter) {
 672       try {
 673         return Integer.toString(
 674             DatabaseComment.getInstance().getSize(
 675                   "to_media="+anEntityAdapter.get("id")+" " + extraCondition));
 676       }
 677       catch (Throwable t) {
 678         throw new RuntimeException(t.getMessage());
 679       }
 680     }
 681   }
 682
 683   protected class HumanReadableSizeField implements EntityAdapterDefinition.CalculatedField {
 684       private String fieldName;
 685
 686       public HumanReadableSizeField(String aFieldName) {
 687         fieldName= aFieldName;
 688       }
 689
 690       public Object getValue(EntityAdapter anEntityAdapter) {
 691         try {
 692           String size = (String) anEntityAdapter.get(fieldName);
 693           if (size!=null)
 694             return NumberUtils.humanReadableSize(Double.parseDouble(size));
 695                                         return "";
 696         }
 697         catch (Throwable t) {
 698           throw new RuntimeException(t.getMessage());
 699         }
 700       }
 701     }
 702
 703
 704   protected class ContentMediaCountField implements EntityAdapterDefinition.CalculatedField {
 705     private String table;
 706     private boolean published;
 707
 708     public ContentMediaCountField(String aTable, boolean anOnlyPublished) {
 709       table = aTable;
 710       published = anOnlyPublished;
 711     }
 712
 713     public ContentMediaCountField(String aTable) {
 714       this(aTable, true);
 715     }
 716
 717     public Object getValue(EntityAdapter anEntityAdapter) {
 718       try {
 719         ArrayList extraTable = new ArrayList();
 720         extraTable.add(table+" m");
 721         String selectSql = "cxm.media_id=m.id and cxm.content_id="+
 722           anEntityAdapter.get("id");
 723         if (published)
 724           selectSql+= " and m.is_published='t'";
 725
 726         return Integer.toString(
 727             DatabaseContentToMedia.getInstance().getSize(
 728               "cxm", extraTable, selectSql));
 729       }
 730       catch (Throwable t) {
 731         throw new RuntimeException(t.getMessage());
 732       }
 733     }
 734   }
 735
 736   protected class ContentToIsLockedField implements EntityAdapterDefinition.CalculatedField {
 737     private ModuleContent contentModule;
 738
 739     public ContentToIsLockedField() {
 740       contentModule = new ModuleContent();
 741     }
 742
 743     public Object getValue(EntityAdapter anEntityAdapter) {
 744       try {
 745         return new Boolean(contentModule.queryArticleLock(anEntityAdapter.getEntity().getId())!=null);
 746       }
 747       catch (Throwable t) {
 748         throw new RuntimeException(t.getMessage());
 749       }
 750     }
 751   }
 752     protected class ContentIsOriginalField implements EntityAdapterDefinition.CalculatedField {
 753     public Object getValue(EntityAdapter anEntityAdapter) throws MirLocalizerFailure {
 754       try {
 755
 756         //ML: add check on article type
 757         boolean result = (anEntityAdapter.get("parent")==null);
 758
 759         return new Boolean(result);
 760       }
 761       catch (Throwable t) {
 762         throw new MirLocalizerFailure(t);
 763       }
 764     }
 765   }
 766
 767   protected class ContentToOriginalField implements EntityAdapterDefinition.CalculatedField {
 768     public Object getValue(EntityAdapter anEntityAdapter) throws MirLocalizerFailure {
 769       try {
 770         if (anEntityAdapter.get("parent")!=null)
 771           return anEntityAdapter.get("parent");
 772                                 return anEntityAdapter;
 773       }
 774       catch (Throwable t) {
 775         throw new MirLocalizerFailure(t);
 776       }
 777     }
 778   }
 779
 780   protected class ContentToTranslationsField implements EntityAdapterDefinition.CalculatedField {
 781     public Object getValue(EntityAdapter anEntityAdapter) {
 782       try {
 783         return anEntityAdapter.getRelation(
 784                     "is_published='t' and to_content="+anEntityAdapter.get("id"),
 785                     "id",
 786                     "content" );
 787       }
 788       catch (Throwable t) {
 789         throw new RuntimeException(t.getMessage());
 790       }
 791     }
 792   }
 793
 794   protected class ContentToLanguageNameField implements EntityAdapterDefinition.CalculatedField {
 795     public Object getValue(EntityAdapter anEntityAdapter) throws MirLocalizerFailure {
 796       try {
 797         String result = "";
 798         EntityAdapter language = (EntityAdapter) anEntityAdapter.get("language");
 799         if (language != null) {
 800           if (language.get("code").equals("ot")) {
 801             result = ((String) anEntityAdapter.get("subtitle")).trim();
 802             if (result == null || result.equals(""))
 803               result = (String) language.get("name");
 804           } else {
 805             result = (String) language.get("name");
 806           }
 807         }
 808
 809         return result;
 810       }
 811       catch (Throwable t) {
 812         throw new MirLocalizerFailure(t);
 813       }
 814     }
 815   }
 816
 817   protected class ContentToTranslationFunction implements Generator.Function {
 818     private EntityAdapter target;
 819     private String targetId;
 820     private String targetLanguageId;
 821
 822     public ContentToTranslationFunction(EntityAdapter aTarget) {
 823       target = aTarget;
 824       targetId = (String) target.get("id");
 825       targetLanguageId = (String) target.get("to_language");
 826     }
 827
 828     public Object perform(List aParameters) throws GeneratorExc, GeneratorFailure {
 829       if (aParameters.size()!=1 || !(aParameters.get(0) instanceof String))
 830         throw new GeneratorExc("1 string parameter expected");
 831
 832       try {
 833         String language = (String) aParameters.get(0);
 834         String languageId = languageModule.languageIdForCode(language);
 835         Object result = null;
 836
 837         if (languageId != null && !targetLanguageId.equals(languageId)) {
 838           result = target.getToOneRelation(
 839               "is_published='t' and to_content=" + targetId + " and to_language='" + JDBCStringRoutines.escapeStringLiteral(languageId) + "'",
 840               "id", "content");
 841         }
 842
 843         if (result == null)
 844           result = target;
 845
 846         return result;
 847       }
 848       catch (Throwable t) {
 849         t.printStackTrace(System.out);
 850         throw new GeneratorFailure(t);
 851       }
 852     }
 853   }
 854
 855   protected class ContentToTranslationField implements EntityAdapterDefinition.CalculatedField {
 856     public Object getValue(EntityAdapter anEntityAdapter) throws MirLocalizerFailure {
 857       try {
 858         return new ContentToTranslationFunction((EntityAdapter) anEntityAdapter.get("to_original"));
 859       }
 860       catch (Throwable t) {
 861         throw new MirLocalizerFailure(t);
 862       }
 863     }
 864   }
 865 }
 866