eu.etaxonomy.taxeditor.store/src/main/java/eu/etaxonomy/taxeditor/store/UseObjectStore.java

   1 /**
   2 * Copyright (C) 2011 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 package eu.etaxonomy.taxeditor.store;
  10
  11 import java.net.URISyntaxException;
  12
  13 import org.eclipse.core.runtime.IProgressMonitor;
  14 import org.eclipse.core.runtime.NullProgressMonitor;
  15
  16 import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
  17 import eu.etaxonomy.cdm.api.service.ITermService;
  18 import eu.etaxonomy.cdm.api.service.IVocabularyService;
  19 import eu.etaxonomy.cdm.common.URI;
  20 import eu.etaxonomy.cdm.model.common.MarkerType;
  21 import eu.etaxonomy.cdm.model.description.Feature;
  22 import eu.etaxonomy.cdm.model.description.State;
  23 import eu.etaxonomy.cdm.model.term.DefinedTerm;
  24 import eu.etaxonomy.cdm.model.term.OrderedTermVocabulary;
  25 import eu.etaxonomy.cdm.model.term.TermType;
  26 import eu.etaxonomy.cdm.model.term.TermVocabulary;
  27
  28 /**
  29  * A store to handle all terms and vocabulary required for
  30  * the UseObjects view and components.
  31  * Whenever one of the terms is requested, all required terms are generated
  32  * in the database as we consider the requests as an indicator that
  33  * someone wants to use the terms.
  34  * This
  35  * @author a.theys
  36  * @author a.mueller
  37  * @created mar 13, 2012
  38  */
  39 public class UseObjectStore {
  40
  41         private static boolean isInitialized;
  42
  43         private static MarkerType useMarkerType;
  44         private static Feature useSummaryFeature;
  45         private static Feature useRecordFeature;
  46
  47         public static void reset() {
  48                 isInitialized = false;
  49                 useMarkerType = null;
  50                 useSummaryFeature = null;
  51                 useRecordFeature = null;
  52         }
  53
  54         public static MarkerType getUseMarkerType() {
  55                 initialize();
  56                 return useMarkerType;
  57         }
  58
  59         public static Feature getUseSummaryFeature() {
  60                 initialize();
  61                 return useSummaryFeature;
  62         }
  63
  64         public static Feature getUseRecordFeature() {
  65                 initialize();
  66                 return useRecordFeature;
  67         }
  68
  69
  70         private static void initialize(){
  71                 setupNecessaryItems(null);
  72                 isInitialized = true;
  73         }
  74
  75         private static void setupNecessaryItems( IProgressMonitor monitor ) {
  76                 if (isInitialized){
  77                         return;
  78                 }
  79                 if (monitor == null){
  80                         //TODO can we use a better one?
  81                         monitor = new NullProgressMonitor();
  82                 }
  83
  84                 //TODO remove ConversationHolder as we do not use it anymore since remoting
  85                 ConversationHolder conversation = null; //CdmStore.createConversation();
  86
  87                 //retrieve terms and vocabularies from db
  88                 useRecordFeature = (Feature) CdmStore.getService(ITermService.class).find(UsageTermCollection.uuidUseRecordFeature);
  89                 useSummaryFeature = (Feature) CdmStore.getService(ITermService.class).find(UsageTermCollection.uuidUseSummaryFeature);
  90
  91
  92
  93                 //create use marker type if not exists
  94                 createUseMarkerType(conversation);
  95
  96                 //create state vocabulary if not exists
  97                 createStateVocabulary(monitor, conversation);
  98
  99                 //create state vocabulary if not exists
 100                 createCountryVocabulary(monitor, conversation);
 101
 102                 //create plant part vocabulary
 103                 createPlantVocabulary(monitor, conversation);
 104
 105                 //create human group vocabulary
 106                 createHumanGroupVocabulary(monitor, conversation);
 107
 108                 if(useRecordFeature == null || useSummaryFeature == null) {
 109                         TermVocabulary<Feature> featureVocabulary = CdmStore.getService(IVocabularyService.class).find((UsageTermCollection.uuidFeatureVocabulary));
 110 //                      FeatureTree palmWebFeatureTree = CdmStore.getService(ITermTreeService.class).find(UsageTermCollection.uuidPalmWebFeatureTree);
 111
 112                         if (useRecordFeature == null ) {
 113                                 useRecordFeature = Feature.NewInstance(UsageTermCollection.useRecordFeatureLabel, UsageTermCollection.useRecordFeatureLabel, null);
 114                                 useRecordFeature.setUuid(UsageTermCollection.uuidUseRecordFeature);
 115                                 useRecordFeature.setSupportsCategoricalData(true);
 116                                 featureVocabulary.addTerm(useRecordFeature);
 117
 118 //                              if (palmWebFeatureTree != null){
 119 //                                      FeatureNode useRecFeatureNode = FeatureNode.NewInstance(featureUseRecord);
 120 //                                      palmWebFeatureTree.getRoot().addChild(useRecFeatureNode);
 121 //                              }else{
 122 //                                      StoreUtil.warn(getClass(), "No current feature tree available to add useRecord feature");
 123 //                              }
 124                         }
 125                         if (useSummaryFeature == null) {
 126                                 useSummaryFeature = Feature.NewInstance(UsageTermCollection.useSummaryFeatureLabel, UsageTermCollection.useSummaryFeatureLabel, null);
 127                                 useSummaryFeature.setUuid(UsageTermCollection.uuidUseSummaryFeature);
 128                                 useSummaryFeature.setSupportsTextData(true);
 129                                 featureVocabulary.addTerm(useSummaryFeature);
 130 //                              if (palmWebFeatureTree != null){
 131 //                                      FeatureNode useSumFeatureNode = FeatureNode.NewInstance(featureUseSummary);
 132 //                                      palmWebFeatureTree.getRoot().addChild(useSumFeatureNode);
 133 //                              }else{
 134 //                                      StoreUtil.warn(getClass(), "No current feature tree available to add use summary feature");
 135 //                              }
 136                         }
 137
 138                         CdmStore.getService(IVocabularyService.class).saveOrUpdate(featureVocabulary);
 139 //                      if (palmWebFeatureTree != null){
 140 //                              CdmStore.getService(ITermTreeService.class).saveOrUpdate(palmWebFeatureTree);
 141 //                      }
 142
 143 //                      conversation.commit(true);
 144
 145                 }
 146 //              conversation.close();
 147         }
 148
 149         private static void createHumanGroupVocabulary(IProgressMonitor monitor,ConversationHolder conversation) {
 150                 TermVocabulary<DefinedTerm> humanGroupVocabulary = CdmStore.getService(IVocabularyService.class).find(UsageTermCollection.uuidHumanGroupVocabulary);
 151                 if (humanGroupVocabulary == null){
 152                         monitor.subTask("create human group vocabulary");
 153                         URI termSourceUri = null;
 154                         try {
 155                                 termSourceUri = new URI("eu.etaxonomy.cdm.model.description.DefinedTerm");
 156                         } catch (URISyntaxException e) {
 157                                 e.printStackTrace();
 158                         }
 159
 160                         humanGroupVocabulary = TermVocabulary.NewInstance(TermType.Modifier, DefinedTerm.class, UsageTermCollection.humanGroupLabel, UsageTermCollection.humanGroupLabel, null, termSourceUri);
 161                         humanGroupVocabulary.setUuid(UsageTermCollection.uuidHumanGroupVocabulary);
 162
 163                         DefinedTerm newDummyModifier = DefinedTerm.NewInstance(TermType.Modifier, UsageTermCollection.notAvailableLabel, UsageTermCollection.notAvailableLabel, null);
 164                         newDummyModifier.setUuid(UsageTermCollection.uuidHumanGroupDummy);
 165
 166                         DefinedTerm newSubDummyModifier = DefinedTerm.NewInstance(TermType.Modifier, UsageTermCollection.notAvailableLabel, UsageTermCollection.notAvailableLabel, null);
 167                         newSubDummyModifier.setUuid(UsageTermCollection.uuidEthnicGroupDummy);
 168                         newDummyModifier.addIncludes(newSubDummyModifier);
 169                         humanGroupVocabulary.addTerm(newDummyModifier);
 170
 171                         CdmStore.getService(IVocabularyService.class).saveOrUpdate(humanGroupVocabulary);
 172                         conversation.commit(true);
 173                 }
 174         }
 175
 176         private static void createPlantVocabulary(IProgressMonitor monitor, ConversationHolder conversation) {
 177                 TermVocabulary<DefinedTerm> plantPartVocabulary = CdmStore.getService(IVocabularyService.class).find(UsageTermCollection.uuidPlantPartVocabulary);
 178                 if (plantPartVocabulary == null){
 179                         monitor.subTask("create plant part vocabulary");
 180                         URI termSourceUri = null;
 181                         try {
 182                                 termSourceUri = new URI("eu.etaxonomy.cdm.model.description.DefinedTerm");
 183                         } catch (URISyntaxException e) {
 184                                 e.printStackTrace();
 185                         }
 186                         plantPartVocabulary = TermVocabulary.NewInstance(TermType.Modifier, DefinedTerm.class, UsageTermCollection.plantPartLabel, UsageTermCollection.plantPartLabel, null, termSourceUri);
 187                         plantPartVocabulary.setUuid(UsageTermCollection.uuidPlantPartVocabulary);
 188
 189                         DefinedTerm newDummyModifier = DefinedTerm.NewInstance(TermType.Modifier, UsageTermCollection.notAvailableLabel, UsageTermCollection.notAvailableLabel, null);
 190                         newDummyModifier.setUuid(UsageTermCollection.uuidPlantPartDummy);
 191                         plantPartVocabulary.addTerm(newDummyModifier);
 192
 193                         CdmStore.getService(IVocabularyService.class).saveOrUpdate(plantPartVocabulary);
 194                         conversation.commit(true);
 195                 }
 196         }
 197
 198         private static void createCountryVocabulary(IProgressMonitor monitor, ConversationHolder conversation) {
 199                 TermVocabulary<DefinedTerm> countryVocabulary = CdmStore.getService(IVocabularyService.class).find(UsageTermCollection.uuidCountryVocabulary);
 200                 if (countryVocabulary == null){
 201                         monitor.subTask("create country vocabulary");
 202                         URI termSourceUri = null;
 203                         try {
 204                                 termSourceUri = new URI("eu.etaxonomy.cdm.model.description.DefinedTerm");
 205                         } catch (URISyntaxException e) {
 206                                 e.printStackTrace();
 207                         }
 208                         countryVocabulary = TermVocabulary.NewInstance(TermType.Modifier, DefinedTerm.class, UsageTermCollection.countryLabel, UsageTermCollection.countryLabel, null, termSourceUri);
 209                         countryVocabulary.setUuid(UsageTermCollection.uuidCountryVocabulary);
 210
 211                         DefinedTerm newDummyModifier = DefinedTerm.NewInstance(TermType.Modifier, UsageTermCollection.notAvailableLabel, UsageTermCollection.notAvailableLabel, null);
 212                         newDummyModifier.setUuid(UsageTermCollection.uuidCountryDummy);
 213                         countryVocabulary.addTerm(newDummyModifier);
 214
 215                         CdmStore.getService(IVocabularyService.class).saveOrUpdate(countryVocabulary);
 216                         conversation.commit(true);
 217                 }
 218         }
 219
 220         private static void createStateVocabulary(IProgressMonitor monitor, ConversationHolder conversation) {
 221                 TermVocabulary<State> stateVocabulary = CdmStore.getService(IVocabularyService.class).find(UsageTermCollection.uuidUseCategoryVocabulary);
 222                 if (stateVocabulary == null){
 223                         monitor.subTask("create state vocabulary");
 224                         URI termSourceUri = null;
 225                         try {
 226                                 termSourceUri = new URI("eu.etaxonomy.cdm.model.description.State");
 227                         } catch (URISyntaxException e) {
 228                                 e.printStackTrace();
 229                         }
 230
 231                         stateVocabulary = OrderedTermVocabulary.NewOrderedInstance(TermType.State, State.class, UsageTermCollection.useCategoryVocabularyLabel, UsageTermCollection.useCategoryVocabularyLabel, null, termSourceUri);
 232                         stateVocabulary.setUuid(UsageTermCollection.uuidUseCategoryVocabulary);
 233
 234                         State newDummyState = State.NewInstance(UsageTermCollection.notAvailableLabel, UsageTermCollection.notAvailableLabel, null);
 235                         newDummyState.setUuid(UsageTermCollection.uuidUseCategoryDummy);
 236                         State newDummySubCat = State.NewInstance(UsageTermCollection.notAvailableLabel, UsageTermCollection.notAvailableLabel, null);
 237                         newDummySubCat.setUuid(UsageTermCollection.uuidUseSubCategoryDummy);
 238                         newDummyState.addIncludes(newDummySubCat);
 239
 240                         stateVocabulary.addTerm(newDummyState);
 241
 242                         CdmStore.getService(IVocabularyService.class).saveOrUpdate(stateVocabulary);
 243                         conversation.commit(true);
 244                 }
 245         }
 246
 247         private static void createUseMarkerType(ConversationHolder conversation) {
 248                 useMarkerType = (MarkerType) CdmStore.getService(ITermService.class).find(UsageTermCollection.uuidUseMarkerType);
 249                 if (useMarkerType == null){
 250                         useMarkerType = MarkerType.NewInstance(UsageTermCollection.useMakerLabel, UsageTermCollection.useMakerLabel, null);
 251                         useMarkerType.setUuid( UsageTermCollection.uuidUseMarkerType);
 252                         TermVocabulary<MarkerType> markerTypeVocabulary = CdmStore.getService(IVocabularyService.class).find((UsageTermCollection.uuidMarkersVocabulary));
 253                         markerTypeVocabulary.addTerm(useMarkerType);
 254                         CdmStore.getService(IVocabularyService.class).saveOrUpdate(markerTypeVocabulary);
 255                         conversation.commit(true);
 256                 }
 257         }
 258 }