EDIT

import java.net.URI;

import java.net.URISyntaxException;

import eu.etaxonomy.cdm.api.conversation.ConversationHolder;

import eu.etaxonomy.cdm.api.service.ITermService;

import eu.etaxonomy.cdm.api.service.IVocabularyService;

import eu.etaxonomy.cdm.model.common.DefinedTerm;

import eu.etaxonomy.cdm.model.common.MarkerType;

import eu.etaxonomy.cdm.model.common.TermType;

import eu.etaxonomy.cdm.model.common.TermVocabulary;

import eu.etaxonomy.cdm.model.description.Feature;

import eu.etaxonomy.cdm.model.description.State;

 * The context listener will call this class when the uses view is being loaded.

 * It checks if the uses view's necessary terms are present in the database.

 * It will persist the terms that aren't present, using the CDMLib's services classes.

		monitor.subTask("Refreshing the Uses View");

		MessagingUtils.warn(getClass(), "Refreshing Uses View warn");

		setupNecessaryItems(monitor);

		monitor.subTask("Starting the Uses View");

		MessagingUtils.warn(getClass(), "Starting Uses View warn");

		setupNecessaryItems(monitor);

	}

	private void setupNecessaryItems(IProgressMonitor monitor) {

		//retrieve terms and vocabularies from db

		Feature featureUseRecord = (Feature) CdmStore.getService(ITermService.class).find(UsageTermCollection.uuidUseRecordFeature);

		Feature featureUseSummary = (Feature) CdmStore.getService(ITermService.class).find(UsageTermCollection.uuidUseSummaryFeature);

		ConversationHolder conversation = CdmStore.createConversation();

		//create use marker type if not exists

		createUseMarkerType(conversation);

		//create state vocabulary if not exists

		createStateVocabulary(monitor, conversation);

		//create state vocabulary if not exists

		createCountryVocabulary(monitor, conversation);

		//create plant part vocabulary

		createPlantVocabulary(monitor, conversation);

		//create human group vocabulary

		createHumanGroupVocabulary(monitor, conversation);

		if(featureUseRecord == null || featureUseSummary == null) {

			TermVocabulary<Feature> featureVocabulary = CdmStore.getService(IVocabularyService.class).find((UsageTermCollection.uuidFeatureVocabulary));

//			FeatureTree palmWebFeatureTree = CdmStore.getService(IFeatureTreeService.class).find(UsageTermCollection.uuidPalmWebFeatureTree);

			if (featureUseRecord == null ) {

				featureUseRecord = Feature.NewInstance(UsageTermCollection.useRecordFeatureLabel, UsageTermCollection.useRecordFeatureLabel, null);

				featureUseRecord.setUuid(UsageTermCollection.uuidUseRecordFeature);

				featureUseRecord.setSupportsCategoricalData(true);

				featureVocabulary.addTerm(featureUseRecord);

//				if (palmWebFeatureTree != null){

//					FeatureNode useRecFeatureNode = FeatureNode.NewInstance(featureUseRecord);

//					palmWebFeatureTree.getRoot().addChild(useRecFeatureNode);

//				}else{

//					StoreUtil.warn(getClass(), "No current feature tree available to add useRecord feature");

//				}

			}

			if (featureUseSummary == null) {

				featureUseSummary = Feature.NewInstance(UsageTermCollection.useSummaryFeatureLabel, UsageTermCollection.useSummaryFeatureLabel, null);

				featureUseSummary.setUuid(UsageTermCollection.uuidUseSummaryFeature);

				featureUseSummary.setSupportsTextData(true);

				featureVocabulary.addTerm(featureUseSummary);

//				if (palmWebFeatureTree != null){

//					FeatureNode useSumFeatureNode = FeatureNode.NewInstance(featureUseSummary);

//					palmWebFeatureTree.getRoot().addChild(useSumFeatureNode);

//				}else{

//					StoreUtil.warn(getClass(), "No current feature tree available to add use summary feature");

//				}

			}

			CdmStore.getService(IVocabularyService.class).saveOrUpdate(featureVocabulary);

//			if (palmWebFeatureTree != null){

//				CdmStore.getService(IFeatureTreeService.class).saveOrUpdate(palmWebFeatureTree);

//			}

			conversation.commit(true);

		}

		conversation.close();

	}

	private void createHumanGroupVocabulary(IProgressMonitor monitor,ConversationHolder conversation) {

		TermVocabulary<DefinedTerm> humanGroupVocabulary =  CdmStore.getService(IVocabularyService.class).find(UsageTermCollection.uuidHumanGroupVocabulary);

		if (humanGroupVocabulary == null){

			monitor.subTask("create human group vocabulary");

			URI termSourceUri = null;

			try {

				termSourceUri = new URI("eu.etaxonomy.cdm.model.description.DefinedTerm");

			} catch (URISyntaxException e) {

				e.printStackTrace();

			}

			humanGroupVocabulary = TermVocabulary.NewInstance(TermType.Modifier, UsageTermCollection.humanGroupLabel, UsageTermCollection.humanGroupLabel, null, termSourceUri);

			humanGroupVocabulary.setUuid(UsageTermCollection.uuidHumanGroupVocabulary);

			DefinedTerm newDummyModifier = DefinedTerm.NewInstance(TermType.Modifier, UsageTermCollection.notAvailableLabel, UsageTermCollection.notAvailableLabel, null);

			newDummyModifier.setUuid(UsageTermCollection.uuidHumanGroupDummy);

			DefinedTerm newSubDummyModifier = DefinedTerm.NewInstance(TermType.Modifier, UsageTermCollection.notAvailableLabel, UsageTermCollection.notAvailableLabel, null);

			newSubDummyModifier.setUuid(UsageTermCollection.uuidEthnicGroupDummy);

			newDummyModifier.addIncludes(newSubDummyModifier);

			humanGroupVocabulary.addTerm(newDummyModifier);

			CdmStore.getService(IVocabularyService.class).saveOrUpdate(humanGroupVocabulary);

			conversation.commit(true);

		}

	}

	private void createPlantVocabulary(IProgressMonitor monitor, ConversationHolder conversation) {

		TermVocabulary<DefinedTerm> plantPartVocabulary =  CdmStore.getService(IVocabularyService.class).find(UsageTermCollection.uuidPlantPartVocabulary);

		if (plantPartVocabulary == null){

			monitor.subTask("create plant part vocabulary");

			URI termSourceUri = null;

			try {

				termSourceUri = new URI("eu.etaxonomy.cdm.model.description.DefinedTerm");

			} catch (URISyntaxException e) {

				e.printStackTrace();

			}

			plantPartVocabulary = TermVocabulary.NewInstance(TermType.Modifier, UsageTermCollection.plantPartLabel, UsageTermCollection.plantPartLabel, null, termSourceUri);

			plantPartVocabulary.setUuid(UsageTermCollection.uuidPlantPartVocabulary);

			DefinedTerm newDummyModifier = DefinedTerm.NewInstance(TermType.Modifier, UsageTermCollection.notAvailableLabel, UsageTermCollection.notAvailableLabel, null);

			newDummyModifier.setUuid(UsageTermCollection.uuidPlantPartDummy);

			plantPartVocabulary.addTerm(newDummyModifier);

			CdmStore.getService(IVocabularyService.class).saveOrUpdate(plantPartVocabulary);

			conversation.commit(true);

		}

	}

	private void createCountryVocabulary(IProgressMonitor monitor, ConversationHolder conversation) {

		TermVocabulary<DefinedTerm> countryVocabulary =  CdmStore.getService(IVocabularyService.class).find(UsageTermCollection.uuidCountryVocabulary);

		if (countryVocabulary == null){

			monitor.subTask("create country vocabulary");

			URI termSourceUri = null;

			try {

				termSourceUri = new URI("eu.etaxonomy.cdm.model.description.DefinedTerm");

			} catch (URISyntaxException e) {

				e.printStackTrace();

			}

			countryVocabulary = TermVocabulary.NewInstance(TermType.Modifier, UsageTermCollection.countryLabel, UsageTermCollection.countryLabel, null, termSourceUri);

			countryVocabulary.setUuid(UsageTermCollection.uuidCountryVocabulary);

			DefinedTerm newDummyModifier = DefinedTerm.NewInstance(TermType.Modifier, UsageTermCollection.notAvailableLabel, UsageTermCollection.notAvailableLabel, null);

			newDummyModifier.setUuid(UsageTermCollection.uuidCountryDummy);

			countryVocabulary.addTerm(newDummyModifier);

			CdmStore.getService(IVocabularyService.class).saveOrUpdate(countryVocabulary);

			conversation.commit(true);

		}

	}

	private void createStateVocabulary(IProgressMonitor monitor, ConversationHolder conversation) {

		TermVocabulary<State> stateVocabulary =  CdmStore.getService(IVocabularyService.class).find(UsageTermCollection.uuidUseCategoryVocabulary);

		if (stateVocabulary == null){

			monitor.subTask("create state vocabulary");

			URI termSourceUri = null;

			try {

				termSourceUri = new URI("eu.etaxonomy.cdm.model.description.State");

			} catch (URISyntaxException e) {

				e.printStackTrace();

			}

			stateVocabulary = TermVocabulary.NewInstance(TermType.State, UsageTermCollection.useCategoryVocabularyLabel, UsageTermCollection.useCategoryVocabularyLabel, null, termSourceUri);

			stateVocabulary.setUuid(UsageTermCollection.uuidUseCategoryVocabulary);

			State newDummyState = State.NewInstance(UsageTermCollection.notAvailableLabel, UsageTermCollection.notAvailableLabel, null);

			newDummyState.setUuid(UsageTermCollection.uuidUseCategoryDummy);

			State newDummySubCat = State.NewInstance(UsageTermCollection.notAvailableLabel, UsageTermCollection.notAvailableLabel, null);

			newDummySubCat.setUuid(UsageTermCollection.uuidUseSubCategoryDummy);

			newDummyState.addIncludes(newDummySubCat);

			stateVocabulary.addTerm(newDummyState);

			CdmStore.getService(IVocabularyService.class).saveOrUpdate(stateVocabulary);

			conversation.commit(true);

		}

	private void createUseMarkerType(ConversationHolder conversation) {

		MarkerType useMarkertype = (MarkerType) CdmStore.getService(ITermService.class).find(UsageTermCollection.uuidUseMarkerType);

		if (useMarkertype == null){

			useMarkertype = MarkerType.NewInstance(UsageTermCollection.useMakerLabel, UsageTermCollection.useMakerLabel, null);

			useMarkertype.setUuid( UsageTermCollection.uuidUseMarkerType);

			TermVocabulary<MarkerType> markerTypeVocabulary = CdmStore.getService(IVocabularyService.class).find((UsageTermCollection.uuidMarkersVocabulary));

			markerTypeVocabulary.addTerm(useMarkertype);

			CdmStore.getService(IVocabularyService.class).saveOrUpdate(markerTypeVocabulary);

			conversation.commit(true);

		}

	}