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

Introduction

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

Prototype

public List<BooleanClause<Query>> clauses();

Source Link

Usage

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) {//from  www .j av  a2s. 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.document.library.repository.cmis.search.BaseCmisSearchQueryBuilder.java

License:Open Source License

protected void traverseContentQuery(CMISJunction cmisJunction, Query query, QueryConfig queryConfig)
        throws SearchException {

    if (query instanceof BooleanQuery) {
        BooleanQuery booleanQuery = (BooleanQuery) query;

        List<BooleanClause<Query>> booleanClauses = booleanQuery.clauses();

        CMISFullTextConjunction anyCMISConjunction = new CMISFullTextConjunction();
        CMISDisjunction cmisDisjunction = new CMISDisjunction();
        CMISFullTextConjunction notCMISConjunction = new CMISFullTextConjunction();

        for (BooleanClause<Query> booleanClause : booleanClauses) {
            CMISJunction currentCMISJunction = cmisDisjunction;

            BooleanClauseOccur booleanClauseOccur = booleanClause.getBooleanClauseOccur();

            if (booleanClauseOccur.equals(BooleanClauseOccur.MUST)) {
                currentCMISJunction = anyCMISConjunction;
            } else if (booleanClauseOccur.equals(BooleanClauseOccur.MUST_NOT)) {

                currentCMISJunction = notCMISConjunction;
            }//  w w  w .j a  v  a 2s  . c om

            Query booleanClauseQuery = booleanClause.getClause();

            traverseContentQuery(currentCMISJunction, booleanClauseQuery, queryConfig);
        }

        if (!anyCMISConjunction.isEmpty()) {
            cmisJunction.add(anyCMISConjunction);
        }

        if (!cmisDisjunction.isEmpty()) {
            cmisJunction.add(cmisDisjunction);
        }

        if (!notCMISConjunction.isEmpty()) {
            CMISContainsNotExpression cmisContainsNotExpression = new CMISContainsNotExpression(
                    notCMISConjunction);

            cmisJunction.add(cmisContainsNotExpression);
        }
    } else if (query instanceof TermQuery) {
        TermQuery termQuery = (TermQuery) query;

        QueryTerm queryTerm = termQuery.getQueryTerm();

        if (!_isContentFieldQueryTerm(queryTerm)) {
            return;
        }

        String field = queryTerm.getField();
        String value = queryTerm.getValue();

        value = CMISParameterValueUtil.formatParameterValue(field, value, false, queryConfig);

        CMISContainsValueExpression cmisContainsValueExpression = new CMISContainsValueExpression(value);

        cmisJunction.add(cmisContainsValueExpression);
    } else if (query instanceof WildcardQuery) {
        WildcardQuery wildcardQuery = (WildcardQuery) query;

        QueryTerm queryTerm = wildcardQuery.getQueryTerm();

        if (!_isContentFieldQueryTerm(queryTerm)) {
            return;
        }

        String value = queryTerm.getValue();

        String[] terms = value.split(_STAR_PATTERN);

        CMISConjunction cmisConjunction = new CMISConjunction();

        for (String term : terms) {
            if (Validator.isNotNull(term)) {
                CMISContainsValueExpression containsValueExpression = new CMISContainsValueExpression(term);

                cmisConjunction.add(containsValueExpression);
            }
        }

        cmisJunction.add(cmisConjunction);
    } else if (query instanceof TermRangeQuery) {
        return;
    }
}

---

From source file:com.liferay.document.library.repository.cmis.search.BaseCmisSearchQueryBuilder.java

License:Open Source License

protected void traversePropertiesQuery(CMISJunction cmisJunction, Query query, QueryConfig queryConfig)
        throws SearchException {

    if (query instanceof BooleanQuery) {
        BooleanQuery booleanQuery = (BooleanQuery) query;

        List<BooleanClause<Query>> booleanClauses = booleanQuery.clauses();

        CMISConjunction anyCMISConjunction = new CMISConjunction();
        CMISDisjunction cmisDisjunction = new CMISDisjunction();
        CMISConjunction notCMISConjunction = new CMISConjunction();

        for (BooleanClause<Query> booleanClause : booleanClauses) {
            CMISJunction currentCMISJunction = cmisDisjunction;

            BooleanClauseOccur booleanClauseOccur = booleanClause.getBooleanClauseOccur();

            if (booleanClauseOccur.equals(BooleanClauseOccur.MUST)) {
                currentCMISJunction = anyCMISConjunction;
            } else if (booleanClauseOccur.equals(BooleanClauseOccur.MUST_NOT)) {

                currentCMISJunction = notCMISConjunction;
            }//from   w w  w  . ja  v  a2  s . com

            Query booleanClauseQuery = booleanClause.getClause();

            traversePropertiesQuery(currentCMISJunction, booleanClauseQuery, queryConfig);
        }

        if (!anyCMISConjunction.isEmpty()) {
            cmisJunction.add(anyCMISConjunction);
        }

        if (!cmisDisjunction.isEmpty()) {
            cmisJunction.add(cmisDisjunction);
        }

        if (!notCMISConjunction.isEmpty()) {
            cmisJunction.add(new CMISNotExpression(notCMISConjunction));
        }
    } else if (query instanceof MatchQuery) {
        MatchQuery matchQuery = (MatchQuery) query;

        if (!isSupportedField(matchQuery.getField())) {
            return;
        }

        CMISCriterion cmisCriterion = buildFieldExpression(matchQuery.getField(), matchQuery.getValue(),
                CMISSimpleExpressionOperator.EQ, queryConfig);

        if (cmisCriterion != null) {
            cmisJunction.add(cmisCriterion);
        }
    } else if (query instanceof TermQuery) {
        TermQuery termQuery = (TermQuery) query;

        QueryTerm queryTerm = termQuery.getQueryTerm();

        if (!isSupportedField(queryTerm.getField())) {
            return;
        }

        CMISCriterion cmisCriterion = buildFieldExpression(queryTerm.getField(), queryTerm.getValue(),
                CMISSimpleExpressionOperator.EQ, queryConfig);

        if (cmisCriterion != null) {
            cmisJunction.add(cmisCriterion);
        }
    } else if (query instanceof TermRangeQuery) {
        TermRangeQuery termRangeQuery = (TermRangeQuery) query;

        if (!isSupportedField(termRangeQuery.getField())) {
            return;
        }

        String fieldName = termRangeQuery.getField();

        String cmisField = getCmisField(fieldName);
        String cmisLowerTerm = CMISParameterValueUtil.formatParameterValue(fieldName,
                termRangeQuery.getLowerTerm(), false, queryConfig);
        String cmisUpperTerm = CMISParameterValueUtil.formatParameterValue(fieldName,
                termRangeQuery.getUpperTerm(), false, queryConfig);

        CMISCriterion cmisCriterion = new CMISBetweenExpression(cmisField, cmisLowerTerm, cmisUpperTerm,
                termRangeQuery.includesLower(), termRangeQuery.includesUpper());

        cmisJunction.add(cmisCriterion);
    } else if (query instanceof WildcardQuery) {
        WildcardQuery wildcardQuery = (WildcardQuery) query;

        QueryTerm queryTerm = wildcardQuery.getQueryTerm();

        if (!isSupportedField(queryTerm.getField())) {
            return;
        }

        CMISCriterion cmisCriterion = buildFieldExpression(queryTerm.getField(), queryTerm.getValue(),
                CMISSimpleExpressionOperator.LIKE, queryConfig);

        if (cmisCriterion != null) {
            cmisJunction.add(cmisCriterion);
        }
    }
}

---

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

License:Open Source License

protected boolean contains(Query query1, Query query2) {
    if (query1 instanceof BooleanQuery) {
        BooleanQuery booleanQuery = (BooleanQuery) query1;

        for (BooleanClause<Query> booleanClause : booleanQuery.clauses()) {
            if (contains(booleanClause.getClause(), query2)) {
                return true;
            }//  w  w w.j a  va2 s  .  c  om
        }

        return false;
    } else if (query2 instanceof BooleanQuery) {
        BooleanQuery booleanQuery = (BooleanQuery) query2;

        for (BooleanClause<Query> booleanClause : booleanQuery.clauses()) {
            if (contains(query1, booleanClause.getClause())) {
                return true;
            }
        }

        return false;
    } else if ((query1 instanceof TermQuery) && (query2 instanceof TermQuery)) {

        TermQuery termQuery1 = (TermQuery) query1;

        QueryTerm queryTerm1 = termQuery1.getQueryTerm();

        String field1 = queryTerm1.getField();
        String value1 = queryTerm1.getValue();

        TermQuery termQuery2 = (TermQuery) query2;

        QueryTerm queryTerm2 = termQuery2.getQueryTerm();

        String field2 = queryTerm2.getField();
        String value2 = queryTerm2.getValue();

        if (field1.equals(field2) && value1.equals(value2)) {
            return true;
        }
    } else if ((query1 instanceof TermRangeQuery) && (query2 instanceof TermRangeQuery)) {

        TermRangeQuery termRangeQuery1 = (TermRangeQuery) query1;

        boolean includesLower1 = termRangeQuery1.includesLower();
        boolean includesUpper1 = termRangeQuery1.includesUpper();
        String lowerTerm1 = termRangeQuery1.getLowerTerm();
        String upperTerm1 = termRangeQuery1.getUpperTerm();

        TermRangeQuery termRangeQuery2 = (TermRangeQuery) query2;

        boolean includesLower2 = termRangeQuery2.includesLower();
        boolean includesUpper2 = termRangeQuery2.includesUpper();
        String lowerTerm2 = termRangeQuery2.getLowerTerm();
        String upperTerm2 = termRangeQuery2.getUpperTerm();

        if ((includesLower1 == includesLower2) && (includesUpper1 == includesUpper2)
                && lowerTerm1.equals(lowerTerm2) && upperTerm1.equals(upperTerm2)) {

            return true;
        }
    } else if ((query1 instanceof WildcardQuery) && (query2 instanceof WildcardQuery)) {

        WildcardQuery wildcardQuery1 = (WildcardQuery) query1;

        QueryTerm queryTerm1 = wildcardQuery1.getQueryTerm();

        String field1 = queryTerm1.getField();
        String value1 = queryTerm1.getValue();

        WildcardQuery wildcardQuery2 = (WildcardQuery) query2;

        QueryTerm queryTerm2 = wildcardQuery2.getQueryTerm();

        String field2 = queryTerm2.getField();
        String value2 = queryTerm2.getValue();

        if (field1.equals(field2) && value1.equals(value2)) {
            return true;
        }
    }

    return false;
}

---

From source file:com.liferay.portlet.documentlibrary.store.DLStoreImpl.java

License:Open Source License

public Hits search(long companyId, long userId, String portletId, long groupId, long[] repositoryIds,
        String keywords, int start, int end) throws SystemException {

    try {/*from  www .  j  a v  a2  s  .co  m*/
        SearchContext searchContext = new SearchContext();

        searchContext.setCompanyId(companyId);
        searchContext.setEnd(end);
        searchContext.setEntryClassNames(new String[] { DLFileEntryConstants.getClassName() });
        searchContext.setGroupIds(new long[] { groupId });

        Indexer indexer = IndexerRegistryUtil.getIndexer(DLFileEntryConstants.getClassName());

        searchContext.setSearchEngineId(indexer.getSearchEngineId());

        searchContext.setStart(start);
        searchContext.setUserId(userId);

        BooleanQuery contextQuery = BooleanQueryFactoryUtil.create(searchContext);

        contextQuery.addRequiredTerm(Field.PORTLET_ID, portletId);

        if (groupId > 0) {
            Group group = groupLocalService.getGroup(groupId);

            if (group.isLayout()) {
                contextQuery.addRequiredTerm(Field.SCOPE_GROUP_ID, groupId);

                groupId = group.getParentGroupId();
            }

            contextQuery.addRequiredTerm(Field.GROUP_ID, groupId);
        }

        if ((repositoryIds != null) && (repositoryIds.length > 0)) {
            BooleanQuery repositoryIdsQuery = BooleanQueryFactoryUtil.create(searchContext);

            for (long repositoryId : repositoryIds) {
                try {
                    if (userId > 0) {
                        PermissionChecker permissionChecker = PermissionThreadLocal.getPermissionChecker();

                        DLFolderPermission.check(permissionChecker, groupId, repositoryId, ActionKeys.VIEW);
                    }

                    if (repositoryId == DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {

                        repositoryId = groupId;
                    }

                    TermQuery termQuery = TermQueryFactoryUtil.create(searchContext, "repositoryId",
                            repositoryId);

                    repositoryIdsQuery.add(termQuery, BooleanClauseOccur.SHOULD);
                } catch (Exception e) {
                }
            }

            contextQuery.add(repositoryIdsQuery, BooleanClauseOccur.MUST);
        }

        BooleanQuery searchQuery = BooleanQueryFactoryUtil.create(searchContext);

        searchQuery.addTerms(_KEYWORDS_FIELDS, keywords);

        BooleanQuery fullQuery = BooleanQueryFactoryUtil.create(searchContext);

        fullQuery.add(contextQuery, BooleanClauseOccur.MUST);

        if (searchQuery.clauses().size() > 0) {
            fullQuery.add(searchQuery, BooleanClauseOccur.MUST);
        }

        return SearchEngineUtil.search(searchContext, fullQuery);
    } catch (Exception e) {
        throw new SystemException(e);
    }
}

---

From source file:com.liferay.portlet.tags.service.impl.TagsAssetLocalServiceImpl.java

License:Open Source License

public Hits search(long companyId, String portletId, String keywords, int start, int end)
        throws SystemException {

    try {//from w w  w  .  j  av a  2s . c o  m
        BooleanQuery contextQuery = BooleanQueryFactoryUtil.create();

        if (Validator.isNotNull(portletId)) {
            contextQuery.addRequiredTerm(Field.PORTLET_ID, portletId);
        } else {
            BooleanQuery portletIdsQuery = BooleanQueryFactoryUtil.create();

            for (String assetTypePortletId : TagsUtil.ASSET_TYPE_PORTLET_IDS) {

                TermQuery termQuery = TermQueryFactoryUtil.create(Field.PORTLET_ID, assetTypePortletId);

                portletIdsQuery.add(termQuery, BooleanClauseOccur.SHOULD);
            }

            contextQuery.add(portletIdsQuery, BooleanClauseOccur.MUST);
        }

        BooleanQuery searchQuery = BooleanQueryFactoryUtil.create();

        if (Validator.isNotNull(keywords)) {
            searchQuery.addTerm(Field.TITLE, keywords);
            searchQuery.addTerm(Field.CONTENT, keywords);
            searchQuery.addTerm(Field.DESCRIPTION, keywords);
            searchQuery.addTerm(Field.PROPERTIES, keywords);
            searchQuery.addTerm(Field.TAGS_ENTRIES, keywords);
        }

        BooleanQuery fullQuery = BooleanQueryFactoryUtil.create();

        fullQuery.add(contextQuery, BooleanClauseOccur.MUST);

        if (searchQuery.clauses().size() > 0) {
            fullQuery.add(searchQuery, BooleanClauseOccur.MUST);
        }

        return SearchEngineUtil.search(companyId, fullQuery, start, end);
    } catch (Exception e) {
        throw new SystemException(e);
    }
}

---

From source file:com.vportal.portlet.vcms.service.impl.VcmsArticleServiceImpl.java

License:Open Source License

public Hits search(long companyId, long groupId, long userId, String keywords, int start, int end)
        throws SystemException {
    try {//from   w ww. java 2  s .c om
        BooleanQuery contextQuery = BooleanQueryFactoryUtil.create();

        contextQuery.addRequiredTerm(Field.PORTLET_ID, PortletKeysExt.VCMS);

        if (groupId > 0) {
            contextQuery.addRequiredTerm(Field.GROUP_ID, groupId);
        }

        if (userId > 0) {
            contextQuery.addRequiredTerm(Field.USER_ID, userId);
        }

        BooleanQuery searchQuery = BooleanQueryFactoryUtil.create();

        if (Validator.isNotNull(keywords)) {
            searchQuery.addTerm(Field.TITLE, keywords);
            searchQuery.addTerm(Field.DESCRIPTION, keywords);
            searchQuery.addTerm(Field.CONTENT, keywords);
            /*searchQuery.addTerm(Field.TAGS_ENTRIES, keywords);*/
            searchQuery.addTerm(Field.ASSET_TAG_NAMES, keywords);
        }

        BooleanQuery fullQuery = BooleanQueryFactoryUtil.create();

        fullQuery.add(contextQuery, BooleanClauseOccur.MUST);

        if (searchQuery.clauses().size() > 0) {
            fullQuery.add(searchQuery, BooleanClauseOccur.MUST);
        }

        return SearchEngineUtil.search(companyId, fullQuery, start, end);
    } catch (Exception e) {
        throw new SystemException(e);
    }
}

---

From source file:com.vportal.portlet.vfaq.service.impl.FAQQuestionLocalServiceImpl.java

License:Open Source License

public Hits search(long companyId, long groupId, long userId, String keywords, int start, int end)
        throws SystemException {
    try {/*  ww w  .j a va 2  s  .  c  om*/
        BooleanQuery contextQuery = BooleanQueryFactoryUtil.create();

        contextQuery.addRequiredTerm(Field.PORTLET_ID, PortletKeysExt.FAQ_QUESTION);

        if (groupId > 0) {
            contextQuery.addRequiredTerm(Field.GROUP_ID, groupId);
        }

        if (userId > 0) {
            contextQuery.addRequiredTerm(Field.USER_ID, userId);
        }

        BooleanQuery searchQuery = BooleanQueryFactoryUtil.create();

        if (Validator.isNotNull(keywords)) {
            searchQuery.addTerm(Field.TITLE, keywords);
            searchQuery.addTerm(Field.CONTENT, keywords);
            /*searchQuery.addTerm(Field.TAGS_ENTRIES, keywords);*/
        }

        BooleanQuery fullQuery = BooleanQueryFactoryUtil.create();

        fullQuery.add(contextQuery, BooleanClauseOccur.MUST);

        if (searchQuery.clauses().size() > 0) {
            fullQuery.add(searchQuery, BooleanClauseOccur.MUST);
        }

        return SearchEngineUtil.search(companyId, fullQuery, start, end);
    } catch (Exception e) {
        throw new SystemException(e);
    }
}

---

From source file:com.vportal.portlet.vlegal.service.impl.VLegalDocumentServiceImpl.java

License:Open Source License

public Hits search(long companyId, long groupId, long userId, String keywords, int start, int end)
        throws SystemException {
    try {//ww  w.  j a  va  2s .c  o  m
        BooleanQuery contextQuery = BooleanQueryFactoryUtil.create();

        contextQuery.addRequiredTerm(Field.PORTLET_ID, PortletKeysExt.VLEGAL);

        if (groupId > 0) {
            contextQuery.addRequiredTerm(Field.GROUP_ID, groupId);
        }

        if (userId > 0) {
            contextQuery.addRequiredTerm(Field.USER_ID, userId);
        }

        BooleanQuery searchQuery = BooleanQueryFactoryUtil.create();

        if (Validator.isNotNull(keywords)) {
            searchQuery.addTerm(Field.TITLE, keywords);
            searchQuery.addTerm(Field.CONTENT, keywords);
            searchQuery.addTerm(Field.ASSET_TAG_NAMES, keywords);
        }

        BooleanQuery fullQuery = BooleanQueryFactoryUtil.create();

        fullQuery.add(contextQuery, BooleanClauseOccur.MUST);

        if (searchQuery.clauses().size() > 0) {
            fullQuery.add(searchQuery, BooleanClauseOccur.MUST);
        }

        return SearchEngineUtil.search(companyId, fullQuery, start, end);
    } catch (Exception e) {
        throw new SystemException(e);
    }
}

---