public Object objectByNamedQuery(SearchParameters sp) {
if (sp == null || !sp.hasNamedQuery()) {
throw new IllegalStateException(
"Invalid search template provided: could not determine which namedQuery to use");
}
Query query = entityManager.createNamedQuery(sp.getNamedQuery());
String queryString = getQueryString(query);
// append select count if needed
if (queryString != null
&& queryString.toLowerCase().startsWith("from")
&& !queryString.toLowerCase().contains("count(")) {
query = recreateQuery(query, "select count(*) " + queryString);
}
setQueryParameters(query, sp);
log.debug("objectNamedQuery : {}", sp.toString());
// execute
Object result = query.getSingleResult();
if (log.isDebugEnabled()) {
log.debug(
"{} returned a {} object",
sp.getNamedQuery(),
result == null ? "null" : result.getClass());
if (result instanceof Number) {
log.debug("{} returned a number with value : {}", sp.getNamedQuery(), result);
}
}
return result;
}
public static void main(String[] args) {
SearchParameters sps = new SearchParameters();
sps.setIndexID(66L);
sps.addFulltextField("Title", "科技");
SearchResult sr = ArticleIndexer.search(sps);
System.out.println(sr.Data);
}
public static SearchResult search(Mapx map) {
SearchParameters sps = new SearchParameters();
String site = map.getString("site");
String id = map.getString("id");
String catalog = map.getString("catalog");
if (StringUtil.isEmpty(catalog)) {
catalog = map.getString("Catalog");
}
String order = map.getString("order");
String time = map.getString("time");
String keyword = map.getString("keyword");
String query = map.getString("query");
if (StringUtil.isEmpty(keyword)) {
keyword = query;
}
String page = map.getString("page");
String size = map.getString("size");
if (StringUtil.isEmpty(id)) {
id = SearchAPI.getIndexIDBySiteID(site);
}
if (StringUtil.isNotEmpty(keyword)) {
sps.addFulltextField("Title", keyword, false);
sps.addFulltextField("Content", keyword, false);
sps.addFulltextField("_Keyword", keyword, true);
}
if ("time".equalsIgnoreCase(order)) {
sps.setSortField("PublishDate", 3, true);
}
if (StringUtil.isNotEmpty(time)) {
Date today = new Date();
String StartDate = DateUtil.toString(DateUtil.addDay(today, -36500));
if (time.equals("week")) StartDate = DateUtil.toString(DateUtil.addDay(today, -7));
else if (time.equals("month")) StartDate = DateUtil.toString(DateUtil.addDay(today, -30));
else if (time.equals("quarter")) {
StartDate = DateUtil.toString(DateUtil.addDay(today, -90));
}
String EndDate = "2999-01-01";
sps.setDateRange("PublishDate", StartDate, EndDate);
}
if (StringUtil.isNotEmpty(catalog)) {
sps.addLeftLikeField("CatalogInnerCode", catalog);
}
if (StringUtil.isNotEmpty(page)) {
sps.setPageIndex(Integer.parseInt(page) - 1);
}
if (StringUtil.isNotEmpty(size)) {
sps.setPageSize(Integer.parseInt(size));
}
if (StringUtil.isEmpty(id)) {
SearchResult sr = new SearchResult();
sr.Data = new DataTable();
return sr;
}
sps.setIndexID(Long.parseLong(id));
return ArticleIndexer.search(sps);
}
private void setQueryParameters(Query query, SearchParameters sp) {
// add default parameter if specified in the named query
for (Parameter<?> p : query.getParameters()) {
if (NAMED_PARAMETER_CURRENT_USER_ID.equals(p.getName())) {
query.setParameter(NAMED_PARAMETER_CURRENT_USER_ID, UserContext.getId());
} else if (NAMED_PARAMETER_NOW.equals(p.getName())) {
query.setParameter(NAMED_PARAMETER_NOW, Calendar.getInstance().getTime());
}
}
// add parameters for the named query
for (String paramName : sp.getNamedQueryParameters().keySet()) {
query.setParameter(paramName, sp.getNamedQueryParameter(paramName));
}
}
/** Construct a join predicate on collection (eg many to many, List) */
public <T> List<Predicate> byExampleOnManyToMany(
ManagedType<T> mt,
Root<T> mtPath,
final T mtValue,
SearchParameters sp,
CriteriaBuilder builder) {
List<Predicate> predicates = newArrayList();
for (PluralAttribute<T, ?, ?> pa : mt.getDeclaredPluralAttributes()) {
if (pa.getCollectionType() == PluralAttribute.CollectionType.LIST) {
List<?> values = (List<?>) JpaUtil.getValue(mtValue, mt.getAttribute(pa.getName()));
if (values != null && !values.isEmpty()) {
if (sp.getUseANDInManyToMany()) {
if (values.size() > 3) {
log.warn(
"Please note that using AND restriction on an Many to Many relationship requires as many joins as values");
}
for (Object value : values) {
ListJoin<T, ?> join = mtPath.join(mt.getDeclaredList(pa.getName()));
predicates.add(join.in(value));
}
} else {
ListJoin<T, ?> join = mtPath.join(mt.getDeclaredList(pa.getName()));
predicates.add(join.in(values));
}
}
}
}
return predicates;
}
public <E> Predicate byEntitySelectors(
Root<E> root, CriteriaBuilder builder, SearchParameters sp) {
List<EntitySelector<?, ?, ?>> selectors = sp.getEntities();
List<Predicate> predicates = newArrayList();
for (EntitySelector<?, ?, ?> s : selectors) {
@SuppressWarnings("unchecked")
EntitySelector<? super E, ? extends Identifiable<?>, ?> selector =
(EntitySelector<? super E, ? extends Identifiable<?>, ?>) s;
if (selector.isNotEmpty()) {
List<Predicate> selectorPredicates = newArrayList();
for (Identifiable<?> selection : selector.getSelected()) {
selectorPredicates.add(builder.equal(getExpression(root, selector), selection.getId()));
}
if (TRUE == selector.getIncludeNull()) {
selectorPredicates.add(builder.or(builder.isNull(getExpression(root, selector))));
}
predicates.add(JpaUtil.orPredicate(builder, selectorPredicates));
} else if (selector.isIncludeNullSet()) {
if (selector.getIncludeNull()) {
predicates.add(builder.isNull(getExpression(root, selector)));
} else {
predicates.add(builder.isNotNull(getExpression(root, selector)));
}
}
}
return JpaUtil.concatPredicate(sp, builder, predicates);
}
public <T> List<T> findByNamedQuery(SearchParameters sp) {
if (sp == null || !sp.hasNamedQuery()) {
throw new IllegalArgumentException(
"searchParameters must be non null and must have a namedQuery");
}
Query query = entityManager.createNamedQuery(sp.getNamedQuery());
String queryString = getQueryString(query);
// append order by if needed
if (queryString != null && sp.hasOrders()) {
// create the sql restriction clausis
StringBuilder orderClausis = new StringBuilder("order by ");
boolean first = true;
for (OrderBy orderBy : sp.getOrders()) {
if (!first) {
orderClausis.append(", ");
}
orderClausis.append(orderBy.getColumn());
orderClausis.append(orderBy.isOrderDesc() ? " desc" : " asc");
first = false;
}
if (log.isDebugEnabled()) {
log.debug("appending: [" + orderClausis.toString() + "] to " + queryString);
}
query = recreateQuery(query, queryString + " " + orderClausis.toString());
}
// pagination
if (sp.getFirstResult() >= 0) {
query.setFirstResult(sp.getFirstResult());
}
if (sp.getMaxResults() > 0) {
query.setMaxResults(sp.getMaxResults());
}
// named parameters
setQueryParameters(query, sp);
// execute
@SuppressWarnings("unchecked")
List<T> result = (List<T>) query.getResultList();
if (result != null && log.isDebugEnabled()) {
log.debug(sp.getNamedQuery() + " returned a List of size: " + result.size());
}
return result;
}
public static SearchResult tagSearch(Mapx map) {
SearchParameters sps = new SearchParameters();
String site = map.getString("site");
String order = map.getString("order");
String keyword = map.getString("keyword");
String query = map.getString("query");
if (StringUtil.isEmpty(keyword)) {
keyword = query;
}
String page = map.getString("page");
String size = map.getString("size");
if (StringUtil.isNotEmpty(keyword)) {
sps.addLikeField("Tag", keyword, false);
}
if ("time".equalsIgnoreCase(order)) {
sps.setSortField("PublishDate", 3, true);
}
if (StringUtil.isNotEmpty(page)) {
sps.setPageIndex(Integer.parseInt(page) - 1);
}
if (StringUtil.isNotEmpty(size)) {
sps.setPageSize(Integer.parseInt(size));
}
String id = SearchAPI.getIndexIDBySiteID(site);
sps.setIndexID(Long.parseLong(id));
return ArticleIndexer.search(sps);
}
// 'g.' preffix because of ERROR 1052 (23000): Column 'column_name' in where
// clause is ambiguous
// caused by the same name of columns in m_office and m_group tables
private String getGroupExtraCriteria(final SearchParameters searchCriteria) {
String extraCriteria = " and g.level_Id = " + GroupTypes.GROUP.getId();
String sqlSearch = searchCriteria.getSqlSearch();
if (sqlSearch != null) {
sqlSearch = sqlSearch.replaceAll(" display_name ", " g.display_name ");
sqlSearch = sqlSearch.replaceAll("display_name ", "g.display_name ");
extraCriteria += " and (" + sqlSearch + ")";
}
final Long officeId = searchCriteria.getOfficeId();
if (officeId != null) {
extraCriteria += " and g.office_id = " + officeId;
}
final String externalId = searchCriteria.getExternalId();
if (externalId != null) {
extraCriteria += " and g.external_id = " + ApiParameterHelper.sqlEncodeString(externalId);
}
final String name = searchCriteria.getName();
if (name != null) {
extraCriteria +=
" and g.display_name like " + ApiParameterHelper.sqlEncodeString("%" + name + "%");
}
final String hierarchy = searchCriteria.getHierarchy();
if (hierarchy != null) {
extraCriteria +=
" and o.hierarchy like " + ApiParameterHelper.sqlEncodeString(hierarchy + "%");
}
if (StringUtils.isNotBlank(extraCriteria)) {
extraCriteria = extraCriteria.substring(4);
}
return extraCriteria;
}
@Override
public Page<GroupGeneralData> retrieveAll(final SearchParameters searchParameters) {
final AppUser currentUser = this.context.authenticatedUser();
final String hierarchy = currentUser.getOffice().getHierarchy();
final String hierarchySearchString = hierarchy + "%";
final StringBuilder sqlBuilder = new StringBuilder(200);
sqlBuilder.append("select SQL_CALC_FOUND_ROWS ");
sqlBuilder.append(this.allGroupTypesDataMapper.schema());
sqlBuilder.append(" where o.hierarchy like ?");
final String extraCriteria = getGroupExtraCriteria(searchParameters);
if (StringUtils.isNotBlank(extraCriteria)) {
sqlBuilder.append(" and (").append(extraCriteria).append(")");
}
if (searchParameters.isOrderByRequested()) {
sqlBuilder
.append(" order by ")
.append(searchParameters.getOrderBy())
.append(' ')
.append(searchParameters.getSortOrder());
}
if (searchParameters.isLimited()) {
sqlBuilder.append(" limit ").append(searchParameters.getLimit());
if (searchParameters.isOffset()) {
sqlBuilder.append(" offset ").append(searchParameters.getOffset());
}
}
final String sqlCountRows = "SELECT FOUND_ROWS()";
return this.paginationHelper.fetchPage(
this.jdbcTemplate,
sqlCountRows,
sqlBuilder.toString(),
new Object[] {hierarchySearchString},
this.allGroupTypesDataMapper);
}
@RequiredReadAction
private static boolean processInheritors(
@NotNull final Processor<DotNetTypeDeclaration> consumer,
@NotNull final String baseVmQName,
@NotNull final SearchScope searchScope,
@NotNull final SearchParameters parameters) {
if (DotNetTypes.System.Object.equals(baseVmQName)) {
return AllTypesSearch.search(
searchScope, parameters.getProject(), parameters.getNameCondition())
.forEach(
new Processor<DotNetTypeDeclaration>() {
@Override
public boolean process(final DotNetTypeDeclaration aClass) {
ProgressIndicatorProvider.checkCanceled();
final String qname1 =
ApplicationManager.getApplication()
.runReadAction(
new Computable<String>() {
@Override
@Nullable
public String compute() {
return aClass.getVmQName();
}
});
return DotNetTypes.System.Object.equals(qname1)
|| consumer.process(parameters.myTransformer.fun(aClass));
}
});
}
final Ref<String> currentBase = Ref.create(null);
final Stack<String> stack = new Stack<String>();
// there are two sets for memory optimization: it's cheaper to hold FQN than PsiClass
final Set<String> processedFqns =
new THashSet<String>(); // FQN of processed classes if the class has one
final Processor<DotNetTypeDeclaration> processor =
new Processor<DotNetTypeDeclaration>() {
@Override
public boolean process(final DotNetTypeDeclaration candidate) {
ProgressIndicatorProvider.checkCanceled();
final Ref<Boolean> result = new Ref<Boolean>();
final Ref<String> vmQNameRef = new Ref<String>();
ApplicationManager.getApplication()
.runReadAction(
new Runnable() {
@Override
public void run() {
vmQNameRef.set(candidate.getVmQName());
if (parameters.isCheckInheritance() || parameters.isCheckDeep()) {
if (!candidate.isInheritor(currentBase.get(), false)) {
result.set(true);
return;
}
}
if (PsiSearchScopeUtil.isInScope(searchScope, candidate)) {
final String name = candidate.getName();
if (name != null
&& parameters.getNameCondition().value(name)
&& !consumer.process(parameters.myTransformer.fun(candidate))) {
result.set(false);
}
}
}
});
if (!result.isNull()) {
return result.get();
}
if (parameters.isCheckDeep() && !isSealed(candidate)) {
stack.push(vmQNameRef.get());
}
return true;
}
};
stack.push(baseVmQName);
final GlobalSearchScope projectScope = GlobalSearchScope.allScope(parameters.getProject());
while (!stack.isEmpty()) {
ProgressIndicatorProvider.checkCanceled();
String vmQName = stack.pop();
if (!processedFqns.add(vmQName)) {
continue;
}
currentBase.set(vmQName);
if (!DirectTypeInheritorsSearch.search(parameters.getProject(), vmQName, projectScope, false)
.forEach(processor)) {
return false;
}
}
return true;
}
private void setQueryParameters(Query query, SearchParameters sp) {
// add parameters for the named query
for (Entry<String, Object> entrySet : sp.getNamedQueryParameters().entrySet()) {
query.setParameter(entrySet.getKey(), entrySet.getValue());
}
}
public static SearchResult advanceSearch(Mapx map) {
SearchParameters sps = new SearchParameters();
String site = map.getString("site");
String id = map.getString("id");
String startDate = map.getString("startdate");
String endDate = map.getString("enddate");
String catalog = map.getString("catalog");
String author = map.getString("author");
String title = map.getString("title");
String content = map.getString("content");
String keyword = map.getString("keyword");
String query = map.getString("query");
if (StringUtil.isEmpty(keyword)) {
keyword = query;
}
String orderField = map.getString("orderfield");
String descFlag = map.getString("descflag");
String page = map.getString("page");
String size = map.getString("size");
if (StringUtil.isEmpty(id)) {
id = SearchAPI.getIndexIDBySiteID(site);
}
if ((StringUtil.isNotEmpty(startDate)) && (StringUtil.isEmpty(endDate))) {
endDate = "2099-01-01";
}
if ((StringUtil.isNotEmpty(endDate)) && (StringUtil.isEmpty(startDate))) {
startDate = "1900-01-01";
}
if (StringUtil.isNotEmpty(startDate)) {
sps.setDateRange("PublishDate", startDate, endDate);
}
if (StringUtil.isNotEmpty(catalog)) {
sps.addLeftLikeField("CatalogInnerCode", catalog, true);
}
if (StringUtil.isNotEmpty(title)) {
sps.addFulltextField("Title", title);
}
if (StringUtil.isNotEmpty(content)) {
sps.addFulltextField("Content", content);
}
if (StringUtil.isNotEmpty(keyword)) {
sps.addFulltextField("Title", keyword, false);
sps.addFulltextField("Content", keyword, false);
sps.addFulltextField("_Keyword", keyword, true);
}
if (StringUtil.isNotEmpty(orderField)) {
boolean isDesc = "true".equals(descFlag);
sps.setSortField(orderField, 3, isDesc);
}
if (StringUtil.isNotEmpty(author)) {
sps.addEqualField("Author", author);
}
if (StringUtil.isNotEmpty(page)) {
sps.setPageIndex(Integer.parseInt(page) - 1);
}
if (StringUtil.isNotEmpty(size)) {
sps.setPageSize(Integer.parseInt(size));
}
if (StringUtil.isEmpty(id)) {
SearchResult sr = new SearchResult();
sr.Data = new DataTable();
return sr;
}
sps.setIndexID(Long.parseLong(id));
return ArticleIndexer.search(sps);
}
