/ - Diff - EDIT - EDIT Project Management

+    	}
     	private final DerivedUnitFacadeConfigurator config;
     	private Map<PropertyChangeListener, CdmBase> listeners = new HashMap<PropertyChangeListener, CdmBase>();
     	// private GatheringEvent gatheringEvent;
     	private DerivedUnitType type; // needed?
-...
     	 * @return
     	 */
     	public static DerivedUnitFacade NewInstance(DerivedUnitType type) {
     		return new DerivedUnitFacade(type, null);
     		return new DerivedUnitFacade(type, null, null);
+    	}
     	/**
-...
     	 * @return
     	 */
     	public static DerivedUnitFacade NewInstance(DerivedUnitType type, FieldObservation fieldObservation) {
     		return new DerivedUnitFacade(type, fieldObservation);
     		return new DerivedUnitFacade(type, fieldObservation, null);
+    	}
     	/**
     	 * Creates a derived unit facade for a new derived unit of type
     	 * <code>type</code>.
+    	 *
     	 * @param type
     	 * @param fieldObservation the field observation to use
     	 * @param config the facade configurator to use
     	 * //TODO are there any ambiguities to solve with defining a field observation or a configurator
     	 * @return
     	 */
     	public static DerivedUnitFacade NewInstance(DerivedUnitType type, FieldObservation fieldObservation, DerivedUnitFacadeConfigurator config) {
     		return new DerivedUnitFacade(type, fieldObservation, config);
+    	}
     	/**
     	 * Creates a derived unit facade for a given derived unit using the default
     	 * configuration.
-...
     	// ****************** CONSTRUCTOR ******************************************
     	private DerivedUnitFacade(DerivedUnitType type, FieldObservation fieldObservation) {
     		this.config = DerivedUnitFacadeConfigurator.NewInstance();
     	private DerivedUnitFacade(DerivedUnitType type, FieldObservation fieldObservation, DerivedUnitFacadeConfigurator config) {
     		if (config == null){
     			config = DerivedUnitFacadeConfigurator.NewInstance();
+    		}
     		this.config = config;
     		this.type = type;
     		// derivedUnit
     		derivedUnit = type.getNewDerivedUnitInstance();
-...
     				fieldObservation = fieldOriginals.iterator().next();
     				// ###fieldObservation =
     				// getInitializedFieldObservation(fieldObservation);
     				fieldObservation
     						.addPropertyChangeListener(getNewEventPropagationListener());
     				if (config.isFirePropertyChangeEvents()){
     					addNewEventPropagationListener(fieldObservation);
+    				}
     			} else {
     				throw new IllegalStateException("Illegal state");
+    			}
-...
     	private void setFieldObservation(FieldObservation fieldObservation) {
     		this.fieldObservation = fieldObservation;
     		if (fieldObservation != null){
     			fieldObservation.addPropertyChangeListener(getNewEventPropagationListener());
     			if (config.isFirePropertyChangeEvents()){
     				addNewEventPropagationListener(fieldObservation);
+    			}
     			if (derivedUnit != null){
     				DerivationEvent derivationEvent = getDerivationEvent(CREATE);
     				derivationEvent.addOriginal(fieldObservation);
-...
     	// Determination
     	public void addDetermination(DeterminationEvent determination) {
     		testDerivedUnit();
     		testDerivedUnit();
     		determination.setIdentifiedUnit(derivedUnit);
     		derivedUnit.addDetermination(determination);
+    	}
-...
+    	}
     	// ******************************* Events ***************************
     	/**
     	 * @return
     	 */
     	private PropertyChangeListener getNewEventPropagationListener() {
     	private void addNewEventPropagationListener(CdmBase listeningObject) {
     		//if there is already a listener, don't do anything
     		for (PropertyChangeListener listener : this.listeners.keySet()){
     			if (listeners.get(listener) == listeningObject){
     				return;
+    			}
+    		}
     		//create new listener
     		PropertyChangeListener listener = new PropertyChangeListener() {
     			@Override
     			public void propertyChange(PropertyChangeEvent event) {
-...
+    				}
+    			}
     		};
     		return listener;
     		//add listener to listening object and to list of listeners
     		listeningObject.addPropertyChangeListener(listener);
     		listeners.put(listener, listeningObject);
+    	}
     	// **************** Other Collections
     	// ***************************************************
     	// **************** Other Collections ********************************
     	/**
     	 * Creates a duplicate specimen which derives from the same derivation event
-...
     		return type;
+    	}
     	/**
     	 * Closes this facade. As a minimum this method removes all listeners created by this facade from their
     	 * listening objects.
     	 */
     	public void close(){
     		for (PropertyChangeListener listener : this.listeners.keySet()){
     			CdmBase listeningObject = listeners.get(listener);
     			listeningObject.removePropertyChangeListener(listener);
+    		}
+    	}
+    }

     		DerivedUnitFacade facade;
     		try {
     			facade = DerivedUnitFacade.NewInstance(derivedUnit);
     			DerivedUnitFacadeConfigurator config = DerivedUnitFacadeConfigurator.NewInstance();
     			config.setFirePropertyChangeEvents(false);
     			facade = DerivedUnitFacade.NewInstance(derivedUnit, config);
     			result += fieldStrategy.getFieldData(facade);
     //			//country
     //			String strCountry = null;

     	private boolean moveDerivedUnitMediaToGallery = false;
     	private boolean throwExceptionForNonSpecimenPreservationMethodRequest = true;
     	private boolean firePropertyChangeEvents = true;
     	//needed if inititialization via property paths is required
-...
     	public boolean isThrowExceptionForNonSpecimenPreservationMethodRequest() {
     		return throwExceptionForNonSpecimenPreservationMethodRequest;
+    	}
     	public void setFirePropertyChangeEvents(boolean firePropertyChangeEvents) {
     		this.firePropertyChangeEvents = firePropertyChangeEvents;
+    	}
     	public boolean isFirePropertyChangeEvents() {
     		return firePropertyChangeEvents;
+    	}
+    }

     	public String getTitleCache(FieldObservation fieldObservation) {
     		DerivedUnitFacade facade;
     		String result = "";
     		facade = DerivedUnitFacade.NewInstance(DerivedUnitType.FieldObservation, fieldObservation);
     		DerivedUnitFacadeConfigurator config = DerivedUnitFacadeConfigurator.NewInstance();
     		config.setFirePropertyChangeEvents(false);
     		facade = DerivedUnitFacade.NewInstance(DerivedUnitType.FieldObservation, fieldObservation, config);
     		result = getFieldData(facade);
     		result = addPlantDescription(result, facade);
     		facade.close();
     		return result;
+    	}

     import org.junit.BeforeClass;
     import org.junit.Ignore;
     import org.junit.Test;
     import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
     import org.springframework.security.core.context.SecurityContextHolder;
     import org.unitils.dbunit.annotation.DataSet;
     import org.unitils.dbunit.annotation.ExpectedDataSet;
     import org.unitils.spring.annotation.SpringBeanByType;
-...
     import eu.etaxonomy.cdm.api.facade.DerivedUnitFacade.DerivedUnitType;
     import eu.etaxonomy.cdm.api.service.IOccurrenceService;
     import eu.etaxonomy.cdm.api.service.ITermService;
     import eu.etaxonomy.cdm.api.service.IUserService;
     import eu.etaxonomy.cdm.model.agent.AgentBase;
     import eu.etaxonomy.cdm.model.agent.Team;
     import eu.etaxonomy.cdm.model.common.IdentifiableSource;
     import eu.etaxonomy.cdm.model.common.Language;
     import eu.etaxonomy.cdm.model.common.LanguageString;
     import eu.etaxonomy.cdm.model.common.TimePeriod;
     import eu.etaxonomy.cdm.model.common.User;
     import eu.etaxonomy.cdm.model.description.Feature;
     import eu.etaxonomy.cdm.model.description.Sex;
     import eu.etaxonomy.cdm.model.description.SpecimenDescription;
-...
+     *
      */
     public class DerivedUnitFacadeTest extends CdmTransactionalIntegrationTest {
     	private static final Logger logger = Logger
     			.getLogger(DerivedUnitFacadeTest.class);
     	private static final Logger logger = Logger.getLogger(DerivedUnitFacadeTest.class);
     	@SpringBeanByType
     	private IOccurrenceService service;
-...
     		// this should not throw exceptions
     		specimenFacade.setAbsoluteElevationRange(minimum, maximum);
+    	}
     	@SpringBeanByType
     	private IUserService userService;
     	/**
+    	 *
     	 * See https://dev.e-taxonomy.eu/trac/ticket/2426
     	 * This test doesn't handle the above issue yet as it doesn't fire events as
     	 * expected (at least it does not reproduce the behaviour in the Taxonomic Editor).
     	 * In the meanwhile the property change framework for the facade has been changed
     	 * so the original problem may have disappeared.
+    	 *
     	 */
     	@Test
     	public void testNoRecursiveChangeEvents(){
     		String username = "username";
     		String password = "password";
     		User user = User.NewInstance(username, password);
     		userService.save(user);
     		UsernamePasswordAuthenticationToken token = new UsernamePasswordAuthenticationToken(user, password);
     		SecurityContextHolder.getContext().setAuthentication(token);
     		DerivedUnitFacade facade = DerivedUnitFacade.NewInstance(DerivedUnitType.Specimen);
     		facade.setLocality("testLocality");
     		facade.getTitleCache();
     //		facade.innerGatheringEvent().firePropertyChange("createdBy", null, user);
     		this.service.save(facade.innerDerivedUnit());
+    	}
+    }

Project

General

Profile

EDIT

Revision ede17590

Added by Andreas Müller about 13 years ago