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