cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/DefinedTermBase.java

   1 /**
   2 * Copyright (C) 2007 EDIT
   3 * European Distributed Institute of Taxonomy
   4 * http://www.e-taxonomy.eu
   5 *
   6 * The contents of this file are subject to the Mozilla Public License Version 1.1
   7 * See LICENSE.TXT at the top of this package for the full license terms.
   8 */
   9
  10 package eu.etaxonomy.cdm.model.common;
  11
  12 import org.apache.log4j.Logger;
  13 import org.hibernate.annotations.Cascade;
  14 import org.hibernate.annotations.CascadeType;
  15 import org.springframework.beans.factory.annotation.Autowired;
  16
  17 import au.com.bytecode.opencsv.CSVWriter;
  18 import eu.etaxonomy.cdm.model.common.init.TermLoader;
  19
  20 import java.util.*;
  21
  22 import javax.persistence.*;
  23
  24 /**
  25  * workaround for enumerations, base type according to TDWG.  For linear ordering
  26  * use partOf relation and BreadthFirst. Default iterator order should therefore
  27  * be BreadthFirst (not DepthFirst)
  28  * @author m.doering
  29  * @version 1.0
  30  * @created 08-Nov-2007 13:06:19
  31  */
  32 @Entity
  33 @Inheritance(strategy=InheritanceType.SINGLE_TABLE)
  34 public abstract class DefinedTermBase extends TermBase implements IDefTerm{
  35         static Logger logger = Logger.getLogger(DefinedTermBase.class);
  36         //public static IDefinedTermDao dao;
  37         //public static ITermService termService;
  38         //Map for preloading all DefinedTerms
  39         static protected Map<UUID, DefinedTermBase> definedTermsMap = null;
  40
  41         private DefinedTermBase kindOf;
  42         private Set<DefinedTermBase> generalizationOf = new HashSet<DefinedTermBase>();
  43         private DefinedTermBase partOf;
  44         private Set<DefinedTermBase> includes = new HashSet<DefinedTermBase>();
  45         private Set<Media> media = new HashSet<Media>();
  46         private TermVocabulary vocabulary;
  47
  48         public static void initTermList(ITermLister termLister){
  49                 logger.debug("initTermList");
  50                 if (definedTermsMap == null){
  51                         if (termLister == null){   //e.g. when used in tests with no database connection
  52                                 definedTermsMap = new HashMap<UUID, DefinedTermBase>();
  53                                 try {
  54                                         String strUuidEnglish = "e9f8cdb7-6819-44e8-95d3-e2d0690c3523";
  55                                         UUID uuidEnglish = UUID.fromString(strUuidEnglish);
  56                                         Language english = new Language(uuidEnglish);
  57                                         definedTermsMap.put(english.getUuid(), english);
  58                                         TermLoader.setDefinedTermsMap(definedTermsMap);
  59                                         new TermLoader().loadAllDefaultTerms();
  60                                 } catch (Exception e) {
  61                                         logger.error("Error ocurred when loading terms");
  62                                 }
  63
  64                         }else{
  65                                 List<DefinedTermBase> list = termLister.listTerms();
  66                                 definedTermsMap = new HashMap<UUID, DefinedTermBase>();
  67                                 for (DefinedTermBase dtb: list){
  68                                         definedTermsMap.put(dtb.getUuid(), dtb);
  69                                 }
  70                         }
  71                 }
  72                 logger.debug("initTermList - end");
  73         }
  74
  75         public static DefinedTermBase findByUuid(UUID uuid){
  76                 //in tests tems may no be initialised by database access
  77                 if (!isInitialized()){
  78                         initTermList(null);
  79                 }
  80                 return definedTermsMap.get(uuid);
  81         }
  82
  83         public static boolean isInitialized(){
  84                 return (definedTermsMap != null);
  85         }
  86
  87         public static Map<UUID, DefinedTermBase> getDefinedTerms(){
  88                 return definedTermsMap;
  89         }
  90
  91
  92 //      public static void setDao(IDefinedTermDao dao) {
  93 //              logger.warn("Setting DefinedTerm static dao");
  94 //              DefinedTermBase.dao = dao;
  95 //      }
  96 //
  97 //      public static void setService(ITermService service) {
  98 //              logger.warn("Setting DefinedTerm static service");
  99 //              DefinedTermBase.termService = service;
 100 //      }
 101
 102         public DefinedTermBase() {
 103                 super();
 104         }
 105         public DefinedTermBase(String term, String label) {
 106                 super(term, label);
 107         }
 108
 109
 110         /* (non-Javadoc)
 111          * @see eu.etaxonomy.cdm.model.common.IDefTerm#readCsvLine(java.util.List)
 112          */
 113         public void readCsvLine(List<String> csvLine) {
 114                 readCsvLine(csvLine, Language.ENGLISH());
 115         }
 116         public void readCsvLine(List<String> csvLine, Language lang) {
 117                 this.setUuid(UUID.fromString(csvLine.get(0)));
 118                 this.setUri(csvLine.get(1));
 119                 this.addRepresentation(new Representation(csvLine.get(3), csvLine.get(2).trim(), lang) );
 120         }
 121
 122         /* (non-Javadoc)
 123          * @see eu.etaxonomy.cdm.model.common.IDefTerm#writeCsvLine(au.com.bytecode.opencsv.CSVWriter)
 124          */
 125         public void writeCsvLine(CSVWriter writer) {
 126                 String [] line = new String[4];
 127                 line[0] = getUuid().toString();
 128                 line[1] = getUri();
 129                 line[2] = getLabel();
 130                 line[3] = getDescription();
 131                 writer.writeNext(line);
 132         }
 133
 134         @Transient
 135         //@ManyToOne
 136         //@Cascade({CascadeType.SAVE_UPDATE})
 137         public DefinedTermBase getKindOf(){
 138                 return this.kindOf;
 139         }
 140         public void setKindOf(DefinedTermBase kindOf){
 141                 this.kindOf = kindOf;
 142         }
 143
 144         @Transient
 145         //@OneToMany(fetch=FetchType.LAZY)
 146         //@Cascade({CascadeType.SAVE_UPDATE})
 147         public Set<DefinedTermBase> getGeneralizationOf(){
 148                 return this.generalizationOf;
 149         }
 150         public void setGeneralizationOf(Set<DefinedTermBase> generalizationOf) {
 151                 this.generalizationOf = generalizationOf;
 152         }
 153
 154
 155         @Transient
 156         //@ManyToOne
 157         //@Cascade({CascadeType.SAVE_UPDATE})
 158         public DefinedTermBase getPartOf(){
 159                 return this.partOf;
 160         }
 161         public void setPartOf(DefinedTermBase partOf){
 162                 this.partOf = partOf;
 163         }
 164
 165         @Transient
 166         //@OneToMany(fetch=FetchType.LAZY)
 167         //@Cascade({CascadeType.SAVE_UPDATE})
 168         public Set<DefinedTermBase> getIncludes(){
 169                 return this.includes;
 170         }
 171         public void setIncludes(Set<DefinedTermBase> includes) {
 172                 this.includes = includes;
 173         }
 174         public void addIncludes(DefinedTermBase includes) {
 175                 this.includes.add(includes);
 176         }
 177         public void removeIncludes(TermBase includes) {
 178                 this.includes.remove(includes);
 179         }
 180
 181
 182         @OneToMany
 183         @Cascade({CascadeType.SAVE_UPDATE})
 184         public Set<Media> getMedia(){
 185                 return this.media;
 186         }
 187         public void setMedia(Set<Media> media) {
 188                 this.media = media;
 189         }
 190         public void addMedia(Media media) {
 191                 this.media.add(media);
 192         }
 193         public void removeMedia(Media media) {
 194                 this.media.remove(media);
 195         }
 196
 197
 198         /* (non-Javadoc)
 199          * @see eu.etaxonomy.cdm.model.common.IDefTerm#getVocabulary()
 200          */
 201         @ManyToOne(fetch=FetchType.EAGER)
 202         @Cascade( { CascadeType.SAVE_UPDATE })
 203         public TermVocabulary getVocabulary() {
 204                 return this.vocabulary;
 205         }
 206         /* (non-Javadoc)
 207          * @see eu.etaxonomy.cdm.model.common.IDefTerm#setVocabulary(eu.etaxonomy.cdm.model.common.TermVocabulary)
 208          */
 209         public void setVocabulary(TermVocabulary newVocabulary) {
 210                 // Hibernate bidirectional cascade hack:
 211                 // http://opensource.atlassian.com/projects/hibernate/browse/HHH-1054
 212                 if(this.vocabulary == newVocabulary) return;
 213                 if (this.vocabulary != null) {
 214                         this.vocabulary.terms.remove(this);
 215                 }
 216                 if (newVocabulary!= null) {
 217                         newVocabulary.terms.add(this);
 218                 }
 219                 this.vocabulary = newVocabulary;
 220         }
 221
 222 }