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