Example usage for com.liferay.portal.kernel.search BooleanQuery add

List of usage examples for com.liferay.portal.kernel.search BooleanQuery add

  1. HOME
  2. Java
  3. com.liferay.portal
  4. com.liferay.portal.kernel.search.*
  5. BooleanQuery
  6. add

Introduction

In this page you can find the example usage for com.liferay.portal.kernel.search BooleanQuery add.

Prototype

public Query add(Query query, String occur) throws ParseException;

Source Link

Usage

From source file:com.ext.portlet.Activity.ActivityUtil.java

License:Open Source License

private static Hits getAggregatedActivitySearchResults(long userId, int start, int end) throws SearchException {
    SearchContext context = new SearchContext();
    context.setCompanyId(DEFAULT_COMPANY_ID);
    BooleanQuery query = BooleanQueryFactoryUtil.create(context);
    query.addRequiredTerm(Field.ENTRY_CLASS_NAME, SocialActivity.class.getName());

    BooleanQuery subQuery = BooleanQueryFactoryUtil.create(context);
    subQuery.addExactTerm("userId", userId);

    try {//  ww w  .  j  ava  2s  .  com
        query.add(subQuery, BooleanClauseOccur.MUST);
    } catch (ParseException e) {
        _log.error(e);
    }

    Sort sort = SortFactoryUtil.create("createDate", Sort.FLOAT_TYPE, true);
    return SearchEngineUtil.search(SearchEngineUtil.getDefaultSearchEngineId(), context.getCompanyId(), query,
            sort, start, end);
}

From source file:com.ext.portlet.Activity.ActivityUtil.java

License:Open Source License

private static Hits getAggregatedActivitySearchResultsExcludingUsers(List<Long> excludedUserIds, int start,
        int end) throws SearchException {
    SearchContext context = new SearchContext();
    context.setCompanyId(DEFAULT_COMPANY_ID);
    BooleanQuery query = BooleanQueryFactoryUtil.create(context);
    query.addRequiredTerm(Field.ENTRY_CLASS_NAME, SocialActivity.class.getName());

    BooleanQuery excludeQuery = BooleanQueryFactoryUtil.create(context);
    for (Long excludedUserId : excludedUserIds) {
        excludeQuery.addExactTerm("userId", excludedUserId);
    }//  w w w. jav a  2s . c o m

    try {
        query.add(excludeQuery, BooleanClauseOccurImpl.MUST_NOT);
    } catch (ParseException e) {
        _log.error(e);
    }

    Sort sort = SortFactoryUtil.create("createDate", Sort.FLOAT_TYPE, true);
    return SearchEngineUtil.search(SearchEngineUtil.getDefaultSearchEngineId(), context.getCompanyId(), query,
            sort, start, end);
}

From source file:com.library.slayer.service.impl.LMSBookLocalServiceImpl.java

License:Open Source License

/**
 * @param fieldName/*from   w w w.  j a v  a2s  . co  m*/
 * @param value
 * @param searchContext
 * @param fullQuery
 * @return
 */
private BooleanQuery createQuery(String fieldName, String value, SearchContext searchContext,
        BooleanQuery fullQuery) {
    BooleanQuery searchQuery = BooleanQueryFactoryUtil.create(searchContext);
    String[] splitValue = value.split(",");
    for (String splitVal : splitValue) {
        try {
            searchQuery.addTerm(fieldName, splitVal.replace(" ", ","));
        } catch (ParseException e) {

        }
    }
    try {
        fullQuery.add(searchQuery, BooleanClauseOccur.MUST);
    } catch (ParseException e) {

    }
    return fullQuery;
}

From source file:com.library.slayer.service.impl.LMSBookLocalServiceImpl.java

License:Open Source License

public List<LMSBook> advanceSearchAll(long companyId, long groupId, String title, String author, String desc,
        String type) {/* w  ww .j ava 2s.c  o  m*/

    SearchContext searchContext = new SearchContext();
    searchContext.setCompanyId(companyId);
    searchContext.setEntryClassNames(CLASS_NAMES);

    BooleanQuery contextQuery = BooleanQueryFactoryUtil.create(searchContext);
    contextQuery.addRequiredTerm(Field.COMPANY_ID, companyId);
    contextQuery.addRequiredTerm(Field.PORTLET_ID,
            Long.toString(ClassNameLocalServiceUtil.getClassNameId(LMSBook.class)));

    BooleanQuery fullQuery = BooleanQueryFactoryUtil.create(searchContext);
    fullQuery.setQueryConfig(searchContext.getQueryConfig());
    try {
        fullQuery.add(contextQuery, BooleanClauseOccur.MUST);
    } catch (ParseException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }

    BooleanQuery searchQuery = BooleanQueryFactoryUtil.create(searchContext);
    Hits hits = null;

    if (Validator.isNotNull(title)) {
        Sort sort = new Sort(Field.TITLE, true);
        searchContext.setSorts(new Sort[] { sort });

        fullQuery = createQuery(Field.TITLE, title, searchContext, fullQuery);

    }
    if (Validator.isNotNull(author)) {
        fullQuery = createQuery(Field.NAME, author, searchContext, fullQuery);
    }
    if (Validator.isNotNull(desc)) {
        fullQuery = createQuery(Field.DESCRIPTION, desc, searchContext, fullQuery);
    }

    if (searchQuery.clauses().size() > 0) {
        try {
            fullQuery.add(searchQuery, BooleanClauseOccur.MUST);
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    try {
        hits = SearchEngineUtil.search(searchContext, fullQuery);
    } catch (SearchException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    List<LMSBook> books = new ArrayList<LMSBook>();

    if (hits != null && hits.getLength() > 0) {
        for (Document document : hits.getDocs()) {

            long bookId = Long.parseLong(document.get(Field.ENTRY_CLASS_PK));
            try {
                LMSBook book = LMSBookLocalServiceUtil.getLMSBook(bookId);
                books.add(book);
            } catch (PortalException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } catch (SystemException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    return books;
}

From source file:com.liferay.asset.categories.internal.search.AssetCategoryIndexer.java

License:Open Source License

@Override
public void postProcessSearchQuery(BooleanQuery searchQuery, BooleanFilter fullQueryBooleanFilter,
        SearchContext searchContext) throws Exception {

    String title = (String) searchContext.getAttribute(Field.TITLE);

    if (Validator.isNotNull(title)) {
        BooleanQuery localizedQuery = new BooleanQueryImpl();

        searchContext.setAttribute(Field.ASSET_CATEGORY_TITLE, title);

        addSearchLocalizedTerm(localizedQuery, searchContext, Field.ASSET_CATEGORY_TITLE, true);
        addSearchLocalizedTerm(localizedQuery, searchContext, Field.TITLE, true);

        searchQuery.add(localizedQuery, BooleanClauseOccur.SHOULD);
    }//w w w. ja v  a2s  . c  o m
}

From source file:com.liferay.asset.categories.internal.search.AssetVocabularyIndexer.java

License:Open Source License

@Override
public void postProcessSearchQuery(BooleanQuery searchQuery, BooleanFilter fullQueryBooleanFilter,
        SearchContext searchContext) throws Exception {

    String title = (String) searchContext.getAttribute(Field.TITLE);

    if (Validator.isNotNull(title)) {
        BooleanQuery localizedQuery = new BooleanQueryImpl();

        addSearchLocalizedTerm(localizedQuery, searchContext, Field.TITLE, true);

        searchQuery.add(localizedQuery, BooleanClauseOccur.SHOULD);
    }//from  ww w  .  j  a  v  a2s .com
}

From source file:com.liferay.asset.tags.internal.search.AssetTagIndexer.java

License:Open Source License

@Override
public void postProcessSearchQuery(BooleanQuery searchQuery, BooleanFilter fullQueryBooleanFilter,
        SearchContext searchContext) throws Exception {

    String name = (String) searchContext.getAttribute(Field.NAME);

    if (Validator.isNotNull(name)) {
        BooleanQuery nameQuery = new BooleanQueryImpl();

        addSearchTerm(nameQuery, searchContext, Field.NAME, true);

        searchQuery.add(nameQuery, BooleanClauseOccur.SHOULD);
    }/*  w  ww.  j  a va 2  s.  c  o  m*/
}

From source file:com.liferay.configuration.admin.web.internal.search.ConfigurationModelIndexer.java

License:Open Source License

@Override
protected BooleanQuery createFullQuery(BooleanFilter fullQueryBooleanFilter, SearchContext searchContext)
        throws Exception {

    BooleanQuery searchQuery = new BooleanQueryImpl();

    addSearchLocalizedTerm(searchQuery, searchContext, Field.DESCRIPTION, false);
    addSearchLocalizedTerm(searchQuery, searchContext, Field.TITLE, false);
    addSearchTerm(searchQuery, searchContext, FieldNames.CONFIGURATION_MODEL_ATTRIBUTE_DESCRIPTION, false);
    addSearchTerm(searchQuery, searchContext, FieldNames.CONFIGURATION_MODEL_ATTRIBUTE_NAME, false);
    addSearchTerm(searchQuery, searchContext, FieldNames.CONFIGURATION_MODEL_FACTORY_PID, false);
    addSearchTerm(searchQuery, searchContext, FieldNames.CONFIGURATION_MODEL_ID, false);

    BooleanQuery fullBooleanQuery = new BooleanQueryImpl();

    if (fullQueryBooleanFilter.hasClauses()) {
        fullBooleanQuery.setPreBooleanFilter(fullQueryBooleanFilter);
    }//from   w ww  . ja  va  2  s.  c  o m

    fullBooleanQuery.add(searchQuery, BooleanClauseOccur.MUST);

    return fullBooleanQuery;
}

From source file:com.liferay.document.library.repository.search.internal.LuceneRepositorySearchQueryTermBuilder.java

License:Open Source License

protected void translateQuery(BooleanQuery booleanQuery, SearchContext searchContext,
        org.apache.lucene.search.Query query, org.apache.lucene.search.BooleanClause.Occur occur)
        throws Exception {

    BooleanClauseOccur booleanClauseOccur = getBooleanClauseOccur(occur);

    if (query instanceof org.apache.lucene.search.TermQuery) {
        org.apache.lucene.search.TermQuery luceneTermQuery = (org.apache.lucene.search.TermQuery) query;

        Term term = luceneTermQuery.getTerm();

        String termValue = term.text();

        TermQuery termQuery = new TermQueryImpl(term.field(), termValue);

        booleanQuery.add(termQuery, getBooleanClauseOccur(occur));
    } else if (query instanceof org.apache.lucene.search.BooleanQuery) {
        org.apache.lucene.search.BooleanQuery curBooleanQuery = (org.apache.lucene.search.BooleanQuery) query;

        BooleanQuery conjunctionQuery = new BooleanQueryImpl();

        BooleanQuery disjunctionQuery = new BooleanQueryImpl();

        for (org.apache.lucene.search.BooleanClause booleanClause : curBooleanQuery.getClauses()) {

            BooleanClauseOccur curBooleanClauseOccur = getBooleanClauseOccur(booleanClause.getOccur());

            BooleanQuery subbooleanQuery = null;

            if (curBooleanClauseOccur.equals(BooleanClauseOccur.SHOULD)) {
                subbooleanQuery = disjunctionQuery;
            } else {
                subbooleanQuery = conjunctionQuery;
            }/*from w  w  w.j  a va2  s  .  c  o m*/

            translateQuery(subbooleanQuery, searchContext, booleanClause.getQuery(), booleanClause.getOccur());
        }

        if (conjunctionQuery.hasClauses()) {
            booleanQuery.add(conjunctionQuery, BooleanClauseOccur.MUST);
        }

        if (disjunctionQuery.hasClauses()) {
            booleanQuery.add(disjunctionQuery, BooleanClauseOccur.SHOULD);
        }
    } else if (query instanceof org.apache.lucene.search.FuzzyQuery) {
        org.apache.lucene.search.FuzzyQuery fuzzyQuery = (org.apache.lucene.search.FuzzyQuery) query;

        Term term = fuzzyQuery.getTerm();

        String termValue = term.text().concat(StringPool.STAR);

        WildcardQuery wildcardQuery = new WildcardQueryImpl(term.field(), termValue);

        booleanQuery.add(wildcardQuery, booleanClauseOccur);
    } else if (query instanceof org.apache.lucene.search.PhraseQuery) {
        org.apache.lucene.search.PhraseQuery phraseQuery = (org.apache.lucene.search.PhraseQuery) query;

        Term[] terms = phraseQuery.getTerms();

        StringBundler sb = new StringBundler(terms.length * 2);

        for (Term term : terms) {
            sb.append(term.text());
            sb.append(StringPool.SPACE);
        }

        TermQuery termQuery = new TermQueryImpl(terms[0].field(), sb.toString().trim());

        booleanQuery.add(termQuery, booleanClauseOccur);
    } else if (query instanceof org.apache.lucene.search.PrefixQuery) {
        org.apache.lucene.search.PrefixQuery prefixQuery = (org.apache.lucene.search.PrefixQuery) query;

        Term prefixTerm = prefixQuery.getPrefix();

        String termValue = prefixTerm.text().concat(StringPool.STAR);

        WildcardQuery wildcardQuery = new WildcardQueryImpl(prefixTerm.field(), termValue);

        booleanQuery.add(wildcardQuery, booleanClauseOccur);
    } else if (query instanceof org.apache.lucene.search.TermRangeQuery) {
        org.apache.lucene.search.TermRangeQuery termRangeQuery = (org.apache.lucene.search.TermRangeQuery) query;

        booleanQuery.addRangeTerm(termRangeQuery.getField(), termRangeQuery.getLowerTerm().utf8ToString(),
                termRangeQuery.getUpperTerm().utf8ToString());
    } else if (query instanceof org.apache.lucene.search.WildcardQuery) {
        org.apache.lucene.search.WildcardQuery luceneWildcardQuery = (org.apache.lucene.search.WildcardQuery) query;

        Term wildcardTerm = luceneWildcardQuery.getTerm();

        WildcardQuery wildcardQuery = new WildcardQueryImpl(wildcardTerm.field(), wildcardTerm.text());

        booleanQuery.add(wildcardQuery, booleanClauseOccur);
    } else {
        if (_log.isWarnEnabled()) {
            _log.warn("Ignoring unknown query type " + query.getClass() + " with query " + query);
        }
    }
}

From source file:com.liferay.document.library.repository.search.internal.RepositorySearchQueryBuilderImpl.java

License:Open Source License

@Override
public BooleanQuery getFullQuery(SearchContext searchContext) throws SearchException {

    try {//from   w ww .  ja v  a2 s.com
        BooleanQuery contextQuery = new BooleanQueryImpl();

        addContext(contextQuery, searchContext);

        BooleanQuery searchQuery = new BooleanQueryImpl();

        addSearchKeywords(searchQuery, searchContext);

        BooleanQuery fullQuery = new BooleanQueryImpl();

        if (contextQuery.hasClauses()) {
            fullQuery.add(contextQuery, BooleanClauseOccur.MUST);
        }

        if (searchQuery.hasClauses()) {
            fullQuery.add(searchQuery, BooleanClauseOccur.MUST);
        }

        BooleanClause<Query>[] booleanClauses = searchContext.getBooleanClauses();

        if (booleanClauses != null) {
            for (BooleanClause<Query> booleanClause : booleanClauses) {
                fullQuery.add(booleanClause.getClause(), booleanClause.getBooleanClauseOccur());
            }
        }

        fullQuery.setQueryConfig(searchContext.getQueryConfig());

        return fullQuery;
    } catch (Exception e) {
        throw new SearchException(e);
    }
}