import org.LexGrid.LexBIG.DataModel.Core.ResolvedConceptReference; //导入依赖的package包/类
/**
 * Returns the text representing the given item.  Note that in
 * general this method assumes the presentations have been constrianed
 * during the initial query by HCD qualification.
 * @param rcr Concept resolved from a query.
 * @param hcd The hierarchical code to reflect in printed output.
 * @return The first embedded text presentation, or the item
 * description if no presentation is found.
 */
protected String getItemText(ResolvedConceptReference rcr, String hcd) {
	StringBuffer sb = new StringBuffer(rcr.getConceptCode());
	boolean presFound = false;
	if (rcr.getReferencedEntry() != null) {
		Presentation[] presentations = rcr.getReferencedEntry().getPresentation();
		for (int i = 0; i < presentations.length && !presFound; i++) {
			Presentation p = presentations[i];
			PropertyQualifier[] quals = p.getPropertyQualifier();
			for (int j = 0; j < quals.length && !presFound; j++) {
				PropertyQualifier pq = quals[j];
				if (presFound = "HCD".equals(pq.getPropertyQualifierId()) && hcd.equals(pq.getContent())) {
					sb.append(':').append(p.getText().getContent());
				}
			}
		}
	}
	if (!presFound && rcr.getEntityDescription() != null)
		sb.append(':').append(rcr.getEntityDescription().getContent());
	return sb.toString();
}
 

import org.LexGrid.LexBIG.DataModel.Core.ResolvedConceptReference; //导入依赖的package包/类
public static String createStringFromResolvedConceptReferenceObject(ResolvedConceptReference reference, int tabCount){
	StringBuffer results = new StringBuffer();
	String tabs = createTabs(tabCount);
	
	appendLine(results, tabs, " Code: " + reference.getCode());
	appendLine(results, tabs, " CodeNamespace: " + reference.getCodeNamespace());
	appendLine(results, tabs, " CodingSchemeName: " + reference.getCodingSchemeName());
	appendLine(results, tabs, " CodingSchemeURI: " + reference.getCodingSchemeURI());
	appendLine(results, tabs, " CodingSchemeVersion: " + reference.getCodingSchemeVersion());
	appendLine(results, tabs, " ConceptCode: " + reference.getConceptCode());

	appendLine(results, tabs, " EntityDescription: " + reference.getEntityDescription().getContent());
	appendLine(results, tabs, " Entities: \n");
	appendLine(results, "", createStringFromEntityObject(reference.getEntity(), tabCount + 1));
	appendLine(results, tabs, " SourceOf: " + reference.getSourceOf());
	appendLine(results, tabs, " TargetOf: " + reference.getTargetOf());
	
	return results.toString();
}
 

import org.LexGrid.LexBIG.DataModel.Core.ResolvedConceptReference; //导入依赖的package包/类
@Override
protected List<? extends ResolvedConceptReference> doPage(
		int position,
		int pageSize) {


	List<ResolvedConceptReference> returnList = new ArrayList<ResolvedConceptReference>();
	try {
		while(quickIterator.hasNext() && returnList.size() < pageSize){
			returnList.addAll(this.resolveOneHit(quickIterator.next()));
		}
	} catch (LBException e) {
		throw new RuntimeException(e);
	}
	return returnList;
}
 

import org.LexGrid.LexBIG.DataModel.Core.ResolvedConceptReference; //导入依赖的package包/类
public void dumpResolvedValueSetCodingSchemes() {
	int sample_size = 5;
	Vector v = getResolvedValueSetCodingSchemes();
	System.out.println("\nNumber of Resolved Value Set coding schemes: " + v.size());
       for (int i=0; i<5; i++) {
		String t = (String) v.elementAt(i);
		int j = i+1;
		System.out.println("\n" + " (" + j + ") " + t);

		String cs_name = getValueSetCodingSchemeName(t);
		String cs_version = getValueSetCodingSchemeVersion(t);
		System.out.println("\t" + cs_name + " (" + cs_version + ")");

		ResolvedConceptReferenceList samples = generateTestCases(cs_name, cs_version, sample_size, TestCaseGenerator.TYPE_VALUE_SET);
		for (int k=0; k<samples.getResolvedConceptReferenceCount(); k++) {
			ResolvedConceptReference rcr = (ResolvedConceptReference) samples.getResolvedConceptReference(k);
			System.out.println("\t" + rcr.getEntityDescription().getContent() + " (" + rcr.getCode() + ")");
		}
	}
}
 

import org.LexGrid.LexBIG.DataModel.Core.ResolvedConceptReference; //导入依赖的package包/类
public ResolvedConceptReference getRandomResolvedConceptReference(String source) {
   SourceTreeUtils sourceTreeUtils = new SourceTreeUtils(lbSvc);
TreeItem ti = sourceTreeUtils.getSourceTree(source);
if (ti == null) return null;
if (!ti._expandable) {
	return null;
}
Vector v = new Vector();
Iterator iterator = ti._assocToChildMap.keySet().iterator();
while (iterator.hasNext()) {
	String assocText = (String) iterator.next();
	List<TreeItem> children = ti._assocToChildMap.get(assocText);
	for (int k=0; k<children.size(); k++) {
		TreeItem child_ti = (TreeItem) children.get(k);
		ResolvedConceptReference rcr = new ResolvedConceptReference();
		EntityDescription ed = new EntityDescription();
		ed.setContent(child_ti._text);
		rcr.setEntityDescription(ed);
		rcr.setCode(child_ti._code);
		v.add(rcr);
	}
}
if (v.size() == 0) return null;
int m = new RandomVariateGenerator().uniform(0, v.size()-1);
return (ResolvedConceptReference) v.elementAt(m);
  }
 

import org.LexGrid.LexBIG.DataModel.Core.ResolvedConceptReference; //导入依赖的package包/类
/**
  * Get concept Entity by code
  * @param codingScheme
  * @param code
  * @return
  */
 public ResolvedConceptReference getConceptByCode(String codingScheme, String version,
 		String code) {
     CodedNodeSet cns = null;
     ResolvedConceptReferencesIterator iterator = null;

     try {
LexBIGService lbSvc = RemoteServerUtil.createLexBIGService();
         CodingSchemeVersionOrTag csvt = new CodingSchemeVersionOrTag();
         if (version != null) csvt.setVersion(version);

         cns = lbSvc.getCodingSchemeConcepts(codingScheme, csvt);
         ConceptReferenceList crefs =
             createConceptReferenceList(new String[] { code }, codingScheme);
         cns.restrictToCodes(crefs);
         iterator = cns.resolve(null, null, null);
         if (iterator.numberRemaining() > 0) {
             ResolvedConceptReference ref = (ResolvedConceptReference) iterator.next();
             return ref;
         }
     } catch (LBException e) {
         _logger.info("Error: " + e.getMessage());
     }

     return null;
 }
 

import org.LexGrid.LexBIG.DataModel.Core.ResolvedConceptReference; //导入依赖的package包/类
public void dumpMappingCodingSchemes() {
	int sample_size = 5;
	Vector v = getMappingCodingSchemes();
       for (int i=0; i<v.size(); i++) {
		String t = (String) v.elementAt(i);
		int j = i+1;
		System.out.println("\n" + " (" + j + ") " + t);
		String cs_name = getMappingCodingSchemeName(t);
		String cs_version = getMappingCodingSchemeVersion(t);
		System.out.println("\t" + cs_name + " (" + cs_version + ")");

		ResolvedConceptReferenceList samples = generateTestCases(cs_name, cs_version, sample_size, TestCaseGenerator.TYPE_MAPPING);
		for (int k=0; k<samples.getResolvedConceptReferenceCount(); k++) {
			ResolvedConceptReference rcr = (ResolvedConceptReference) samples.getResolvedConceptReference(k);
			System.out.println("\t" + rcr.getEntityDescription().getContent() + " (" + rcr.getCode() + ")");
		}
	}
}
 

import org.LexGrid.LexBIG.DataModel.Core.ResolvedConceptReference; //导入依赖的package包/类
public ResolvedConceptReference	validate(String scheme, String version,
                                            String matchText,
										 String[] associationsToNavigate, String[] association_qualifier_names,
										 String[] association_qualifier_values, int search_direction,
										 String source, String matchAlgorithm, boolean designationOnly,
										 boolean ranking, int maxToReturn
                                            ) {
    ResolvedConceptReferencesIterator iterator = search(scheme, version, matchText,
										 associationsToNavigate, association_qualifier_names,
										 association_qualifier_values, search_direction,
										 source, matchAlgorithm, designationOnly,
										 ranking, maxToReturn);
	if (iterator == null) return null;
	ResolvedConceptReference rcref = null;
	try {
		while(iterator.hasNext()) {
			rcref = iterator.next();
			return rcref;
		}
	} catch (Exception ex) {
		ex.printStackTrace();
	}
	return null;
}
 

import org.LexGrid.LexBIG.DataModel.Core.ResolvedConceptReference; //导入依赖的package包/类
/**
  * Get concept Entity by code
  * @param codingScheme
  * @param code
  * @return
  */
 public ResolvedConceptReference getConceptByCode(String codingScheme, String code) {
     CodedNodeSet cns = null;
     ResolvedConceptReferencesIterator iterator = null;

     try {
LexBIGService lbSvc = RemoteServerUtil.createLexBIGService();
         cns = lbSvc.getCodingSchemeConcepts(codingScheme, null);
         ConceptReferenceList crefs =
             createConceptReferenceList(new String[] { code }, codingScheme);
         cns.restrictToCodes(crefs);
         iterator = cns.resolve(null, null, null);
         if (iterator.numberRemaining() > 0) {
             ResolvedConceptReference ref = (ResolvedConceptReference) iterator.next();
             return ref;
         }
     } catch (LBException e) {
         _logger.info("Error: " + e.getMessage());
     }

     return null;
 }
 

import org.LexGrid.LexBIG.DataModel.Core.ResolvedConceptReference; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
    args = parse(args);
    LexBIGService lbs = RemoteServerUtil.createLexBIGService();
    
    CodedNodeSet cns =
        lbs.getCodingSchemeConcepts("NCI MetaThesaurus", null);
    cns =
        cns.restrictToMatchingDesignations("single dose",
            SearchDesignationOption.ALL, "LuceneQuery", null);

    CodedNodeGraph cng = lbs.getNodeGraph("NCI MetaThesaurus", null, null);
    cng = cng.restrictToTargetCodes(cns);
    ResolvedConceptReferenceList list =
        cng.resolveAsList(null, true, false, 0, 0, null, null, null, null,
            500);

    for (ResolvedConceptReference ref : list.getResolvedConceptReference()) {
        System.out.println("Code: " + ref.getCode());
        System.out.println(" Entity Description"
            + ref.getEntityDescription().getContent());
    }
}
 

import org.LexGrid.LexBIG.DataModel.Core.ResolvedConceptReference; //导入依赖的package包/类
public ResolvedConceptReference validateValueSetSearch(
	                                     String scheme, String version,
                                            String matchText,
                                            String target,
										 String matchAlgorithm,
										 int maxToReturn
                                            ) {
    ResolvedConceptReferencesIterator iterator = searchValueSet(
	                                     scheme, version,
                                            matchText,
                                            target,
										 matchAlgorithm,
										 maxToReturn);

	if (iterator == null) return null;
	ResolvedConceptReference rcref = null;
	try {
		while(iterator.hasNext()) {
			rcref = iterator.next();
			return rcref;
		}
	} catch (Exception ex) {
		ex.printStackTrace();
	}
	return null;
}
 

import org.LexGrid.LexBIG.DataModel.Core.ResolvedConceptReference; //导入依赖的package包/类
public ResolvedConceptReferenceList selectRandomTestCases(ResolvedConceptReferenceList list, int number) {
	ResolvedConceptReferenceList samples = new ResolvedConceptReferenceList();
	if (list.getResolvedConceptReferenceCount() == 0) return samples;
	int max_to_return = number;
	if (max_to_return > list.getResolvedConceptReferenceCount()) {
		max_to_return = list.getResolvedConceptReferenceCount();
	}

	List selected_list = rvGenerator.selectWithNoReplacement(max_to_return, list.getResolvedConceptReferenceCount()-1);
	for (int i=0; i<selected_list.size(); i++) {
		Integer int_obj = (Integer) selected_list.get(i);
		ResolvedConceptReference rcr = list.getResolvedConceptReference(int_obj.intValue());
		samples.addResolvedConceptReference(rcr);
	}
       return samples;
}
 

import org.LexGrid.LexBIG.DataModel.Core.ResolvedConceptReference; //导入依赖的package包/类
/**
 * Prints the.
 *
 * @param ref the ref
 * @param depth the depth
 */
private static void print(ResolvedConceptReference ref, int depth){
	String code = ref.getConceptCode();

	String description;
	if(ref.getEntityDescription() != null){
		description = ref.getEntityDescription().getContent();
	} else {
		description = "";
	}

	System.out.println(buildPrefix(depth) + "Code: " + code + ", Description: " + description + " Hash: " + ref.hashCode());
	if(ref.getSourceOf() != null){
		print(ref.getSourceOf(), depth+1);
	}
	if(ref.getTargetOf() != null){
		print(ref.getTargetOf(), depth+1);
	}
}
 

import org.LexGrid.LexBIG.DataModel.Core.ResolvedConceptReference; //导入依赖的package包/类
public ResolvedConceptReferenceList generateResolvedConceptReferences(String codingScheme, String version, int number) {
	if (version == null) {
		version = codingSchemeDataUtils.getVocabularyVersionByTag(codingScheme, gov.nih.nci.evs.browser.common.Constants.PRODUCTION);
	}

       CodingSchemeVersionOrTag csvt = new CodingSchemeVersionOrTag();
       if (version != null) {
           csvt.setVersion(version);
	}

	ResolvedConceptReferenceList rcrl = new ResolvedConceptReferenceList();
	try {
		LocalNameList entityTypes = new LocalNameList();
		entityTypes.addEntry("concept");
		CodedNodeSet cns = lbSvc.getNodeSet(codingScheme, csvt, entityTypes);

		SortOptionList sortOptions = null;
		LocalNameList filterOptions = null;
		LocalNameList propertyNames = null;
		CodedNodeSet.PropertyType[] propertyTypes = null;
		boolean resolveObjects = false;
		int maxToReturn = number;
           ResolvedConceptReferenceList rvrlist = cns.resolveToList(sortOptions, filterOptions, propertyNames, propertyTypes, resolveObjects, maxToReturn);

           for (int i=0; i<rvrlist.getResolvedConceptReferenceCount(); i++) {
			ResolvedConceptReference rcr = rvrlist.getResolvedConceptReference(i);
			rcrl.addResolvedConceptReference(rcr);
		}
	} catch (Exception ex) {
		ex.printStackTrace();
	}
	return rcrl;
}
 

import org.LexGrid.LexBIG.DataModel.Core.ResolvedConceptReference; //导入依赖的package包/类
@Override
public String extract(ResolvedConceptReference ref) {
	if(ref.getEntityDescription() != null) {
		return ref.getEntityDescription().getContent();
	} else {
		return "";
	}
}
 

import org.LexGrid.LexBIG.DataModel.Core.ResolvedConceptReference; //导入依赖的package包/类
protected void displayRef(OutputStreamWriter osWriter, int k,
    ResolvedConceptReference ref) {
    try {
        osWriter.write("(" + k + ") " + ref.getConceptCode() + ":"
            + ref.getEntityDescription().getContent() + "\n");
    } catch (Exception ex) {
        ex.printStackTrace();
    }
}
 

import org.LexGrid.LexBIG.DataModel.Core.ResolvedConceptReference; //导入依赖的package包/类
private List<EVSConcept> getEVSConcepts(ResolvedConceptReferencesIterator rcRefIter) throws Exception {
	List<EVSConcept> evsConcepts = new ArrayList<EVSConcept>();
	if (rcRefIter != null) {
		while (rcRefIter.hasNext()) {
			ResolvedConceptReference conceptRef = rcRefIter.next();
			
			EVSConcept evsConcept = getEVSConcept(conceptRef);
			
			evsConcepts.add(evsConcept);
		}
	}
	return evsConcepts;
}
 

import org.LexGrid.LexBIG.DataModel.Core.ResolvedConceptReference; //导入依赖的package包/类
public void printNavigationTabTest(PrintWriter out) {
 ResolvedConceptReference rcr = getRandomResolvedConceptReference();
 String code = rcr.getConceptCode();
 test_counter++;
    out.println("    @Test");
    out.println("    public void testNavigationTabTestCase_" + test_counter + "() throws Exception {");
    out.println("    	driver.get(baseUrl + \"/ncimbrowser/\");");
    out.println("		int searchType = 0; //(NAVIGATION_TAB)");
    out.println("    	try {");
    out.println("	    	driver.findElement(By.id(\"matchText\")).clear();");
    out.println("			Thread.sleep(1000);");
    out.println("			driver.findElement(By.id(\"matchText\")).sendKeys(\"" + code + "\");");
    out.println("			Thread.sleep(1000);");
    out.println("			driver.findElement(By.id(\"searchTarget1\")).click();");
    out.println("			Thread.sleep(1000);");
    out.println("			driver.findElement(By.id(\"searchTerm:search\")).click();");
    out.println("			Thread.sleep(1000);");
    out.println("			driver.findElement(By.name(\"sdTab\")).click();");
    out.println("			Thread.sleep(1000);");
    out.println("			driver.findElement(By.name(\"relTab\")).click();");
    out.println("			Thread.sleep(2000);");
    out.println("			driver.findElement(By.name(\"sourceTab\")).click();");
    out.println("			Thread.sleep(2000);");
    out.println("			driver.findElement(By.name(\"vaTab\")).click();");
    out.println("			Thread.sleep(1000);");
    out.println("			driver.findElement(By.cssSelector(\"div.vocabularynamebanner\")).click();");
    out.println("			Thread.sleep(1000);");
    out.println("			assertTrue(true);");
    out.println("    	} catch (Exception ex) {");
    out.println("			ex.printStackTrace();");
    out.println("			assertTrue(false);");
    out.println("    	}");
    out.println("    }");
}
 

import org.LexGrid.LexBIG.DataModel.Core.ResolvedConceptReference; //导入依赖的package包/类
public void printTestSourceHelp(PrintWriter out) {
 String method_name = "testSourceHelp";
 out.println("    @Test // (" + method_name + ")");
 out.println("    public void testSourceHelp() throws Exception {");
 out.println("		driver.get(baseUrl + \"/ncimbrowser/\");");
 String scheme = gov.nih.nci.evs.browser.common.Constants.NCI_METATHESAURUS;
 String version = NCIm_PROD_Version;
 //ResolvedConceptReferenceList testCases = testUtils.generateTestCases(scheme, version, 10, TestCaseGenerator.TYPE_TERMINOLOGY);
 ResolvedConceptReferenceList testCases = ncimTestCases;//testUtils.generateTestCases(scheme, version, 10, TestCaseGenerator.TYPE_TERMINOLOGY);
 int n = rvGenerator.uniform(0, testCases.getResolvedConceptReferenceCount()-1);
 ResolvedConceptReference rcr = (ResolvedConceptReference) testCases.getResolvedConceptReference(n);
 if (rcr == null) {
  	System.out.println("ResolvedConceptReference is NULL -- return ");
 }
 String code = rcr.getConceptCode();
    out.println("        driver.findElement(By.xpath(\"//input[@name='algorithm'][@value='exactMatch']\")).click();");
 out.println("		driver.findElement(By.name(\"matchText\")).clear();");
 out.println("		driver.findElement(By.id(\"searchTarget1\")).click();");
 out.println("		driver.findElement(By.name(\"matchText\")).sendKeys(\"" + code + "\");");

    out.println("		driver.findElement(By.id(\"searchTerm:search\")).click();");
    out.println("		Thread.sleep(1000);");
    out.println("		driver.findElement(By.name(\"sdTab\")).click();");
    out.println("		Thread.sleep(1000);");
    out.println("		driver.findElement(By.cssSelector(\"img[alt=\\\"Source List\\\"]\")).click();");

    out.println("		String bodyText = null;");
    out.println("		String matchedString = \"National Cancer Institute Thesaurus\";");
    out.println("		Thread.sleep(4000);");
    out.println("		bodyText = getPopupWindowBodyText(driver);");
    out.println("		assertTrue(bodyText.contains(matchedString));");
    out.println("		Thread.sleep(1000);    ");
 out.println("    }");
 out.println("");
}
 

import org.LexGrid.LexBIG.DataModel.Core.ResolvedConceptReference; //导入依赖的package包/类
ResolvedConceptReferenceList generateNCImResolvedConceptReferenceList(int number) {
  String scheme = gov.nih.nci.evs.browser.common.Constants.NCI_THESAURUS;
  String version = null;
  ResolvedConceptReferenceList rcrl = testUtils.generateTestCases(scheme, version, number, TestCaseGenerator.TYPE_TERMINOLOGY);
//Generate NCI Thesaurus
// map NCI Thesaurus to NCIm Metahesaurus
  String ncim_scheme = gov.nih.nci.evs.browser.common.Constants.NCI_METATHESAURUS;
  String ncim_version = NCIm_PROD_Version;
  ResolvedConceptReferenceList testCases = new ResolvedConceptReferenceList();
     if (rcrl != null) {
   for (int i=0; i<rcrl.getResolvedConceptReferenceCount(); i++) {
	   ResolvedConceptReference rcr = (ResolvedConceptReference) rcrl.getResolvedConceptReference(i);
	   String code = rcr.getConceptCode();
	   Vector v = metathesaurusUtils.getMatchedMetathesaurusCUIs(scheme, version, null, code);
	   if (v != null && v.size() > 0) {
		   ResolvedConceptReference ncim_rcr = new ResolvedConceptReference();
		   //Entity entity = conceptDetails.getConceptByCode(ncim_scheme, ncim_version, code);

		   Entity entity = new Entity();
		   String cui = (String) v.elementAt(0);
		   entity.setEntityCodeNamespace(ncim_scheme);
		   entity.setEntityCode(cui);

		   ncim_rcr.setEntity(entity);
		   ncim_rcr.setConceptCode(code);
		   ncim_rcr.setCodingSchemeName(ncim_scheme);
		   //ncim_rcr.setEntityDescription(entity.getEntityDescription());
		   testCases.addResolvedConceptReference(ncim_rcr);
		   if (testCases.getResolvedConceptReferenceCount() == NCIM_TEST_CASES) break;
       }
   }

  } else {
  		System.out.println("WARNING: generateNCImResolvedConceptReferenceList rcrl returns null???");
     }
  return testCases;
 }