Java ValueDomainPermissibleValue类代码示例

import gov.nih.nci.cadsr.domain.ValueDomainPermissibleValue; //导入依赖的package包/类
private void retrievePermissibleValues(ValueDomain valueDomain,
                                       gov.nih.nci.cadsr.domain.ValueDomain cadsrValueDomain) {
    EnumeratedValueDomain enumeratedValueDomain = (EnumeratedValueDomain) cadsrValueDomain;
    Collection<ValueDomainPermissibleValue> valueDomainPermissibleValues =
                            enumeratedValueDomain.getValueDomainPermissibleValueCollection();
    for (ValueDomainPermissibleValue valueDomainPermissibleValue : valueDomainPermissibleValues) {
        gov.nih.nci.cadsr.domain.PermissibleValue cadsrPermissibleValue =
            valueDomainPermissibleValue.getPermissibleValue();
        String stringValue = cadsrPermissibleValue.getValue();
        PermissibleValue permissibleValue = new PermissibleValue();
        permissibleValue.setValue(stringValue);

        if (cadsrPermissibleValue.getValueMeaning() != null) {
            ValueMeaning valueMeaning = cadsrPermissibleValue.getValueMeaning();
            permissibleValue.setValueMeaning(valueMeaning.getDescription());
        }
        valueDomain.getPermissibleValueCollection().add(permissibleValue);
    }
}
 

import gov.nih.nci.cadsr.domain.ValueDomainPermissibleValue; //导入依赖的package包/类
/**
 * Returns the Set of Permissible values from the collection of value domains. 
 * @param valueDomainCollection The value domain collection. 
 * @param cde The CDE to which this permissible values belong. 
 * @return the Set of Permissibel values from the collection of value domains.
 */
private Set getPermissibleValues(Collection valueDomainCollection)
{
    Logger.out.debug("Value Domain Size : "+valueDomainCollection.size());
    
    Set permissibleValuesSet = new HashSet();
    
    Iterator iterator = valueDomainCollection.iterator();
    while(iterator.hasNext())
    {
        ValueDomainPermissibleValue valueDomainPermissibleValue = (ValueDomainPermissibleValue) iterator.next();
        
        //caDSR permissible value object
        PermissibleValue permissibleValue = (PermissibleValue) valueDomainPermissibleValue.getPermissibleValue();
        
        //Create the instance of catissue permissible value
        edu.wustl.common.cde.PermissibleValueImpl cachedPermissibleValue = new PermissibleValueImpl();
        
        cachedPermissibleValue.setConceptid(permissibleValue.getId());
        cachedPermissibleValue.setValue(permissibleValue.getValue());
        
        Logger.out.debug("Concept ID : "+cachedPermissibleValue.getConceptid());
        Logger.out.debug("Value : "+cachedPermissibleValue.getValue());
        permissibleValuesSet.add(cachedPermissibleValue);
    } // while iterator
    return permissibleValuesSet;
}
 

import gov.nih.nci.cadsr.domain.ValueDomainPermissibleValue; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    ApplicationService appService = mock(ApplicationService.class);
    when(appService.search(any(Class.class), any())).then(new Answer<List<Object>>() {
        @Override
        public List<Object> answer(InvocationOnMock invocation) throws Throwable {
            DataElement de = new DataElement();
            EnumeratedValueDomain vd = new EnumeratedValueDomain();
            de.setValueDomain(vd);
            vd.setDatatypeName("NUMBER");
            vd.setLongName("Some Value Domain");
            vd.setPublicID(Long.valueOf(2));
            vd.setValueDomainPermissibleValueCollection(new HashSet<ValueDomainPermissibleValue>());
            ValueDomainPermissibleValue vdpv = new ValueDomainPermissibleValue();
            gov.nih.nci.cadsr.domain.PermissibleValue permissibleValue = new gov.nih.nci.cadsr.domain.PermissibleValue();
            permissibleValue.setValue("1.0");
            vdpv.setPermissibleValue(permissibleValue);
            vd.getValueDomainPermissibleValueCollection().add(vdpv);
            List<Object> objects = new ArrayList<Object>();
            objects.add(de);
            return objects;
        }
    });

    CaDSRApplicationServiceFactory appFactory = mock(CaDSRApplicationServiceFactory.class);
    when(appFactory.retrieveCaDsrApplicationService(anyString())).thenReturn(appService);

    caDSRFacade = new CaDSRFacadeImpl();
    caDSRFacade.setSearch(new SearchStub());
    caDSRFacade.setCaDsrApplicationServiceFactory(appFactory);
}
 

import gov.nih.nci.cadsr.domain.ValueDomainPermissibleValue; //导入依赖的package包/类
public ExternalQuestionElement transformCADSRQuestion(gov.nih.nci.cadsr.domain.DataElement sourceQuestion, AnswerType answerType, Set<String> deletedAnswerValues)
	{
//		int numAnswers = 1;
		ExternalQuestionElement targetElement = new ExternalQuestionElement();

		targetElement.setExternalUuid          ( sourceQuestion.getId() );
		targetElement.setDescription   ( getQuestionDescription( sourceQuestion ) );

		targetElement.setLearnMore     ( sourceQuestion.getPreferredDefinition() );
		targetElement.setSourceId(String.valueOf(sourceQuestion.getPublicID()) );
//		targetElement.setType          ( getQuestionType( sourceQuestion ) );	
		targetElement.setLink          ( QuestionSource.CA_DSR, String.valueOf( sourceQuestion.getPublicID() ) );
		targetElement.setExternalVersion( sourceQuestion.getVersion() );
		
		
		AnswerType finalAnswerType = answerType == null ? getAnswerType(sourceQuestion) : answerType;
		//create a question
		ExternalQuestion targetQuestion = new ExternalQuestion();
		targetQuestion.setShortName     ( sourceQuestion.getPreferredName() );
		targetQuestion.setType(AnswerType.CHECKBOX.equals(finalAnswerType) ? QuestionType.MULTI_ANSWER : QuestionType.SINGLE_ANSWER);
		targetElement.setQuestion(targetQuestion);
		
		// set answers/answer-related properties
		
		Answer answer = new Answer();
		answer.setType        ( finalAnswerType );
		answer.setDescription ( sourceQuestion.getLongName() );	
		targetElement.setAnswerType(answer.getType());
		if ( sourceQuestion.getValueDomain() instanceof EnumeratedValueDomain ) 
		{
			// Set the answer values
			Collection<ValueDomainPermissibleValue> coll =
				((EnumeratedValueDomain)sourceQuestion.getValueDomain()).getValueDomainPermissibleValueCollection();
			int numAnswerValues = 0;
			for ( ValueDomainPermissibleValue val : coll ) 
			{		
				AnswerValue answerValue = new AnswerValue();
				PermissibleValue permissibleValue = val.getPermissibleValue();
				if(deletedAnswerValues != null && deletedAnswerValues.contains(permissibleValue.getId())) {
					continue;
				}
				answerValue.setExternalId    ( permissibleValue.getId() );
				answerValue.setValue          ( permissibleValue.getValue() );
				answerValue.setDescription    ( permissibleValue.getValue() );
				answerValue.setName           ( permissibleValue.getValue() );
				answerValue.setCadsrPublicId  ( permissibleValue.getValueMeaning() == null ? 
						                        null : 
						                        permissibleValue.getValueMeaning().getPublicID() );
				answerValue.setOrd            ( ++numAnswerValues );
				answer.addAnswerValues        ( answerValue );	
			}			
		} 
		
		// If there were no answer values, then 
		// add a dummy value to prevent the AnswerPresenter custom tag from crashing
		if ( CollectionUtils.isEmpty( answer.getAnswerValues()) ) 
		{
			answer.addDefaultAnswerValue();
		}
	
		targetQuestion.setAnswer( answer );
		
		return targetElement;
	}