Java NameUsageSearchResult类代码示例

import org.gbif.api.model.checklistbank.search.NameUsageSearchResult; //导入依赖的package包/类
public List<NameUsageSearchResult> fullTextSearch(NameUsageSearchRequest searchRequest) {
List<NameUsageSearchResult> result = Lists.newArrayList();
SearchResponse<NameUsageSearchResult, NameUsageSearchParameter> response = null;

boolean isInitial = true;
do {
    response = search(searchRequest);
    if(response == null)
	break;
    result.addAll(response.getResults());
    int limit = response.getLimit();
    if (isInitial) {
	limit = Pager.getMaxLimit(response);
	isInitial = false;
    }
    searchRequest.setLimit(limit);
    searchRequest.setOffset(response.getOffset() + limit);
}
while(!Pager.isEndOfRecords(response));

return result;
   }
 

import org.gbif.api.model.checklistbank.search.NameUsageSearchResult; //导入依赖的package包/类
public NubNameUsage(org.gbif.api.model.checklistbank.NameUsage scientificNameUsage,
			  NameUsageSearchResult nameUsageSearchResult,
			  NameUsageSuggestResult nameUsageSuggestResult) {
super();
if(isConformal(scientificNameUsage, nameUsageSearchResult, nameUsageSuggestResult)) {
    if(scientificNameUsage != null) {
	setScientificName(scientificNameUsage);
    }
    if(nameUsageSearchResult != null) {
	setNameUsageSearchResult(nameUsageSearchResult);
    }
    if(nameUsageSuggestResult != null){
	setNameUsageSuggestResult(nameUsageSuggestResult);
    }
}
   }
 

import org.gbif.api.model.checklistbank.search.NameUsageSearchResult; //导入依赖的package包/类
protected NubNameUsage createNubNameUsage(NameUsageSearchResult result)
throws IOException
   {
NubNameUsage nameUsage = getObject(result.getKey());
if (nameUsage == null) {
    nameUsage = new NubNameUsage(result);
    nubNameUsages.put(result.getKey(), nameUsage);
    UUID datasetKey = result.getDatasetKey();
    if(datasetKey != null) {
	nameUsage.setDataset(getDataset(datasetKey));
    }
    datasetKey = result.getConstituentKey();
    if(datasetKey != null) {
	nameUsage.setConstituentDataset(getDataset(datasetKey));
    }
}
return nameUsage;
   }
 

import org.gbif.api.model.checklistbank.search.NameUsageSearchResult; //导入依赖的package包/类
private SearchResponse<NameUsageSearchResult, NameUsageSearchParameter> assertSearch(NameUsageSearchRequest searchRequest, boolean useFacets,
                                                                                     Long expectedCount, String expectedFacetCounts) {

  // query
  SearchResponse<NameUsageSearchResult, NameUsageSearchParameter> response = wsClient.search(searchRequest);

  // assert
  if (expectedCount != null) {
    assertEquals(expectedCount, response.getCount());
  }

  if (useFacets && expectedFacetCounts != null) {
    assertEquals(1, response.getFacets().size());
    assertEquals(expectedFacetCounts, response.getFacets().get(0).getCounts().size());
  }
  if (!useFacets) {
    Assert.assertTrue(response.getFacets().isEmpty());
  }

  for (NameUsageSearchResult u : response.getResults()) {
    assertNotNull(u);
    assertEquals(NameUsageSearchResult.class, u.getClass());
  }

  return response;
}
 

import org.gbif.api.model.checklistbank.search.NameUsageSearchResult; //导入依赖的package包/类
@Test
@PrepareForTest(WebResource.Builder.class)
public void testList() {
  WebResource.Builder builder = PowerMockito.mock(WebResource.Builder.class);
  NameUsageSearchRequest searchRequest = new NameUsageSearchRequest(DEFAULT_PARAM_OFFSET, DEFAULT_PARAM_LIMIT);
  searchRequest.setQ("*");
  when(resource.type(any(String.class))).thenReturn(builder);
  when(resource.accept(any(String.class))).thenReturn(builder);
  // there is no path, it uses the default URL /checklist
  SearchResponse<NameUsageSearchResult, NameUsageSearchParameter> defaultResponse =
    new SearchResponse<NameUsageSearchResult, NameUsageSearchParameter>(DEFAULT_PARAM_OFFSET, DEFAULT_PARAM_LIMIT);
  when(builder.get(any(GenericType.class))).thenReturn(defaultResponse);
  when(resource.get(any(GenericType.class))).thenReturn(defaultResponse);

  SearchResponse<NameUsageSearchResult, NameUsageSearchParameter> response = client.search(searchRequest);
  Assert.assertNotNull(response);
}
 

import org.gbif.api.model.checklistbank.search.NameUsageSearchResult; //导入依赖的package包/类
/**
 * Builds a SearchResponse instance using the current builder state.
 *
 * @return a new instance of a SearchResponse.
 */
public SearchResponse<NameUsageSearchResult, NameUsageSearchParameter> buildSearch(NameUsageSearchRequest searchRequest, QueryResponse response) {
  // Create response
  SearchResponse<NameUsageSearchResult, NameUsageSearchParameter> resp = new SearchResponse<NameUsageSearchResult, NameUsageSearchParameter>(searchRequest);
  resp.setCount(response.getResults().getNumFound());
  resp.setLimit(response.getResults().size());

  // Main result documents
  SolrDocumentList docs = response.getResults();
  for (SolrDocument doc : docs) {
    resp.getResults().add(converter.toSearchUsage(doc, searchRequest.isExtended()));
  }

  // add facets
  setFacets(resp, response);

  // add highlighting
  setHighlighting(resp, response, searchRequest);
  return resp;
}
 

import org.gbif.api.model.checklistbank.search.NameUsageSearchResult; //导入依赖的package包/类
/**
 * Helper method that takes Solr response and extracts the facets results.
 * The facets are converted to a list of Facets understood by the search API.
 * The result of this method can be a empty list.
 *
 * @param queryResponse that contains the facets information returned by Solr
 * @return the List of facets retrieved from the Solr response
 */
private void setFacets(SearchResponse<NameUsageSearchResult, NameUsageSearchParameter> response, final QueryResponse queryResponse) {
  List<Facet<NameUsageSearchParameter>> facets = Lists.newArrayList();
  if (queryResponse.getFacetFields() != null) {
    List<FacetField> facetFields =  queryResponse.getFacetFields();
    for (final FacetField facetField : facetFields) {
      NameUsageSearchParameter facetParam = SolrMapping.FACET_MAPPING.inverse().get(facetField.getName());
      Facet<NameUsageSearchParameter> facet = new Facet<NameUsageSearchParameter>(facetParam);

      List<Facet.Count> counts = Lists.newArrayList();
      if (facetField.getValues() != null) {
        for (final FacetField.Count count : facetField.getValues()) {
          String value = SolrMapping.interpretSolrValue(facetParam, count.getName());
          counts.add(new Facet.Count(value, count.getCount()));
        }
      }
      facet.setCounts(counts);
      facets.add(facet);
    }
  }
  response.setFacets(facets);
}
 

import org.gbif.api.model.checklistbank.search.NameUsageSearchResult; //导入依赖的package包/类
public String getDatasetTitle()
   {
NameUsage<? extends NubNameUsage> n = getNameUsage();
if(n != this) {
    if(n instanceof NubNameUsage) {
	return ((NubNameUsage)n).getDatasetTitle();
    }
}

if(dataset != null) {
    return dataset.getTitle();
}
else {
    UUID datasetKey = null;
    org.gbif.api.model.checklistbank.NameUsage scientificNameUsage = getScientificNameUsage();
    if(scientificNameUsage != null) {
	datasetKey = scientificNameUsage.getDatasetKey();
    }
    if(datasetKey == null) {
	NameUsageSearchResult nameUsageSearchResult = getNameUsageSearchResult();
	if(nameUsageSearchResult != null) {
	    datasetKey = nameUsageSearchResult.getDatasetKey();
	}
    }
    if(datasetKey != null) {
	return datasetKey.toString();
    }
}

return null;
   }
 

import org.gbif.api.model.checklistbank.search.NameUsageSearchResult; //导入依赖的package包/类
protected boolean isConformal(org.gbif.api.model.checklistbank.NameUsage scientificNameUsage,
			  NameUsageSearchResult nameUsageSearchResult,
			  NameUsageSuggestResult nameUsageSuggestResult)
   {
return isConformal(nameUsageSearchResult, nameUsageSuggestResult) &&
    isConformal(scientificNameUsage, nameUsageSuggestResult) &&
    isConformal(scientificNameUsage, nameUsageSearchResult);
   }
 

import org.gbif.api.model.checklistbank.search.NameUsageSearchResult; //导入依赖的package包/类
public boolean setNameUsageSearchResult(NameUsageSearchResult nameUsageSearchResult)
   {
NameUsage<? extends NubNameUsage> n = getNameUsage();
if(n != this) {
    if(n instanceof NubNameUsage) {
	return ((NubNameUsage)n).setNameUsageSearchResult(nameUsageSearchResult);
    }
}

if(this.nameUsageSearchResult == nameUsageSearchResult ||
   (this.nameUsageSearchResult != null && nameUsageSearchResult != null &&
    this.nameUsageSearchResult.equals(nameUsageSearchResult)) ||
   !isConformal(this.scientificNameUsage, nameUsageSearchResult, this.nameUsageSuggestResult)
   ){
    return false;
}

clearNameUsageSearchResult();
if(scientificNameUsage == null && nameUsageSearchResult != null) {
    setRank(RankMap.get(RankMap.get(nameUsageSearchResult.getRank().getMarker())));
    if(nameUsageSearchResult.getNumDescendants() == 0) {
	setLowerNameUsages(null);
	this.lowerNameUsages = Collections.emptyList();
    }
}

this.nameUsageSearchResult = nameUsageSearchResult;

return true;
   }
 

import org.gbif.api.model.checklistbank.search.NameUsageSearchResult; //导入依赖的package包/类
protected Collection<NubNameUsage> getFullTextNameUsages(String query, Rank rank, boolean includeSynonyms, boolean includeVernaculars, Locale locale)
throws IOException
   {
String[] literals = splitQuery(query);
if (literals == null)
    return null;

List<NubNameUsage> nameUsages = null;
for (String literal : literals) {
    List<NameUsageSearchResult> results = dataSource.fullTextSearch(literal, RankMap.get(rank), 
								    null, null, null, null, null, null, null, null, null, null, null);
    if(results != null) {
	nameUsages = new ArrayList<NubNameUsage>(results.size());
	for (NameUsageSearchResult result : results) {
	    NubNameUsage nameUsage = getObject(result.getKey());
	    if(nameUsage == null) {
		nameUsage = createNubNameUsage(result);
		//nameUsage = new NubNameUsage(result);
		//nubNameUsages.put(result.getKey(), nameUsage);
	    }
	    //else
	    nameUsage.setNameUsageSearchResult(result);
	    nameUsages.add(nameUsage);
	}
	results.clear();
    }
}
return nameUsages;
   }
 

import org.gbif.api.model.checklistbank.search.NameUsageSearchResult; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
  mockNameUsageService = mock(NameUsageService.class);
  mockVernacularNameService = mock(VernacularNameService.class);
  mockTypeSpecimenService = mock(TypeSpecimenService.class);
  mockSpeciesProfileService = mock(SpeciesProfileService.class);
  mockReferenceService = mock(ReferenceService.class);
  mockImageService = mock(MultimediaService.class);
  mockDescriptionService = mock(DescriptionService.class);
  mockDistributionService = mock(DistributionService.class);
  mockIdentifierService = mock(IdentifierService.class);
  mockSearchService = mock(NameUsageSearchService.class);
  mockUsageCountMapper = mock(UsageCountMapper.class);

  searchResponse = new SearchResponse<NameUsageSearchResult, NameUsageSearchParameter>(0, 20);
  searchResponse.setCount(1000L);

  resource = new SpeciesResource(mockNameUsageService, mockVernacularNameService, mockTypeSpecimenService,
    mockSpeciesProfileService, mockReferenceService, mockImageService, mockDescriptionService,
    mockDistributionService, mockIdentifierService, mockSearchService, mockUsageCountMapper);

  locale = Locale.US;
  nameUsage = new NameUsage();
  nameUsage.setKey(NAME_USAGE_KEY);

  page = new PagingRequest(0, 1);
}
 

import org.gbif.api.model.checklistbank.search.NameUsageSearchResult; //导入依赖的package包/类
@Test
public void searchHighlightTest() {
  NameUsageSearchRequest searchRequest = new NameUsageSearchRequest(DEFAULT_PARAM_OFFSET, DEFAULT_PARAM_LIMIT);
  searchRequest.setQ("puma");
  searchRequest.setHighlight(true);
  SearchResponse<NameUsageSearchResult, NameUsageSearchParameter> response = wsClient.search(searchRequest);
  assertNotNull(response);
}
 

import org.gbif.api.model.checklistbank.search.NameUsageSearchResult; //导入依赖的package包/类
@Test
public void searchTest() {
  NameUsageSearchRequest searchRequest = new NameUsageSearchRequest(DEFAULT_PARAM_OFFSET, DEFAULT_PARAM_LIMIT);
  searchRequest.setQ("puma");
  searchRequest.addFacets(NameUsageSearchParameter.DATASET_KEY);
  searchRequest.addParameter(NameUsageSearchParameter.DATASET_KEY, Constants.NUB_DATASET_KEY.toString());
  searchRequest.setMultiSelectFacets(true);
  SearchResponse<NameUsageSearchResult, NameUsageSearchParameter> response = wsClient.search(searchRequest);
  assertNotNull(response);
}
 

import org.gbif.api.model.checklistbank.search.NameUsageSearchResult; //导入依赖的package包/类
@Test
public void searchTestWithNubKey() {
  NameUsageSearchRequest searchRequest = new NameUsageSearchRequest(DEFAULT_PARAM_OFFSET, DEFAULT_PARAM_LIMIT);
  searchRequest.setQ("oenanthe");
  searchRequest.addParameter(NameUsageSearchParameter.HIGHERTAXON_KEY, "3184223");
  searchRequest.addFacets(NameUsageSearchParameter.DATASET_KEY);
  searchRequest.addParameter(NameUsageSearchParameter.DATASET_KEY, Constants.NUB_DATASET_KEY.toString());
  SearchResponse<NameUsageSearchResult, NameUsageSearchParameter> response = wsClient.search(searchRequest);
  assertNotNull(response);
}