eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/UseObjectManager.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.editor;
  10
  11 import java.net.URI;
  12 import java.net.URISyntaxException;
  13
  14 import org.eclipse.core.runtime.IProgressMonitor;
  15 import org.eclipse.ui.IMemento;
  16
  17 import eu.etaxonomy.cdm.api.conversation.ConversationHolder;
  18 import eu.etaxonomy.cdm.api.service.IFeatureTreeService;
  19 import eu.etaxonomy.cdm.api.service.ITermService;
  20 import eu.etaxonomy.cdm.api.service.IVocabularyService;
  21 import eu.etaxonomy.cdm.model.common.DefinedTerm;
  22 import eu.etaxonomy.cdm.model.common.MarkerType;
  23 import eu.etaxonomy.cdm.model.common.TermType;
  24 import eu.etaxonomy.cdm.model.common.TermVocabulary;
  25 import eu.etaxonomy.cdm.model.description.Feature;
  26 import eu.etaxonomy.cdm.model.description.FeatureNode;
  27 import eu.etaxonomy.cdm.model.description.FeatureTree;
  28 import eu.etaxonomy.cdm.model.description.State;
  29 import eu.etaxonomy.taxeditor.model.ContextListenerAdapter;
  30 import eu.etaxonomy.taxeditor.model.MessagingUtils;
  31 import eu.etaxonomy.taxeditor.store.CdmStore;
  32
  33 /**
  34  * The context listener will call this class when the uses view is being loaded.
  35  * It checks if the uses view's necessary terms are present in the database.
  36  * It will persist the terms that aren't present, using the CDMLib's services classes.
  37  * @author a.theys
  38  * @created mar 13, 2012
  39  */
  40 public class UseObjectManager extends ContextListenerAdapter{
  41
  42         public UseObjectManager() {
  43                 CdmStore.getContextManager().addContextListener(this);
  44         }
  45
  46
  47         @Override
  48         public void contextRefresh(IProgressMonitor monitor) {
  49                 monitor.subTask("Refreshing the Uses View");
  50                 MessagingUtils.warn(getClass(), "Refreshing Uses View warn");
  51                 setupNecessaryItems(monitor);
  52         }
  53
  54
  55         @Override
  56         public void contextStart(IMemento memento, IProgressMonitor monitor) {
  57                 monitor.subTask("Starting the Uses View");
  58                 MessagingUtils.warn(getClass(), "Starting Uses View warn");
  59                 setupNecessaryItems(monitor);
  60         }
  61
  62         private void setupNecessaryItems(IProgressMonitor monitor) {
  63
  64                 //retrieve terms and vocabularies from db
  65                 Feature featureUseRecord = (Feature) CdmStore.getService(ITermService.class).find(UsageTermCollection.uuidUseRecordFeature);
  66                 Feature featureUseSummary = (Feature) CdmStore.getService(ITermService.class).find(UsageTermCollection.uuidUseSummaryFeature);
  67
  68                 ConversationHolder conversation = CdmStore.createConversation();
  69
  70
  71                 //create use marker type if not exists
  72                 createUseMarkerType(conversation);
  73
  74                 //create state vocabulary if not exists
  75                 createStateVocabulary(monitor, conversation);
  76
  77                 //create state vocabulary if not exists
  78                 createCountryVocabulary(monitor, conversation);
  79
  80                 //create plant part vocabulary
  81                 createPlantVocabulary(monitor, conversation);
  82
  83                 //create human group vocabulary
  84                 createHumanGroupVocabulary(monitor, conversation);
  85
  86                 if(featureUseRecord == null || featureUseSummary == null) {
  87                         TermVocabulary<Feature> featureVocabulary = CdmStore.getService(IVocabularyService.class).find((UsageTermCollection.uuidFeatureVocabulary));
  88 //                      FeatureTree palmWebFeatureTree = CdmStore.getService(IFeatureTreeService.class).find(UsageTermCollection.uuidPalmWebFeatureTree);
  89
  90                         if (featureUseRecord == null ) {
  91                                 featureUseRecord = Feature.NewInstance(UsageTermCollection.useRecordFeatureLabel, UsageTermCollection.useRecordFeatureLabel, null);
  92                                 featureUseRecord.setUuid(UsageTermCollection.uuidUseRecordFeature);
  93                                 featureUseRecord.setSupportsCategoricalData(true);
  94                                 featureVocabulary.addTerm(featureUseRecord);
  95
  96 //                              if (palmWebFeatureTree != null){
  97 //                                      FeatureNode useRecFeatureNode = FeatureNode.NewInstance(featureUseRecord);
  98 //                                      palmWebFeatureTree.getRoot().addChild(useRecFeatureNode);
  99 //                              }else{
 100 //                                      StoreUtil.warn(getClass(), "No current feature tree available to add useRecord feature");
 101 //                              }
 102                         }
 103                         if (featureUseSummary == null) {
 104                                 featureUseSummary = Feature.NewInstance(UsageTermCollection.useSummaryFeatureLabel, UsageTermCollection.useSummaryFeatureLabel, null);
 105                                 featureUseSummary.setUuid(UsageTermCollection.uuidUseSummaryFeature);
 106                                 featureUseSummary.setSupportsTextData(true);
 107                                 featureVocabulary.addTerm(featureUseSummary);
 108 //                              if (palmWebFeatureTree != null){
 109 //                                      FeatureNode useSumFeatureNode = FeatureNode.NewInstance(featureUseSummary);
 110 //                                      palmWebFeatureTree.getRoot().addChild(useSumFeatureNode);
 111 //                              }else{
 112 //                                      StoreUtil.warn(getClass(), "No current feature tree available to add use summary feature");
 113 //                              }
 114                         }
 115
 116                         CdmStore.getService(IVocabularyService.class).saveOrUpdate(featureVocabulary);
 117 //                      if (palmWebFeatureTree != null){
 118 //                              CdmStore.getService(IFeatureTreeService.class).saveOrUpdate(palmWebFeatureTree);
 119 //                      }
 120                         conversation.commit(true);
 121
 122                 }
 123                 conversation.close();
 124         }
 125
 126
 127         private void createHumanGroupVocabulary(IProgressMonitor monitor,ConversationHolder conversation) {
 128                 TermVocabulary<DefinedTerm> humanGroupVocabulary =  CdmStore.getService(IVocabularyService.class).find(UsageTermCollection.uuidHumanGroupVocabulary);
 129                 if (humanGroupVocabulary == null){
 130                         monitor.subTask("create human group vocabulary");
 131                         URI termSourceUri = null;
 132                         try {
 133                                 termSourceUri = new URI("eu.etaxonomy.cdm.model.description.DefinedTerm");
 134                         } catch (URISyntaxException e) {
 135                                 e.printStackTrace();
 136                         }
 137
 138                         humanGroupVocabulary = TermVocabulary.NewInstance(TermType.Modifier, UsageTermCollection.humanGroupLabel, UsageTermCollection.humanGroupLabel, null, termSourceUri);
 139                         humanGroupVocabulary.setUuid(UsageTermCollection.uuidHumanGroupVocabulary);
 140
 141                         DefinedTerm newDummyModifier = DefinedTerm.NewInstance(TermType.Modifier, UsageTermCollection.notAvailableLabel, UsageTermCollection.notAvailableLabel, null);
 142                         newDummyModifier.setUuid(UsageTermCollection.uuidHumanGroupDummy);
 143
 144                         DefinedTerm newSubDummyModifier = DefinedTerm.NewInstance(TermType.Modifier, UsageTermCollection.notAvailableLabel, UsageTermCollection.notAvailableLabel, null);
 145                         newSubDummyModifier.setUuid(UsageTermCollection.uuidEthnicGroupDummy);
 146                         newDummyModifier.addIncludes(newSubDummyModifier);
 147                         humanGroupVocabulary.addTerm(newDummyModifier);
 148
 149                         CdmStore.getService(IVocabularyService.class).saveOrUpdate(humanGroupVocabulary);
 150                         conversation.commit(true);
 151                 }
 152         }
 153
 154
 155         private void createPlantVocabulary(IProgressMonitor monitor, ConversationHolder conversation) {
 156                 TermVocabulary<DefinedTerm> plantPartVocabulary =  CdmStore.getService(IVocabularyService.class).find(UsageTermCollection.uuidPlantPartVocabulary);
 157                 if (plantPartVocabulary == null){
 158                         monitor.subTask("create plant part vocabulary");
 159                         URI termSourceUri = null;
 160                         try {
 161                                 termSourceUri = new URI("eu.etaxonomy.cdm.model.description.DefinedTerm");
 162                         } catch (URISyntaxException e) {
 163                                 e.printStackTrace();
 164                         }
 165                         plantPartVocabulary = TermVocabulary.NewInstance(TermType.Modifier, UsageTermCollection.plantPartLabel, UsageTermCollection.plantPartLabel, null, termSourceUri);
 166                         plantPartVocabulary.setUuid(UsageTermCollection.uuidPlantPartVocabulary);
 167
 168                         DefinedTerm newDummyModifier = DefinedTerm.NewInstance(TermType.Modifier, UsageTermCollection.notAvailableLabel, UsageTermCollection.notAvailableLabel, null);
 169                         newDummyModifier.setUuid(UsageTermCollection.uuidPlantPartDummy);
 170                         plantPartVocabulary.addTerm(newDummyModifier);
 171
 172                         CdmStore.getService(IVocabularyService.class).saveOrUpdate(plantPartVocabulary);
 173                         conversation.commit(true);
 174                 }
 175         }
 176
 177
 178         private void createCountryVocabulary(IProgressMonitor monitor, ConversationHolder conversation) {
 179                 TermVocabulary<DefinedTerm> countryVocabulary =  CdmStore.getService(IVocabularyService.class).find(UsageTermCollection.uuidCountryVocabulary);
 180                 if (countryVocabulary == null){
 181                         monitor.subTask("create country vocabulary");
 182                         URI termSourceUri = null;
 183                         try {
 184                                 termSourceUri = new URI("eu.etaxonomy.cdm.model.description.DefinedTerm");
 185                         } catch (URISyntaxException e) {
 186                                 e.printStackTrace();
 187                         }
 188                         countryVocabulary = TermVocabulary.NewInstance(TermType.Modifier, UsageTermCollection.countryLabel, UsageTermCollection.countryLabel, null, termSourceUri);
 189                         countryVocabulary.setUuid(UsageTermCollection.uuidCountryVocabulary);
 190
 191                         DefinedTerm newDummyModifier = DefinedTerm.NewInstance(TermType.Modifier, UsageTermCollection.notAvailableLabel, UsageTermCollection.notAvailableLabel, null);
 192                         newDummyModifier.setUuid(UsageTermCollection.uuidCountryDummy);
 193                         countryVocabulary.addTerm(newDummyModifier);
 194
 195                         CdmStore.getService(IVocabularyService.class).saveOrUpdate(countryVocabulary);
 196                         conversation.commit(true);
 197                 }
 198         }
 199
 200
 201         private void createStateVocabulary(IProgressMonitor monitor, ConversationHolder conversation) {
 202                 TermVocabulary<State> stateVocabulary =  CdmStore.getService(IVocabularyService.class).find(UsageTermCollection.uuidUseCategoryVocabulary);
 203                 if (stateVocabulary == null){
 204                         monitor.subTask("create state vocabulary");
 205                         URI termSourceUri = null;
 206                         try {
 207                                 termSourceUri = new URI("eu.etaxonomy.cdm.model.description.State");
 208                         } catch (URISyntaxException e) {
 209                                 e.printStackTrace();
 210                         }
 211
 212                         stateVocabulary = TermVocabulary.NewInstance(TermType.State, UsageTermCollection.useCategoryVocabularyLabel, UsageTermCollection.useCategoryVocabularyLabel, null, termSourceUri);
 213                         stateVocabulary.setUuid(UsageTermCollection.uuidUseCategoryVocabulary);
 214
 215                         State newDummyState = State.NewInstance(UsageTermCollection.notAvailableLabel, UsageTermCollection.notAvailableLabel, null);
 216                         newDummyState.setUuid(UsageTermCollection.uuidUseCategoryDummy);
 217                         State newDummySubCat = State.NewInstance(UsageTermCollection.notAvailableLabel, UsageTermCollection.notAvailableLabel, null);
 218                         newDummySubCat.setUuid(UsageTermCollection.uuidUseSubCategoryDummy);
 219                         newDummyState.addIncludes(newDummySubCat);
 220
 221                         stateVocabulary.addTerm(newDummyState);
 222
 223                         CdmStore.getService(IVocabularyService.class).saveOrUpdate(stateVocabulary);
 224                         conversation.commit(true);
 225                 }
 226         }
 227
 228
 229         private void createUseMarkerType(ConversationHolder conversation) {
 230                 MarkerType useMarkertype = (MarkerType) CdmStore.getService(ITermService.class).find(UsageTermCollection.uuidUseMarkerType);
 231                 if (useMarkertype == null){
 232                         useMarkertype = MarkerType.NewInstance(UsageTermCollection.useMakerLabel, UsageTermCollection.useMakerLabel, null);
 233                         useMarkertype.setUuid( UsageTermCollection.uuidUseMarkerType);
 234                         TermVocabulary<MarkerType> markerTypeVocabulary = CdmStore.getService(IVocabularyService.class).find((UsageTermCollection.uuidMarkersVocabulary));
 235                         markerTypeVocabulary.addTerm(useMarkertype);
 236                         CdmStore.getService(IVocabularyService.class).saveOrUpdate(markerTypeVocabulary);
 237                         conversation.commit(true);
 238                 }
 239         }
 240 }