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