Java ErrorCode.NOT_FOUND属性代码示例

@Override
public Representation get() {
  try {
    final String defaultSearchFieldName = getSchema().getDefaultSearchFieldName();
    if (null == defaultSearchFieldName) {
      final String message = "undefined " + IndexSchema.DEFAULT_SEARCH_FIELD;
      throw new SolrException(ErrorCode.NOT_FOUND, message);
    }
    getSolrResponse().add(IndexSchema.DEFAULT_SEARCH_FIELD, defaultSearchFieldName);
  } catch (Exception e) {
    getSolrResponse().setException(e);
  }
  handlePostExecution(log);

  return new SolrOutputRepresentation();
}
 

/**
 * Implements the GET request to provide the list of words to the client.
 * Alternatively, if a specific word is requested, then it is returned
 * or a 404 is raised, indicating that the requested word does not exist.
 */
@Override
public void doGet(BaseSolrResource endpoint, String childId) {
  SolrQueryResponse response = endpoint.getSolrResponse();
  if (childId != null) {
    // downcase arg if we're configured to ignoreCase
    String key = getIgnoreCase() ? childId.toLowerCase(Locale.ROOT) : childId;       
    if (!managedWords.contains(key))
      throw new SolrException(ErrorCode.NOT_FOUND, 
          String.format(Locale.ROOT, "%s not found in %s", childId, getResourceId()));
      
    response.add(childId, key);
  } else {
    response.add(WORD_SET_JSON_FIELD, buildMapToStore(managedWords));      
  }
}
 

@Override
public void doGet(BaseSolrResource endpoint, String childId) {
  SolrQueryResponse response = endpoint.getSolrResponse();
  if (childId != null) {
    boolean ignoreCase = getIgnoreCase();
    String key = applyCaseSetting(ignoreCase, childId);
    
    // if ignoreCase==true, then we get the mappings using the lower-cased key
    // and then return a union of all case-sensitive keys, if false, then
    // we only return the mappings for the exact case requested
    CasePreservedSynonymMappings cpsm = synonymMappings.get(key);
    Set<String> mappings = (cpsm != null) ? cpsm.getMappings(ignoreCase, childId) : null;
    if (mappings == null)
      throw new SolrException(ErrorCode.NOT_FOUND,
          String.format(Locale.ROOT, "%s not found in %s", childId, getResourceId()));          
    
    response.add(childId, mappings);
  } else {
    response.add(SYNONYM_MAPPINGS, buildMapToStore(getStoredView()));      
  }
}
 

@Override
public void handleRequestBody(SolrQueryRequest req, SolrQueryResponse rsp) throws Exception {
  // Make sure the cores is enabled
  CoreContainer cores = getCoreContainer();
  if (cores == null) {
    throw new SolrException(SolrException.ErrorCode.BAD_REQUEST,
            "Core container instance missing");
  }

  String path = (String) req.getContext().get("path");
  int i = path.lastIndexOf('/');
  String name = path.substring(i + 1, path.length());
  
  if (name.equalsIgnoreCase("properties")) {
    propertiesHandler.handleRequest(req, rsp);
  } else if (name.equalsIgnoreCase("threads")) {
    threadDumpHandler.handleRequest(req, rsp);
  } else if (name.equalsIgnoreCase("logging")) {
    loggingHandler.handleRequest(req, rsp);
  }  else if (name.equalsIgnoreCase("system")) {
    systemInfoHandler.handleRequest(req, rsp);
  } else {
    if (name.equalsIgnoreCase("info")) name = "";
    throw new SolrException(ErrorCode.NOT_FOUND, "Info Handler not found: " + name);
  }
  
  rsp.setHttpCaching(false);
}
 

/**
 * Deletes words managed by this resource.
 */
@Override
public synchronized void doDeleteChild(BaseSolrResource endpoint, String childId) {
  // downcase arg if we're configured to ignoreCase
  String key = getIgnoreCase() ? childId.toLowerCase(Locale.ROOT) : childId;       
  if (!managedWords.contains(key))
    throw new SolrException(ErrorCode.NOT_FOUND, 
        String.format(Locale.ROOT, "%s not found in %s", childId, getResourceId()));

  managedWords.remove(key);
  storeManagedData(managedWords);
  log.info("Removed word: {}", key);
}
 

@Override
public synchronized void doDeleteChild(BaseSolrResource endpoint, String childId) {
  boolean ignoreCase = getIgnoreCase();
  String key = applyCaseSetting(ignoreCase, childId);
  
  CasePreservedSynonymMappings cpsm = synonymMappings.get(key);
  if (cpsm == null)
    throw new SolrException(ErrorCode.NOT_FOUND, 
        String.format(Locale.ROOT, "%s not found in %s", childId, getResourceId()));

  if (ignoreCase) {
    // delete all mappings regardless of case
    synonymMappings.remove(key);
  } else {
    // just delete the mappings for the specific case-sensitive key
    if (cpsm.mappings.containsKey(childId)) {
      cpsm.mappings.remove(childId);
      
      if (cpsm.mappings.isEmpty())
        synonymMappings.remove(key);            
    } else {
      throw new SolrException(ErrorCode.NOT_FOUND, 
          String.format(Locale.ROOT, "%s not found in %s", childId, getResourceId()));          
    }
  }
  
  // store the updated data (using the stored view)
  storeManagedData(getStoredView());
  
  log.info("Removed synonym mappings for: {}", childId);      
}
 

@Override
public void init(Map<String,String> params) throws SolrException {
  this.currencyConfigFile = params.get(PARAM_CURRENCY_CONFIG);
  if(currencyConfigFile == null) {
    throw new SolrException(ErrorCode.NOT_FOUND, "Missing required configuration "+PARAM_CURRENCY_CONFIG);
  }
  
  // Removing config params custom to us
  params.remove(PARAM_CURRENCY_CONFIG);
}
 

@Override
  public double getExchangeRate(String sourceCurrencyCode, String targetCurrencyCode) {
//    System.out.println("***** getExchangeRate("+sourceCurrencyCode+targetCurrencyCode+")");
    if(sourceCurrencyCode.equals(targetCurrencyCode)) return 1.0;

    Double result = map.get(sourceCurrencyCode+","+targetCurrencyCode);
    if(result == null) {
      throw new SolrException(ErrorCode.NOT_FOUND, "No exchange rate found for the pair "+sourceCurrencyCode+","+targetCurrencyCode);
    }
    return result;
  }