String getKey() {
    try {
      String key = "";

      key += "-" + scope.getBrowseIndex().getName();
      key += "-" + scope.getBrowseLevel();
      key += "-" + scope.getStartsWith();
      key += "-" + scope.getResultsPerPage();
      key += "-" + scope.getSortBy();
      key += "-" + scope.getSortOption().getNumber();
      key += "-" + scope.getOrder();
      key += "-" + scope.getJumpToItem();
      key += "-" + scope.getFilterValue();
      key += "-" + scope.getFilterValueLang();
      key += "-" + scope.getJumpToValue();
      key += "-" + scope.setJumpToValueLang();
      key += "-" + etAl;

      return key;
    } catch (Exception e) {
      return null; // ignore exception and return no key
    }
  }
Esempio n. 2
0
  /**
   * Browse the archive by single values (such as the name of an author). This produces a BrowseInfo
   * object that contains Strings as the results of the browse
   *
   * @param bs the scope of the browse
   * @return the results of the browse
   * @throws BrowseException
   */
  private BrowseInfo browseByValue(BrowserScope bs) throws BrowseException {
    log.info(LogManager.getHeader(context, "browse_by_value", "focus=" + bs.getJumpToValue()));

    try {
      // get the table name that we are going to be getting our data from
      // this is the distinct table constrained to either community or collection
      dao.setTable(browseIndex.getDistinctTableName());

      // remind the DAO that this is a distinct value browse, so it knows what sort
      // of query to build
      dao.setDistinct(true);

      // tell the browse query whether we are ascending or descending on the value
      dao.setAscending(scope.isAscending());

      // set our constraints on community or collection
      if (scope.inCollection() || scope.inCommunity()) {
        // Scoped browsing of distinct metadata requires the mapping
        // table to be specified.
        dao.setFilterMappingTables(null, browseIndex.getMapTableName());

        if (scope.inCollection()) {
          Collection col = (Collection) scope.getBrowseContainer();
          dao.setContainerTable("collection2item");
          dao.setContainerIDField("collection_id");
          dao.setContainerID(col.getID());
        } else if (scope.inCommunity()) {
          Community com = (Community) scope.getBrowseContainer();
          dao.setContainerTable("communities2item");
          dao.setContainerIDField("community_id");
          dao.setContainerID(com.getID());
        }
      }

      // this is the total number of results in answer to the query
      int total = getTotalResults(true);

      // set the ordering field (there is only one option)
      dao.setOrderField("sort_value");

      // assemble the focus clause if we are to have one
      // it will look like one of the following
      // - sort_value < myvalue
      // = sort_1 > myvalue
      dao.setJumpToField("sort_value");
      int offset = scope.getOffset();
      String rawFocusValue = null;
      if (offset < 1 && scope.hasJumpToValue() || scope.hasStartsWith()) {
        String focusValue = getJumpToValue();

        // store the value to tell the Browse Info object which value we are browsing on
        rawFocusValue = focusValue;

        // make sure the incoming value is normalised
        focusValue = normalizeJumpToValue(focusValue);

        offset = getOffsetForDistinctValue(focusValue);
      }

      // assemble the offset and limit
      dao.setOffset(offset);
      dao.setLimit(scope.getResultsPerPage());

      // Holder for the results
      List<String[]> results = null;

      // Does this browse have any contents?
      if (total > 0) {
        // now run the query
        results = dao.doValueQuery();

        // now, if we don't have any results, we are at the end of the browse.  This will
        // be because a starts_with value has been supplied for which we don't have
        // any items.
        if (results.size() == 0) {
          // In this case, we will calculate a new offset for the last page of results
          offset = total - scope.getResultsPerPage();
          if (offset < 0) {
            offset = 0;
          }

          // And rerun the query
          dao.setOffset(offset);
          results = dao.doValueQuery();
        }
      } else {
        // No records, so make an empty list
        results = new ArrayList<String[]>();
      }

      // construct the BrowseInfo object to pass back
      BrowseInfo browseInfo = new BrowseInfo(results, offset, total, offset);

      if (offset + scope.getResultsPerPage() < total) {
        browseInfo.setNextOffset(offset + scope.getResultsPerPage());
      }

      if (offset - scope.getResultsPerPage() > -1) {
        browseInfo.setPrevOffset(offset - scope.getResultsPerPage());
      }

      // add the browse index to the Browse Info
      browseInfo.setBrowseIndex(browseIndex);

      // set the sort option for the Browse Info
      browseInfo.setSortOption(scope.getSortOption());

      // tell the Browse Info which way we are sorting
      browseInfo.setAscending(scope.isAscending());

      // tell the Browse Info which level of browse we are at
      browseInfo.setBrowseLevel(scope.getBrowseLevel());

      // set the browse value if there is one
      browseInfo.setFocus(rawFocusValue);

      // tell the browse info if it is working from a starts with parameter
      browseInfo.setStartsWith(scope.hasStartsWith());

      // tell the browse info what the container for the browse was
      if (scope.inCollection() || scope.inCommunity()) {
        browseInfo.setBrowseContainer(scope.getBrowseContainer());
      }

      browseInfo.setResultsPerPage(scope.getResultsPerPage());

      return browseInfo;
    } catch (SQLException e) {
      log.error("caught exception: ", e);
      throw new BrowseException(e);
    }
  }
Esempio n. 3
0
  /**
   * Perform a limited browse, which only returns the results requested, without any extraneous
   * information. To perform a full browse, use BrowseEngine.browse() above. This supports Item
   * browse only, and does not currently support focus or values. This method is used, for example,
   * to generate the Recently Submitted Items results.
   *
   * @param bs the scope of the browse
   * @return the results of the browse
   */
  public BrowseInfo browseMini(BrowserScope bs) throws BrowseException {
    log.info(LogManager.getHeader(context, "browse_mini", ""));

    // load the scope into the object
    this.scope = bs;

    // since we use it so much, get the browse index out of the
    // scope and store as a member
    browseIndex = scope.getBrowseIndex();

    // get the table name that we are going to be getting our data from
    dao.setTable(browseIndex.getTableName());

    // tell the browse query whether we are ascending or descending on the value
    dao.setAscending(scope.isAscending());

    // define a clause for the WHERE clause which will allow us to constrain
    // our browse to a specified community or collection
    if (scope.inCollection() || scope.inCommunity()) {
      if (scope.inCollection()) {
        Collection col = (Collection) scope.getBrowseContainer();
        dao.setContainerTable("collection2item");
        dao.setContainerIDField("collection_id");
        dao.setContainerID(col.getID());
      } else if (scope.inCommunity()) {
        Community com = (Community) scope.getBrowseContainer();
        dao.setContainerTable("communities2item");
        dao.setContainerIDField("community_id");
        dao.setContainerID(com.getID());
      }
    }

    dao.setOffset(scope.getOffset());
    dao.setLimit(scope.getResultsPerPage());

    // assemble the ORDER BY clause
    String orderBy = browseIndex.getSortField(scope.isSecondLevel());
    if (scope.getSortBy() > 0) {
      orderBy = "sort_" + Integer.toString(scope.getSortBy());
    }
    dao.setOrderField(orderBy);

    // now run the query
    List<BrowseItem> results = dao.doQuery();

    // construct the mostly empty BrowseInfo object to pass back
    BrowseInfo browseInfo = new BrowseInfo(results, 0, scope.getResultsPerPage(), 0);

    // add the browse index to the Browse Info
    browseInfo.setBrowseIndex(browseIndex);

    // set the sort option for the Browse Info
    browseInfo.setSortOption(scope.getSortOption());

    // tell the Browse Info which way we are sorting
    browseInfo.setAscending(scope.isAscending());

    // tell the browse info what the container for the browse was
    if (scope.inCollection() || scope.inCommunity()) {
      browseInfo.setBrowseContainer(scope.getBrowseContainer());
    }

    browseInfo.setResultsPerPage(scope.getResultsPerPage());

    browseInfo.setEtAl(scope.getEtAl());

    return browseInfo;
  }
Esempio n. 4
0
  /**
   * Browse the archive by the full item browse mechanism. This produces a BrowseInfo object which
   * contains full BrowseItem objects as its result set.
   *
   * @param bs the scope of the browse
   * @return the results of the browse
   * @throws BrowseException
   */
  private BrowseInfo browseByItem(BrowserScope bs) throws BrowseException {
    log.info(LogManager.getHeader(context, "browse_by_item", ""));
    try {
      // get the table name that we are going to be getting our data from
      dao.setTable(browseIndex.getTableName());

      // tell the browse query whether we are ascending or descending on the value
      dao.setAscending(scope.isAscending());

      // assemble the value clause
      String rawValue = null;
      if (scope.hasFilterValue() && scope.isSecondLevel()) {
        String value = scope.getFilterValue();
        rawValue = value;

        // make sure the incoming value is normalised
        value =
            OrderFormat.makeSortString(
                value, scope.getFilterValueLang(), scope.getBrowseIndex().getDataType());

        dao.setAuthorityValue(scope.getAuthorityValue());

        // set the values in the Browse Query
        if (scope.isSecondLevel()) {
          dao.setFilterValueField("value");
          dao.setFilterValue(rawValue);
        } else {
          dao.setFilterValueField("sort_value");
          dao.setFilterValue(value);
        }
        dao.setFilterValuePartial(scope.getFilterValuePartial());

        // to apply the filtering, we need the distinct and map tables for the index
        dao.setFilterMappingTables(
            browseIndex.getDistinctTableName(), browseIndex.getMapTableName());
      }

      // define a clause for the WHERE clause which will allow us to constrain
      // our browse to a specified community or collection
      if (scope.inCollection() || scope.inCommunity()) {
        if (scope.inCollection()) {
          Collection col = (Collection) scope.getBrowseContainer();
          dao.setContainerTable("collection2item");
          dao.setContainerIDField("collection_id");
          dao.setContainerID(col.getID());
        } else if (scope.inCommunity()) {
          Community com = (Community) scope.getBrowseContainer();
          dao.setContainerTable("communities2item");
          dao.setContainerIDField("community_id");
          dao.setContainerID(com.getID());
        }
      }

      // this is the total number of results in answer to the query
      int total = getTotalResults();

      // assemble the ORDER BY clause
      String orderBy = browseIndex.getSortField(scope.isSecondLevel());
      if (scope.getSortBy() > 0) {
        orderBy = "sort_" + Integer.toString(scope.getSortBy());
      }
      dao.setOrderField(orderBy);

      int offset = scope.getOffset();
      String rawFocusValue = null;
      if (offset < 1
          && (scope.hasJumpToItem() || scope.hasJumpToValue() || scope.hasStartsWith())) {
        // We need to convert these to an offset for the actual browse query.
        // First, get a value that we can look up in the ordering field
        rawFocusValue = getJumpToValue();

        // make sure the incoming value is normalised
        String focusValue = normalizeJumpToValue(rawFocusValue);

        log.debug("browsing using focus: " + focusValue);

        // Convert the focus value into an offset
        offset = getOffsetForValue(focusValue);
      }

      dao.setOffset(offset);

      // assemble the LIMIT clause
      dao.setLimit(scope.getResultsPerPage());

      // Holder for the results
      List<BrowseItem> results = null;

      // Does this browse have any contents?
      if (total > 0) {
        // now run the query
        results = dao.doQuery();

        // now, if we don't have any results, we are at the end of the browse.  This will
        // be because a starts_with value has been supplied for which we don't have
        // any items.
        if (results.size() == 0) {
          // In this case, we will calculate a new offset for the last page of results
          offset = total - scope.getResultsPerPage();
          if (offset < 0) {
            offset = 0;
          }

          // And rerun the query
          dao.setOffset(offset);
          results = dao.doQuery();
        }
      } else {
        // No records, so make an empty list
        results = new ArrayList<BrowseItem>();
      }

      // construct the BrowseInfo object to pass back
      //            BrowseInfo browseInfo = new BrowseInfo(results, position, total, offset);
      BrowseInfo browseInfo = new BrowseInfo(results, offset, total, offset);

      if (offset + scope.getResultsPerPage() < total) {
        browseInfo.setNextOffset(offset + scope.getResultsPerPage());
      }

      if (offset - scope.getResultsPerPage() > -1) {
        browseInfo.setPrevOffset(offset - scope.getResultsPerPage());
      }

      // add the browse index to the Browse Info
      browseInfo.setBrowseIndex(browseIndex);

      // set the sort option for the Browse Info
      browseInfo.setSortOption(scope.getSortOption());

      // tell the Browse Info which way we are sorting
      browseInfo.setAscending(scope.isAscending());

      // tell the Browse Info which level of browse we are at
      browseInfo.setBrowseLevel(scope.getBrowseLevel());

      // set the browse value if there is one
      browseInfo.setValue(rawValue);

      // set the browse authority key if there is one
      browseInfo.setAuthority(scope.getAuthorityValue());

      // set the focus value if there is one
      browseInfo.setFocus(rawFocusValue);

      if (scope.hasJumpToItem()) {
        browseInfo.setFocusItem(scope.getJumpToItem());
      }

      // tell the browse info if it is working from a starts with parameter
      browseInfo.setStartsWith(scope.hasStartsWith());

      // tell the browse info what the container for the browse was
      if (scope.inCollection() || scope.inCommunity()) {
        browseInfo.setBrowseContainer(scope.getBrowseContainer());
      }

      browseInfo.setResultsPerPage(scope.getResultsPerPage());

      browseInfo.setEtAl(scope.getEtAl());

      return browseInfo;
    } catch (SQLException e) {
      log.error("caught exception: ", e);
      throw new BrowseException(e);
    }
  }
Esempio n. 5
0
  /**
   * Get the value (for single value browses) for the result that appears at the top of the previous
   * page, for when the User Interface is performing result set paging. The callback argument allows
   * for this method to populate the List with the results obtained from the query, which can be
   * useful when, for example, reaching the final browse page and needing additional results to pad
   * up to the number of results per page
   *
   * @param callback A List object for holding String objects indexed numerically in the correct
   *     order
   * @return the value of the top of the previous page
   * @throws SQLException
   * @throws BrowseException
   */
  private String getPreviousPageValue(List callback) throws SQLException, BrowseException {
    // do we want to capture the results?
    boolean capture = false;
    if (callback != null) {
      capture = true;
    }

    log.debug(
        LogManager.getHeader(context, "get_previous_page_value", "capture_results=" + capture));

    // the only thing we need to do is reverse the direction
    // of the query, and set it to not use the "=" part of the
    // comparator (i.e. < and > not <= and >=).
    boolean isAscending = dao.isAscending();
    dao.setAscending(!isAscending);

    boolean useEquals = dao.useEqualsComparator();
    dao.setEqualsComparator(false);

    // store in local scope the things that we are going to change
    // during this method
    int resultLimit = dao.getLimit();

    // if the database supports it (postgres does), we use limit
    // and offset to minimise the work it has to do.

    // the limit will be the size of a page, or double the size of the
    // page if we are capturing the result set (because the first page's worth
    // will be the results, so the previous link will need to come from the
    // page *before* that)
    int limit = scope.getResultsPerPage();
    if (capture) {
      limit *= 2;
    }
    dao.setLimit(limit);

    // now we have a query which is exactly the opposite of the
    // original query.  So lets execute it:
    List results = dao.doValueQuery();

    // before we continue, put back the variables we messed with
    dao.setAscending(isAscending);
    dao.setEqualsComparator(useEquals);
    dao.setLimit(resultLimit);

    Iterator itr = results.iterator();

    // work our way through the list, capturing if necessary, and finally
    // having the last result, which will be the top of the previous page
    int i = 0;
    String prev = null;
    while (itr.hasNext()) {
      String value = (String) itr.next();

      // we need to copy this, because of the scoping vs by-reference issue
      prev = value;

      // if we need to capture the results in the call back, do it here.
      // Note that since the results will come in backwards, we place
      // each one at the start of the array so that it displaces the others
      // in the right direction.  By the end, they should be sorted correctly
      // we use the index i to be sure that we only grab one page's worth
      // of results (see note above about limit)
      if (capture && i < scope.getResultsPerPage()) {
        callback.add(0, value);
        i++;
      }
    }

    log.debug(LogManager.getHeader(context, "get_previous_page_value_return", "return=" + prev));

    return prev;
  }