Ejemplo n.º 1
0
  @Test
  public void createNewSortObject() {

    String valueExpression = sort.getByValueExpression();
    SortBy.Order sortOrder = sort.getSortOrder();

    assertThat(valueExpression, is(byValueExpression));
    assertThat(sortOrder, is(bySortOrder));
  }
Ejemplo n.º 2
0
 @Override
 public List<Entry<T, Double>> getMostSimilarItems(
     T item, Collection<T> items, Collection<Property> properties, double treshold) {
   List<T> itemSet = new ArrayList<>(items);
   //	itemSet.remove(item);
   double similarity;
   Map<T, Double> map = new HashMap<T, Double>();
   for (T it : itemSet) {
     similarity = calculateSimiliraty(item, it, properties);
     if (similarity >= treshold) map.put(it, similarity);
   }
   return SortBy.sortByValue(map);
 }
Ejemplo n.º 3
0
  /** Parse the query string. */
  public ZimbraQuery(OperationContext octxt, SoapProtocol proto, Mailbox mbox, SearchParams params)
      throws ServiceException {
    this.octxt = octxt;
    this.protocol = proto;
    this.params = params;
    this.mailbox = mbox;

    // Parse the text using the JavaCC parser.
    try {
      QueryParser parser = new QueryParser(mbox, mbox.index.getAnalyzer());
      parser.setDefaultField(params.getDefaultField());
      parser.setTypes(params.getTypes());
      parser.setTimeZone(params.getTimeZone());
      parser.setLocale(params.getLocale());
      parser.setQuick(params.isQuick());
      clauses = parser.parse(params.getQueryString());

      if (parser.getSortBy() != null) {
        SortBy sort = SortBy.of(parser.getSortBy());
        if (sort == null) {
          throw ServiceException.PARSE_ERROR("INVALID_SORTBY: " + sort, null);
        }
        params.setSortBy(sort);
      }
    } catch (Error e) {
      throw ServiceException.PARSE_ERROR("PARSER_ERROR", e);
    }

    ZimbraLog.search.debug("%s,types=%s,sort=%s", this, params.getTypes(), params.getSortBy());

    // Build a parse tree and push all the "NOT's" down to the bottom level.
    // This is because we cannot invert result sets.
    parseTree = ParseTree.build(clauses).simplify();
    parseTree.pushNotsDown();

    // Check sort compatibility.
    switch (params.getSortBy().getKey()) {
      case RCPT:
      case ATTACHMENT:
      case FLAG:
      case PRIORITY:
        // We don't store these in Lucene.
        if (hasTextOperation()) {
          throw ServiceException.INVALID_REQUEST(
              "Sort '" + params.getSortBy().name() + "' can't be used with text query.", null);
        }
        break;
      default:
        break;
    }

    SearchParams.Cursor cursor = params.getCursor();
    if (cursor != null) {
      // Check cursor compatibility
      if (params.getCursor().isIncludeOffset() && hasTextOperation()) {
        throw ServiceException.INVALID_REQUEST(
            "cursor.includeOffset can't be used with text query.", null);
      }
      // Supplement sortValue
      if (cursor.getSortValue() == null) {
        ZimbraLog.search.debug(
            "Supplementing sortValue sort=%s,id=%s", params.getSortBy(), cursor.getItemId());
        try {
          MailItem item =
              mailbox.getItemById(null, cursor.getItemId().getId(), MailItem.Type.UNKNOWN);
          switch (params.getSortBy().getKey()) {
            case NAME:
              cursor.setSortValue(item.getName());
              break;
            case RCPT:
              cursor.setSortValue(item.getSortRecipients());
              break;
            case SENDER:
              cursor.setSortValue(item.getSortSender());
              break;
            case SIZE:
              cursor.setSortValue(String.valueOf(item.getSize()));
              break;
            case SUBJECT:
              cursor.setSortValue(item.getSortSubject());
              break;
            case DATE:
            default:
              cursor.setSortValue(String.valueOf(item.getDate()));
              break;
          }
        } catch (NoSuchItemException e) {
          params.setCursor(null); // clear cursor
        }
      }
    }
  }
Ejemplo n.º 4
0
 /**
  * Specifies the sorting strategy of the results
  *
  * @param sortBy - {@link com.indix.query.ApiParameters.SortBy}
  */
 public SearchQuery withSortBy(SortBy sortBy) {
   parameters.add(new BasicNameValuePair("sortBy", sortBy.name()));
   return this;
 }
  private void bufferAllHits() throws ServiceException {
    assert (mHitBuffer == null);
    mHitBuffer = new ArrayList<ZimbraHit>();

    // get the proper comparator
    Comparator<ZimbraHit> comp;
    switch (sort) {
      default:
      case TASK_DUE_ASC:
        comp =
            new Comparator<ZimbraHit>() {
              @Override
              public int compare(ZimbraHit lhs, ZimbraHit rhs) {
                return TaskHit.compareByDueDate(true, lhs, rhs);
              }
            };
        break;
      case TASK_DUE_DESC:
        comp =
            new Comparator<ZimbraHit>() {
              @Override
              public int compare(ZimbraHit lhs, ZimbraHit rhs) {
                return TaskHit.compareByDueDate(false, lhs, rhs);
              }
            };
        break;
      case TASK_STATUS_ASC:
        comp =
            new Comparator<ZimbraHit>() {
              @Override
              public int compare(ZimbraHit lhs, ZimbraHit rhs) {
                return TaskHit.compareByStatus(true, lhs, rhs);
              }
            };
        break;
      case TASK_STATUS_DESC:
        comp =
            new Comparator<ZimbraHit>() {
              @Override
              public int compare(ZimbraHit lhs, ZimbraHit rhs) {
                return TaskHit.compareByStatus(false, lhs, rhs);
              }
            };
        break;
      case TASK_PERCENT_COMPLETE_ASC:
        comp =
            new Comparator<ZimbraHit>() {
              @Override
              public int compare(ZimbraHit lhs, ZimbraHit rhs) {
                return TaskHit.compareByCompletionPercent(true, lhs, rhs);
              }
            };
        break;
      case TASK_PERCENT_COMPLETE_DESC:
        comp =
            new Comparator<ZimbraHit>() {
              @Override
              public int compare(ZimbraHit lhs, ZimbraHit rhs) {
                return TaskHit.compareByCompletionPercent(false, lhs, rhs);
              }
            };
        break;
      case NAME_LOCALIZED_ASC:
      case NAME_LOCALIZED_DESC:
        comp = sort.getHitComparator(params.getLocale());
        break;
    }

    int maxIfPresorted = MAX_BUFFERED_HITS;
    if (params != null && params.getCursor() == null) {
      maxIfPresorted = params.getLimit();
      if (maxIfPresorted > 0) {
        // 1 is added so that the 'more' setting will be correct.
        maxIfPresorted = maxIfPresorted + 1 + params.getOffset();
      }
    }
    ZimbraHit cur;
    while ((cur = results.getNext()) != null) {

      if (isTaskSort()) {
        if (!(cur instanceof TaskHit) && !(cur instanceof ProxiedHit)) {
          throw ServiceException.FAILURE("Invalid hit type, can only task-sort Tasks", null);
        }
      }

      boolean skipHit = false;

      boolean handleCursorFilteringForFirstHit = true;
      if (DebugConfig.enableContactLocalizedSort) {
        switch (sort) {
          case NAME_LOCALIZED_ASC:
          case NAME_LOCALIZED_DESC:
            handleCursorFilteringForFirstHit = false;
            break;
        }
      }

      // handle cursor filtering
      if (params != null && params.getCursor() != null) {
        ZimbraHit firstHit = null;
        if (params.getCursor().getSortValue() != null) {
          firstHit =
              new ResultsPager.CursorHit(
                  results,
                  params.getCursor().getSortValue(),
                  params.getCursor().getItemId().getId());
        }
        ZimbraHit endHit = null;
        if (params.getCursor().getEndSortValue() != null) {
          endHit = new ResultsPager.CursorHit(results, params.getCursor().getEndSortValue(), 0);
        }
        // fail if cur < first OR cur >= end
        if (handleCursorFilteringForFirstHit) {
          if (firstHit != null && comp.compare(cur, firstHit) < 0) {
            skipHit = true;
          }
        }
        if (endHit != null && comp.compare(cur, endHit) >= 0) {
          skipHit = true;
        }
      }

      if (!skipHit) {
        mHitBuffer.add(cur);
      }
      if (mHitBuffer.size() >= MAX_BUFFERED_HITS) {
        break;
      }
      // If it turns out that the results were sorted remotely, we can bail out early.
      if (results.isPreSorted() && mHitBuffer.size() >= maxIfPresorted) {
        break;
      }
    }

    if (!results.isPreSorted()) {
      Collections.sort(mHitBuffer, comp);
    }
  }