/*******************************************************************************
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*******************************************************************************/
package org.ofbiz.workeffort.workeffort;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
import javolution.util.FastList;
import javolution.util.FastSet;
import org.ofbiz.base.util.Debug;
import org.ofbiz.base.util.UtilDateTime;
import org.ofbiz.base.util.UtilMisc;
import org.ofbiz.base.util.UtilProperties;
import org.ofbiz.base.util.UtilValidate;
import org.ofbiz.common.KeywordSearchUtil;
import org.ofbiz.entity.Delegator;
import org.ofbiz.entity.GenericEntityException;
import org.ofbiz.entity.GenericValue;
import org.ofbiz.entity.condition.EntityComparisonOperator;
import org.ofbiz.entity.condition.EntityCondition;
import org.ofbiz.entity.condition.EntityConditionList;
import org.ofbiz.entity.condition.EntityExpr;
import org.ofbiz.entity.condition.EntityFunction;
import org.ofbiz.entity.condition.EntityOperator;
import org.ofbiz.entity.model.DynamicViewEntity;
import org.ofbiz.entity.model.ModelKeyMap;
import org.ofbiz.entity.model.ModelViewEntity.ComplexAlias;
import org.ofbiz.entity.model.ModelViewEntity.ComplexAliasField;
import org.ofbiz.entity.transaction.GenericTransactionException;
import org.ofbiz.entity.transaction.TransactionUtil;
import org.ofbiz.entity.util.EntityFindOptions;
import org.ofbiz.entity.util.EntityListIterator;
import org.ofbiz.entity.util.EntityUtil;
/**
* Utilities for WorkEffort search based on various constraints including assocs, features and keywords.
*
* Search:
* WorkEffort fields: workEffortTypeId,workEffortPurposeTypeId,scopeEnumId, ??others
* WorkEffortKeyword - keyword search
* WorkEffortAssoc.workEffortIdTo,workEffortIdFrom,workEffortAssocTypeId
* Sub-tasks: WorkEffortAssoc.workEffortIdTo,workEffortIdFrom,workEffortAssocTypeId=WORK_EFF_BREAKDOWN for sub-tasks OR: (specific assoc and all sub-tasks)
* Sub-tasks: WorkEffort.workEffortParentId tree
* WorkEffortGoodStandard.productId
* WorkEffortPartyAssignment.partyId,roleTypeId
* Planned for later:
* WorkEffortFixedAssetAssign.fixedAssetId
* WorkEffortContent.contentId,workEffortContentTypeId
* WorkEffortBilling.invoiceId,invoiceItemSeqId
* CommunicationEventWorkEff.communicationEventId
* TimeEntry.partyId,rateTypeId,timesheetId,invoiceId,invoiceItemSeqId
*/
public class WorkEffortSearch {
public static final String module = WorkEffortSearch.class.getName();
public static final String resource = "WorkEffortUiLabels";
public static ArrayList<String> searchWorkEfforts(List<? extends WorkEffortSearchConstraint> workEffortSearchConstraintList, ResultSortOrder resultSortOrder, Delegator delegator, String visitId) {
WorkEffortSearchContext workEffortSearchContext = new WorkEffortSearchContext(delegator, visitId);
workEffortSearchContext.addWorkEffortSearchConstraints(workEffortSearchConstraintList);
workEffortSearchContext.setResultSortOrder(resultSortOrder);
ArrayList<String> workEffortIds = workEffortSearchContext.doSearch();
return workEffortIds;
}
public static void getAllSubWorkEffortIds(String workEffortId, Set<String> workEffortIdSet, Delegator delegator, Timestamp nowTimestamp) {
if (nowTimestamp == null) {
nowTimestamp = UtilDateTime.nowTimestamp();
}
// first make sure the current id is in the Set
workEffortIdSet.add(workEffortId);
// now find all sub-categories, filtered by effective dates, and call this routine for them
try {
// Find WorkEffortAssoc, workEffortAssocTypeId=WORK_EFF_BREAKDOWN
List<GenericValue> workEffortAssocList = delegator.findByAndCache("WorkEffortAssoc", UtilMisc.toMap("workEffortIdFrom", workEffortId, "workEffortAssocTypeId", "WORK_EFF_BREAKDOWN"));
for (GenericValue workEffortAssoc: workEffortAssocList) {
String subWorkEffortId = workEffortAssoc.getString("workEffortIdTo");
if (workEffortIdSet.contains(subWorkEffortId)) {
// if this category has already been traversed, no use doing it again; this will also avoid infinite loops
continue;
}
// do the date filtering in the loop to avoid looping through the list twice
if (EntityUtil.isValueActive(workEffortAssoc, nowTimestamp)) {
getAllSubWorkEffortIds(subWorkEffortId, workEffortIdSet, delegator, nowTimestamp);
}
}
// Find WorkEffort where current workEffortId = workEffortParentId; only select minimal fields to keep the size low
List<GenericValue> childWorkEffortList = delegator.findList("WorkEffort", EntityCondition.makeCondition("workEffortParentId", EntityComparisonOperator.EQUALS, workEffortId),
UtilMisc.toSet("workEffortId", "workEffortParentId"), null, null, true);
for (GenericValue childWorkEffort: childWorkEffortList) {
String subWorkEffortId = childWorkEffort.getString("workEffortId");
if (workEffortIdSet.contains(subWorkEffortId)) {
// if this category has already been traversed, no use doing it again; this will also avoid infinite loops
continue;
}
// do the date filtering in the loop to avoid looping through the list twice
getAllSubWorkEffortIds(subWorkEffortId, workEffortIdSet, delegator, nowTimestamp);
}
} catch (GenericEntityException e) {
Debug.logError(e, "Error finding sub-categories for workEffort search", module);
}
}
public static class WorkEffortSearchContext {
public int index = 1;
public List<EntityCondition> entityConditionList = FastList.newInstance();
public List<String> orderByList = FastList.newInstance();
public List<String> fieldsToSelect = UtilMisc.toList("workEffortId");
public DynamicViewEntity dynamicViewEntity = new DynamicViewEntity();
public boolean workEffortIdGroupBy = false;
public boolean includedKeywordSearch = false;
public Timestamp nowTimestamp = UtilDateTime.nowTimestamp();
public List<Set<String>> keywordFixedOrSetAndList = FastList.newInstance();
public Set<String> orKeywordFixedSet = FastSet.newInstance();
public Set<String> andKeywordFixedSet = FastSet.newInstance();
public List<GenericValue> workEffortSearchConstraintList = FastList.newInstance();
public ResultSortOrder resultSortOrder = null;
public Integer resultOffset = null;
public Integer maxResults = null;
protected Delegator delegator = null;
protected String visitId = null;
protected Integer totalResults = null;
public WorkEffortSearchContext(Delegator delegator, String visitId) {
this.delegator = delegator;
this.visitId = visitId;
dynamicViewEntity.addMemberEntity("WEFF", "WorkEffort");
}
public Delegator getDelegator() {
return this.delegator;
}
public void addWorkEffortSearchConstraints(List<? extends WorkEffortSearchConstraint> workEffortSearchConstraintList) {
// Go through the constraints and add them in
for (WorkEffortSearchConstraint constraint: workEffortSearchConstraintList) {
constraint.addConstraint(this);
}
}
public void setResultSortOrder(ResultSortOrder resultSortOrder) {
this.resultSortOrder = resultSortOrder;
}
public void setResultOffset(Integer resultOffset) {
this.resultOffset = resultOffset;
}
public void setMaxResults(Integer maxResults) {
this.maxResults = maxResults;
}
public Integer getTotalResults() {
return this.totalResults;
}
public ArrayList<String> doSearch() {
long startMillis = System.currentTimeMillis();
// do the query
EntityListIterator eli = this.doQuery(delegator);
ArrayList<String> workEffortIds = this.makeWorkEffortIdList(eli);
if (eli != null) {
try {
eli.close();
} catch (GenericEntityException e) {
Debug.logError(e, "Error closing WorkEffortSearch EntityListIterator");
}
}
long endMillis = System.currentTimeMillis();
double totalSeconds = ((double)endMillis - (double)startMillis)/1000.0;
// store info about results in the database, attached to the user's visitId, if specified
this.saveSearchResultInfo(Long.valueOf(workEffortIds.size()), Double.valueOf(totalSeconds));
return workEffortIds;
}
public void finishKeywordConstraints() {
if (orKeywordFixedSet.size() == 0 && andKeywordFixedSet.size() == 0 && keywordFixedOrSetAndList.size() == 0) {
return;
}
// we know we have a keyword search to do, so keep track of that now...
this.includedKeywordSearch = true;
// if there is anything in the orKeywordFixedSet add it to the keywordFixedOrSetAndList
if (orKeywordFixedSet.size() > 0) {
// put in keywordFixedOrSetAndList to process with other or lists where at least one is required
keywordFixedOrSetAndList.add(orKeywordFixedSet);
}
// remove all or sets from the or set and list where the or set is size 1 and put them in the and list
Iterator<Set<String>> keywordFixedOrSetAndTestIter = keywordFixedOrSetAndList.iterator();
while (keywordFixedOrSetAndTestIter.hasNext()) {
Set<String> keywordFixedOrSet = keywordFixedOrSetAndTestIter.next();
if (keywordFixedOrSet.size() == 0) {
keywordFixedOrSetAndTestIter.remove();
} else if (keywordFixedOrSet.size() == 1) {
// treat it as just another and
andKeywordFixedSet.add(keywordFixedOrSet.iterator().next());
keywordFixedOrSetAndTestIter.remove();
}
}
boolean doingBothAndOr = (keywordFixedOrSetAndList.size() > 1) || (keywordFixedOrSetAndList.size() > 0 && andKeywordFixedSet.size() > 0);
Debug.logInfo("Finished initial setup of keywords, doingBothAndOr=" + doingBothAndOr + ", andKeywordFixedSet=" + andKeywordFixedSet + "\n keywordFixedOrSetAndList=" + keywordFixedOrSetAndList, module);
ComplexAlias relevancyComplexAlias = new ComplexAlias("+");
if (andKeywordFixedSet.size() > 0) {
// add up the relevancyWeight fields from all keyword member entities for a total to sort by
for (String keyword: andKeywordFixedSet) {
// make index based values and increment
String entityAlias = "PK" + index;
String prefix = "pk" + index;
index++;
dynamicViewEntity.addMemberEntity(entityAlias, "WorkEffortKeyword");
dynamicViewEntity.addAlias(entityAlias, prefix + "Keyword", "keyword", null, null, null, null);
dynamicViewEntity.addViewLink("WEFF", entityAlias, Boolean.FALSE, ModelKeyMap.makeKeyMapList("workEffortId"));
entityConditionList.add(EntityCondition.makeCondition(prefix + "Keyword", EntityOperator.LIKE, keyword));
//don't add an alias for this, will be part of a complex alias: dynamicViewEntity.addAlias(entityAlias, prefix + "RelevancyWeight", "relevancyWeight", null, null, null, null);
relevancyComplexAlias.addComplexAliasMember(new ComplexAliasField(entityAlias, "relevancyWeight", null, null));
}
//TODO: find out why Oracle and other dbs don't like the query resulting from this and fix: workEffortIdGroupBy = true;
if (!doingBothAndOr) {
dynamicViewEntity.addAlias(null, "totalRelevancy", null, null, null, null, null, relevancyComplexAlias);
}
}
if (keywordFixedOrSetAndList.size() > 0) {
for (Set<String> keywordFixedOrSet: keywordFixedOrSetAndList) {
// make index based values and increment
String entityAlias = "PK" + index;
String prefix = "pk" + index;
index++;
dynamicViewEntity.addMemberEntity(entityAlias, "WorkEffortKeyword");
dynamicViewEntity.addAlias(entityAlias, prefix + "Keyword", "keyword", null, null, null, null);
dynamicViewEntity.addViewLink("WEFF", entityAlias, Boolean.FALSE, ModelKeyMap.makeKeyMapList("workEffortId"));
List<EntityExpr> keywordOrList = FastList.newInstance();
for (String keyword: keywordFixedOrSet) {
keywordOrList.add(EntityCondition.makeCondition(prefix + "Keyword", EntityOperator.LIKE, keyword));
}
entityConditionList.add(EntityCondition.makeCondition(keywordOrList, EntityOperator.OR));
workEffortIdGroupBy = true;
if (doingBothAndOr) {
relevancyComplexAlias.addComplexAliasMember(new ComplexAliasField(entityAlias, "relevancyWeight", null, "sum"));
} else {
dynamicViewEntity.addAlias(entityAlias, "totalRelevancy", "relevancyWeight", null, null, null, "sum");
}
}
}
if (doingBothAndOr) {
dynamicViewEntity.addAlias(null, "totalRelevancy", null, null, null, null, null, relevancyComplexAlias);
}
}
public EntityListIterator doQuery(Delegator delegator) {
// handle the now assembled or and and keyword fixed lists
this.finishKeywordConstraints();
if (resultSortOrder != null) {
resultSortOrder.setSortOrder(this);
}
dynamicViewEntity.addAlias("WEFF", "workEffortId", null, null, null, Boolean.valueOf(workEffortIdGroupBy), null);
EntityCondition whereCondition = EntityCondition.makeCondition(entityConditionList, EntityOperator.AND);
// Debug.logInfo("WorkEffortSearch, whereCondition = " + whereCondition.toString(), module);
EntityFindOptions efo = new EntityFindOptions();
efo.setDistinct(true);
efo.setResultSetType(EntityFindOptions.TYPE_SCROLL_INSENSITIVE);
if (maxResults != null) {
efo.setMaxRows(maxResults);
}
EntityListIterator eli = null;
try {
eli = delegator.findListIteratorByCondition(dynamicViewEntity, whereCondition, null, fieldsToSelect, orderByList, efo);
} catch (GenericEntityException e) {
Debug.logError(e, "Error in workEffort search", module);
return null;
}
return eli;
}
public ArrayList<String> makeWorkEffortIdList(EntityListIterator eli) {
ArrayList<String> workEffortIds = new ArrayList<String>(maxResults == null ? 100 : maxResults.intValue());
if (eli == null) {
Debug.logWarning("The eli is null, returning zero results", module);
return workEffortIds;
}
try {
boolean hasResults = false;
Object initialResult = null;
/* this method has been replaced by the following to address issue with SAP DB and possibly other DBs
if (resultOffset != null) {
Debug.logInfo("Before relative, current index=" + eli.currentIndex(), module);
hasResults = eli.relative(resultOffset.intValue());
} else {
initialResult = eli.next();
if (initialResult != null) {
hasResults = true;
}
}
*/
initialResult = eli.next();
if (initialResult != null) {
hasResults = true;
}
if (resultOffset != null && resultOffset.intValue() > 1) {
if (Debug.infoOn()) Debug.logInfo("Before relative, current index=" + eli.currentIndex(), module);
hasResults = eli.relative(resultOffset.intValue() - 1);
initialResult = null;
}
// get the first as the current one
GenericValue searchResult = null;
if (hasResults) {
if (initialResult != null) {
searchResult = (GenericValue) initialResult;
} else {
searchResult = eli.currentGenericValue();
}
}
if (searchResult == null) {
// nothing to get...
int failTotal = 0;
if (this.resultOffset != null) {
failTotal = this.resultOffset.intValue() - 1;
}
this.totalResults = Integer.valueOf(failTotal);
return workEffortIds;
}
// init numRetreived to one since we have already grabbed the initial one
int numRetreived = 1;
int duplicatesFound = 0;
Set<String> workEffortIdSet = FastSet.newInstance();
workEffortIds.add(searchResult.getString("workEffortId"));
workEffortIdSet.add(searchResult.getString("workEffortId"));
while (((searchResult = eli.next()) != null) && (maxResults == null || numRetreived < maxResults.intValue())) {
String workEffortId = searchResult.getString("workEffortId");
if (!workEffortIdSet.contains(workEffortId)) {
workEffortIds.add(workEffortId);
workEffortIdSet.add(workEffortId);
numRetreived++;
} else {
duplicatesFound++;
}
/*
StringBuilder lineMsg = new StringBuilder("Got search result line: ");
Iterator<String> fieldsToSelectIter = fieldsToSelect.iterator();
while (fieldsToSelectIter.hasNext()) {
String fieldName = fieldsToSelectIter.next();
lineMsg.append(fieldName);
lineMsg.append("=");
lineMsg.append(searchResult.get(fieldName));
if (fieldsToSelectIter.hasNext()) {
lineMsg.append(", ");
}
}
Debug.logInfo(lineMsg.toString(), module);
*/
}
if (searchResult != null) {
this.totalResults = eli.getResultsSizeAfterPartialList();
}
if (this.totalResults == null || this.totalResults.intValue() == 0) {
int total = numRetreived;
if (this.resultOffset != null) {
total += (this.resultOffset.intValue() - 1);
}
this.totalResults = Integer.valueOf(total);
}
Debug.logInfo("Got search values, numRetreived=" + numRetreived + ", totalResults=" + totalResults + ", maxResults=" + maxResults + ", resultOffset=" + resultOffset + ", duplicatesFound(in the current results)=" + duplicatesFound, module);
} catch (GenericEntityException e) {
Debug.logError(e, "Error getting results from the workEffort search query", module);
}
return workEffortIds;
}
public void saveSearchResultInfo(Long numResults, Double secondsTotal) {
// uses entities: WorkEffortSearchResult and WorkEffortSearchConstraint
try {
// make sure this is in a transaction
boolean beganTransaction = TransactionUtil.begin();
try {
GenericValue workEffortSearchResult = delegator.makeValue("WorkEffortSearchResult");
String workEffortSearchResultId = delegator.getNextSeqId("WorkEffortSearchResult");
workEffortSearchResult.set("workEffortSearchResultId", workEffortSearchResultId);
workEffortSearchResult.set("visitId", this.visitId);
if (this.resultSortOrder != null) {
workEffortSearchResult.set("orderByName", this.resultSortOrder.getOrderName());
workEffortSearchResult.set("isAscending", this.resultSortOrder.isAscending() ? "Y" : "N");
}
workEffortSearchResult.set("numResults", numResults);
workEffortSearchResult.set("secondsTotal", secondsTotal);
workEffortSearchResult.set("searchDate", nowTimestamp);
workEffortSearchResult.create();
int seqId = 1;
for (GenericValue workEffortSearchConstraint: workEffortSearchConstraintList) {
workEffortSearchConstraint.set("workEffortSearchResultId", workEffortSearchResultId);
workEffortSearchConstraint.set("constraintSeqId", Integer.toString(seqId));
workEffortSearchConstraint.create();
seqId++;
}
TransactionUtil.commit(beganTransaction);
} catch (GenericEntityException e1) {
String errMsg = "Error saving workEffort search result info/stats";
Debug.logError(e1, errMsg, module);
TransactionUtil.rollback(beganTransaction, errMsg, e1);
}
} catch (GenericTransactionException e) {
Debug.logError(e, "Error saving workEffort search result info/stats", module);
}
}
}
// ======================================================================
// Search Constraint Classes
// ======================================================================
@SuppressWarnings("serial")
public static abstract class WorkEffortSearchConstraint implements java.io.Serializable {
public WorkEffortSearchConstraint() { }
public abstract void addConstraint(WorkEffortSearchContext workEffortSearchContext);
/** pretty print for log messages and even UI stuff */
public abstract String prettyPrintConstraint(Delegator delegator, boolean detailed, Locale locale);
}
@SuppressWarnings("serial")
public static class WorkEffortAssocConstraint extends WorkEffortSearchConstraint {
public static final String constraintName = "WorkEffortAssoc";
protected String workEffortId;
protected String workEffortAssocTypeId;
protected boolean includeSubWorkEfforts;
public WorkEffortAssocConstraint(String workEffortId, String workEffortAssocTypeId, boolean includeSubWorkEfforts) {
this.workEffortId = workEffortId;
this.workEffortAssocTypeId = workEffortAssocTypeId;
this.includeSubWorkEfforts = includeSubWorkEfforts;
}
@Override
public void addConstraint(WorkEffortSearchContext workEffortSearchContext) {
Set<String> workEffortIdSet = FastSet.newInstance();
if (includeSubWorkEfforts) {
// find all sub-categories recursively, make a Set of workEffortId
WorkEffortSearch.getAllSubWorkEffortIds(workEffortId, workEffortIdSet, workEffortSearchContext.getDelegator(), workEffortSearchContext.nowTimestamp);
} else {
workEffortIdSet.add(workEffortId);
}
// allow assoc from or to the current WE and the workEffortId on this constraint
// make index based values and increment
String entityAlias;
String prefix;
// do workEffortId = workEffortIdFrom, workEffortIdTo IN workEffortIdSet
entityAlias = "WFA" + workEffortSearchContext.index;
prefix = "wfa" + workEffortSearchContext.index;
workEffortSearchContext.index++;
workEffortSearchContext.dynamicViewEntity.addMemberEntity(entityAlias, "WorkEffortAssoc");
workEffortSearchContext.dynamicViewEntity.addAlias(entityAlias, prefix + "WorkEffortIdFrom", "workEffortIdFrom", null, null, null, null);
workEffortSearchContext.dynamicViewEntity.addAlias(entityAlias, prefix + "WorkEffortIdTo", "workEffortIdTo", null, null, null, null);
workEffortSearchContext.dynamicViewEntity.addAlias(entityAlias, prefix + "WorkEffortAssocTypeId", "workEffortAssocTypeId", null, null, null, null);
workEffortSearchContext.dynamicViewEntity.addAlias(entityAlias, prefix + "FromDate", "fromDate", null, null, null, null);
workEffortSearchContext.dynamicViewEntity.addAlias(entityAlias, prefix + "ThruDate", "thruDate", null, null, null, null);
workEffortSearchContext.dynamicViewEntity.addViewLink("WEFF", entityAlias, Boolean.TRUE, ModelKeyMap.makeKeyMapList("workEffortId","workEffortIdFrom"));
List<EntityExpr> assocConditionFromTo = FastList.newInstance();
assocConditionFromTo.add(EntityCondition.makeCondition(prefix + "WorkEffortIdTo", EntityOperator.IN, workEffortIdSet));
if (UtilValidate.isNotEmpty(workEffortAssocTypeId)) {
assocConditionFromTo.add(EntityCondition.makeCondition(prefix + "WorkEffortAssocTypeId", EntityOperator.EQUALS, workEffortAssocTypeId));
}
assocConditionFromTo.add(EntityCondition.makeCondition(EntityCondition.makeCondition(prefix + "ThruDate", EntityOperator.EQUALS, null), EntityOperator.OR, EntityCondition.makeCondition(prefix + "ThruDate", EntityOperator.GREATER_THAN, workEffortSearchContext.nowTimestamp)));
assocConditionFromTo.add(EntityCondition.makeCondition(prefix + "FromDate", EntityOperator.LESS_THAN, workEffortSearchContext.nowTimestamp));
// do workEffortId = workEffortIdTo, workEffortIdFrom IN workEffortIdSet
entityAlias = "WFA" + workEffortSearchContext.index;
prefix = "wfa" + workEffortSearchContext.index;
workEffortSearchContext.index++;
workEffortSearchContext.dynamicViewEntity.addMemberEntity(entityAlias, "WorkEffortAssoc");
workEffortSearchContext.dynamicViewEntity.addAlias(entityAlias, prefix + "WorkEffortIdFrom", "workEffortIdFrom", null, null, null, null);
workEffortSearchContext.dynamicViewEntity.addAlias(entityAlias, prefix + "WorkEffortIdTo", "workEffortIdTo", null, null, null, null);
workEffortSearchContext.dynamicViewEntity.addAlias(entityAlias, prefix + "WorkEffortAssocTypeId", "workEffortAssocTypeId", null, null, null, null);
workEffortSearchContext.dynamicViewEntity.addAlias(entityAlias, prefix + "FromDate", "fromDate", null, null, null, null);
workEffortSearchContext.dynamicViewEntity.addAlias(entityAlias, prefix + "ThruDate", "thruDate", null, null, null, null);
workEffortSearchContext.dynamicViewEntity.addViewLink("WEFF", entityAlias, Boolean.TRUE, ModelKeyMap.makeKeyMapList("workEffortId","workEffortIdTo"));
List<EntityExpr> assocConditionToFrom = FastList.newInstance();
assocConditionToFrom.add(EntityCondition.makeCondition(prefix + "WorkEffortIdFrom", EntityOperator.IN, workEffortIdSet));
if (UtilValidate.isNotEmpty(workEffortAssocTypeId)) {
assocConditionToFrom.add(EntityCondition.makeCondition(prefix + "WorkEffortAssocTypeId", EntityOperator.EQUALS, workEffortAssocTypeId));
}
assocConditionToFrom.add(EntityCondition.makeCondition(EntityCondition.makeCondition(prefix + "ThruDate", EntityOperator.EQUALS, null), EntityOperator.OR, EntityCondition.makeCondition(prefix + "ThruDate", EntityOperator.GREATER_THAN, workEffortSearchContext.nowTimestamp)));
assocConditionToFrom.add(EntityCondition.makeCondition(prefix + "FromDate", EntityOperator.LESS_THAN, workEffortSearchContext.nowTimestamp));
// now create and add the combined constraint
workEffortSearchContext.entityConditionList.add(EntityCondition.makeCondition(EntityCondition.makeCondition(assocConditionFromTo, EntityOperator.AND), EntityOperator.OR, EntityCondition.makeCondition(assocConditionToFrom, EntityOperator.AND)));
// add in workEffortSearchConstraint, don't worry about the workEffortSearchResultId or constraintSeqId, those will be fill in later
workEffortSearchContext.workEffortSearchConstraintList.add(workEffortSearchContext.getDelegator().makeValue("WorkEffortSearchConstraint", UtilMisc.toMap("constraintName", constraintName, "infoString", this.workEffortId + "," + this.workEffortAssocTypeId, "includeSubWorkEfforts", this.includeSubWorkEfforts ? "Y" : "N")));
}
/** pretty print for log messages and even UI stuff */
@Override
public String prettyPrintConstraint(Delegator delegator, boolean detailed, Locale locale) {
GenericValue workEffort = null;
GenericValue workEffortAssocType = null;
try {
workEffort = delegator.findByPrimaryKeyCache("WorkEffort", UtilMisc.toMap("workEffortId", this.workEffortId));
workEffortAssocType = delegator.findByPrimaryKeyCache("WorkEffortAssocType", UtilMisc.toMap("workEffortAssocTypeId", this.workEffortAssocTypeId));
} catch (GenericEntityException e) {
Debug.logError(e, "Error looking up WorkEffortAssocConstraint pretty print info: " + e.toString(), module);
}
StringBuilder ppBuf = new StringBuilder();
ppBuf.append(UtilProperties.getMessage(resource, "WorkEffortAssoc", locale) + ": ");
if (workEffort != null) {
ppBuf.append(workEffort.getString("workEffortName"));
}
if (workEffort == null || detailed) {
ppBuf.append(" [");
ppBuf.append(workEffortId);
ppBuf.append("]");
}
if (UtilValidate.isNotEmpty(this.workEffortAssocTypeId)) {
if (workEffortAssocType != null) {
ppBuf.append(workEffortAssocType.getString("description"));
}
if (workEffortAssocType == null || detailed) {
ppBuf.append(" [");
ppBuf.append(workEffortAssocTypeId);
ppBuf.append("]");
}
}
if (this.includeSubWorkEfforts) {
ppBuf.append(" (").append(UtilProperties.getMessage(resource, "WorkEffortIncludeAllSubWorkEfforts", locale)).append(")");
}
return ppBuf.toString();
}
@Override
public boolean equals(Object obj) {
WorkEffortSearchConstraint psc = (WorkEffortSearchConstraint) obj;
if (psc instanceof WorkEffortAssocConstraint) {
WorkEffortAssocConstraint that = (WorkEffortAssocConstraint) psc;
if (this.includeSubWorkEfforts != that.includeSubWorkEfforts) {
return false;
}
if (this.workEffortId == null) {
if (that.workEffortId != null) {
return false;
}
} else {
if (!this.workEffortId.equals(that.workEffortId)) {
return false;
}
}
if (this.workEffortAssocTypeId == null) {
if (that.workEffortAssocTypeId != null) {
return false;
}
} else {
if (!this.workEffortAssocTypeId.equals(that.workEffortAssocTypeId)) {
return false;
}
}
return true;
} else {
return false;
}
}
}
@SuppressWarnings("serial")
public static class WorkEffortReviewConstraint extends WorkEffortSearchConstraint {
public static final String constraintName = "WorkEffortReview";
protected String reviewTextString;
public WorkEffortReviewConstraint(String reviewTextString) {
this.reviewTextString = reviewTextString;
}
@Override
public void addConstraint(WorkEffortSearchContext workEffortSearchContext) {
String entityAlias = "WFR" + workEffortSearchContext.index;
String prefix = "wfr" + workEffortSearchContext.index;
workEffortSearchContext.index++;
workEffortSearchContext.dynamicViewEntity.addMemberEntity(entityAlias, "WorkEffortReview");
workEffortSearchContext.dynamicViewEntity.addAlias(entityAlias, prefix + "ReviewText", "reviewText", null, null, null, null);
workEffortSearchContext.dynamicViewEntity.addViewLink("WEFF", entityAlias, Boolean.FALSE, ModelKeyMap.makeKeyMapList("workEffortId"));
workEffortSearchContext.entityConditionList.add(EntityCondition.makeCondition(EntityFunction.UPPER_FIELD(prefix + "ReviewText"), EntityOperator.LIKE, EntityFunction.UPPER("%" + reviewTextString + "%")));
Map<String, String> valueMap = UtilMisc.toMap("constraintName", constraintName, "infoString", this.reviewTextString);
workEffortSearchContext.workEffortSearchConstraintList.add(workEffortSearchContext.getDelegator().makeValue("WorkEffortSearchConstraint", valueMap));
}
/** pretty print for log messages and even UI stuff */
@Override
public String prettyPrintConstraint(Delegator delegator, boolean detailed, Locale locale) {
StringBuilder ppBuf = new StringBuilder();
ppBuf.append(UtilProperties.getMessage(resource, "WorkEffortReviews", locale) + ": \"");
ppBuf.append(this.reviewTextString).append("\", ").append(UtilProperties.getMessage(resource, "WorkEffortKeywordWhere", locale)).append(" ");
return ppBuf.toString();
}
@Override
public boolean equals(Object obj) {
WorkEffortSearchConstraint psc = (WorkEffortSearchConstraint) obj;
if (psc instanceof WorkEffortReviewConstraint) {
WorkEffortReviewConstraint that = (WorkEffortReviewConstraint) psc;
if (this.reviewTextString == null) {
if (that.reviewTextString != null) {
return false;
}
} else {
if (!this.reviewTextString.equals(that.reviewTextString)) {
return false;
}
}
return true;
} else {
return false;
}
}
}
@SuppressWarnings("serial")
public static class PartyAssignmentConstraint extends WorkEffortSearchConstraint {
public static final String constraintName = "PartyAssignment";
protected String partyId;
protected String roleTypeId;
public PartyAssignmentConstraint(String partyId, String roleTypeId) {
this.partyId = partyId;
this.roleTypeId = roleTypeId;
}
@Override
public void addConstraint(WorkEffortSearchContext workEffortSearchContext) {
// make index based values and increment
String entityAlias = "WEPA" + workEffortSearchContext.index;
String prefix = "wepa" + workEffortSearchContext.index;
workEffortSearchContext.index++;
workEffortSearchContext.dynamicViewEntity.addMemberEntity(entityAlias, "WorkEffortPartyAssignment");
workEffortSearchContext.dynamicViewEntity.addAlias(entityAlias, prefix + "PartyId", "partyId", null, null, null, null);
workEffortSearchContext.dynamicViewEntity.addAlias(entityAlias, prefix + "RoleTypeId", "roleTypeId", null, null, null, null);
workEffortSearchContext.dynamicViewEntity.addAlias(entityAlias, prefix + "FromDate", "fromDate", null, null, null, null);
workEffortSearchContext.dynamicViewEntity.addAlias(entityAlias, prefix + "ThruDate", "thruDate", null, null, null, null);
workEffortSearchContext.dynamicViewEntity.addViewLink("WEFF", entityAlias, Boolean.FALSE, ModelKeyMap.makeKeyMapList("workEffortId"));
workEffortSearchContext.entityConditionList.add(EntityCondition.makeCondition(prefix + "PartyId", EntityOperator.EQUALS, partyId));
workEffortSearchContext.entityConditionList.add(EntityCondition.makeCondition(EntityCondition.makeCondition(prefix + "ThruDate", EntityOperator.EQUALS, null), EntityOperator.OR, EntityCondition.makeCondition(prefix + "ThruDate", EntityOperator.GREATER_THAN, workEffortSearchContext.nowTimestamp)));
workEffortSearchContext.entityConditionList.add(EntityCondition.makeCondition(prefix + "FromDate", EntityOperator.LESS_THAN, workEffortSearchContext.nowTimestamp));
if (UtilValidate.isNotEmpty(this.roleTypeId)) {
workEffortSearchContext.entityConditionList.add(EntityCondition.makeCondition(prefix + "RoleTypeId", EntityOperator.EQUALS, roleTypeId));
}
// add in workEffortSearchConstraint, don't worry about the workEffortSearchResultId or constraintSeqId, those will be fill in later
workEffortSearchContext.workEffortSearchConstraintList.add(workEffortSearchContext.getDelegator().makeValue("WorkEffortSearchConstraint", UtilMisc.toMap("constraintName", constraintName, "infoString", this.partyId + "," + this.roleTypeId)));
}
@Override
public String prettyPrintConstraint(Delegator delegator, boolean detailed, Locale locale) {
GenericValue partyNameView = null;
GenericValue roleType = null;
try {
partyNameView = delegator.findByPrimaryKeyCache("PartyNameView", UtilMisc.toMap("partyId", partyId));
roleType = delegator.findByPrimaryKeyCache("RoleType", UtilMisc.toMap("roleTypeId", roleTypeId));
} catch (GenericEntityException e) {
Debug.logError(e, "Error finding PartyAssignmentConstraint information for constraint pretty print", module);
}
StringBuilder ppBuf = new StringBuilder();
ppBuf.append("WorkEffort Assignment: ");
if (partyNameView != null) {
if (UtilValidate.isNotEmpty(partyNameView.getString("firstName"))) {
ppBuf.append(partyNameView.getString("firstName"));
ppBuf.append(" ");
}
if (UtilValidate.isNotEmpty(partyNameView.getString("middleName"))) {
ppBuf.append(partyNameView.getString("middleName"));
ppBuf.append(" ");
}
if (UtilValidate.isNotEmpty(partyNameView.getString("lastName"))) {
ppBuf.append(partyNameView.getString("lastName"));
}
if (UtilValidate.isNotEmpty(partyNameView.getString("groupName"))) {
ppBuf.append(partyNameView.getString("groupName"));
}
} else {
ppBuf.append("[");
ppBuf.append(this.partyId);
ppBuf.append("] ");
}
if (roleType != null) {
ppBuf.append(roleType.getString("description"));
} else {
if (UtilValidate.isNotEmpty(this.roleTypeId)) {
ppBuf.append("[");
ppBuf.append(this.roleTypeId);
ppBuf.append("]");
}
}
return ppBuf.toString();
}
@Override
public boolean equals(Object obj) {
WorkEffortSearchConstraint psc = (WorkEffortSearchConstraint) obj;
if (psc instanceof PartyAssignmentConstraint) {
PartyAssignmentConstraint that = (PartyAssignmentConstraint) psc;
if (this.partyId == null) {
if (that.partyId != null) {
return false;
}
} else {
if (!this.partyId.equals(that.partyId)) {
return false;
}
}
if (this.roleTypeId == null) {
if (that.roleTypeId != null) {
return false;
}
} else {
if (!this.roleTypeId.equals(that.roleTypeId)) {
return false;
}
}
return true;
} else {
return false;
}
}
}
@SuppressWarnings("serial")
public static class ProductSetConstraint extends WorkEffortSearchConstraint {
public static final String constraintName = "ProductSet";
protected Set<String> productIdSet;
public ProductSetConstraint(Collection<String> productIdSet) {
this.productIdSet = UtilMisc.makeSetWritable(productIdSet);
}
@Override
public void addConstraint(WorkEffortSearchContext workEffortSearchContext) {
// make index based values and increment
String entityAlias = "WEGS" + workEffortSearchContext.index;
String prefix = "wegs" + workEffortSearchContext.index;
workEffortSearchContext.index++;
workEffortSearchContext.dynamicViewEntity.addMemberEntity(entityAlias, "WorkEffortGoodStandard");
workEffortSearchContext.dynamicViewEntity.addAlias(entityAlias, prefix + "ProductId", "productId", null, null, null, null);
workEffortSearchContext.dynamicViewEntity.addAlias(entityAlias, prefix + "FromDate", "fromDate", null, null, null, null);
workEffortSearchContext.dynamicViewEntity.addAlias(entityAlias, prefix + "ThruDate", "thruDate", null, null, null, null);
workEffortSearchContext.dynamicViewEntity.addViewLink("WEFF", entityAlias, Boolean.FALSE, ModelKeyMap.makeKeyMapList("workEffortId"));
workEffortSearchContext.entityConditionList.add(EntityCondition.makeCondition(prefix + "ProductId", EntityOperator.IN, productIdSet));
workEffortSearchContext.entityConditionList.add(EntityCondition.makeCondition(EntityCondition.makeCondition(prefix + "ThruDate", EntityOperator.EQUALS, null), EntityOperator.OR, EntityCondition.makeCondition(prefix + "ThruDate", EntityOperator.GREATER_THAN, workEffortSearchContext.nowTimestamp)));
workEffortSearchContext.entityConditionList.add(EntityCondition.makeCondition(prefix + "FromDate", EntityOperator.LESS_THAN, workEffortSearchContext.nowTimestamp));
// add in workEffortSearchConstraint, don't worry about the workEffortSearchResultId or constraintSeqId, those will be fill in later
StringBuilder productIdInfo = new StringBuilder();
Iterator<String> productIdIter = this.productIdSet.iterator();
while (productIdIter.hasNext()) {
String productId = productIdIter.next();
productIdInfo.append(productId);
if (productIdIter.hasNext()) {
productIdInfo.append(",");
}
}
workEffortSearchContext.workEffortSearchConstraintList.add(workEffortSearchContext.getDelegator().makeValue("WorkEffortSearchConstraint", UtilMisc.toMap("constraintName", constraintName, "infoString", productIdInfo.toString())));
}
@Override
public String prettyPrintConstraint(Delegator delegator, boolean detailed, Locale locale) {
StringBuilder infoOut = new StringBuilder();
try {
Iterator<String> productIdIter = this.productIdSet.iterator();
while (productIdIter.hasNext()) {
String productId = productIdIter.next();
GenericValue product = delegator.findByPrimaryKeyCache("Product", UtilMisc.toMap("productId", productId));
if (product == null) {
infoOut.append("[");
infoOut.append(productId);
infoOut.append("]");
} else {
infoOut.append(product.getString("productName"));
}
if (productIdIter.hasNext()) {
infoOut.append(", ");
}
}
} catch (GenericEntityException e) {
Debug.logError(e, "Error finding ProductSetConstraint information for constraint pretty print", module);
}
return infoOut.toString();
}
@Override
public boolean equals(Object obj) {
WorkEffortSearchConstraint psc = (WorkEffortSearchConstraint) obj;
if (psc instanceof ProductSetConstraint) {
ProductSetConstraint that = (ProductSetConstraint) psc;
if (this.productIdSet == null) {
if (that.productIdSet != null) {
return false;
}
} else {
if (!this.productIdSet.equals(that.productIdSet)) {
return false;
}
}
return true;
} else {
return false;
}
}
}
@SuppressWarnings("serial")
public static class KeywordConstraint extends WorkEffortSearchConstraint {
public static final String constraintName = "Keyword";
protected String keywordsString;
protected boolean anyPrefix;
protected boolean anySuffix;
protected boolean isAnd;
protected boolean removeStems;
public KeywordConstraint(String keywordsString, boolean anyPrefix, boolean anySuffix, Boolean removeStems, boolean isAnd) {
this.keywordsString = keywordsString;
this.anyPrefix = anyPrefix;
this.anySuffix = anySuffix;
this.isAnd = isAnd;
if (removeStems != null) {
this.removeStems = removeStems.booleanValue();
} else {
this.removeStems = UtilProperties.propertyValueEquals("keywordsearch", "remove.stems", "true");
}
}
public Set<String> makeFullKeywordSet(Delegator delegator) {
Set<String> keywordSet = KeywordSearchUtil.makeKeywordSet(this.keywordsString, null, true);
Set<String> fullKeywordSet = new TreeSet<String>();
// expand the keyword list according to the thesaurus and create a new set of keywords
for (String keyword: keywordSet) {
Set<String> expandedSet = new TreeSet<String>();
boolean replaceEntered = KeywordSearchUtil.expandKeywordForSearch(keyword, expandedSet, delegator);
fullKeywordSet.addAll(expandedSet);
if (!replaceEntered) {
fullKeywordSet.add(keyword);
}
}
return fullKeywordSet;
}
@Override
public void addConstraint(WorkEffortSearchContext workEffortSearchContext) {
// just make the fixed keyword lists and put them in the context
if (isAnd) {
// when isAnd is true we need to make a list of keyword sets where each set corresponds to one
//incoming/entered keyword and contains all of the expanded keywords plus the entered keyword if none of
//the expanded keywords are flagged as replacements; now the tricky part: each set should be or'ed together,
//but then the sets should be and'ed to produce the overall expression; create the SQL for this
//needs some work as the current method only support a list of and'ed words and a list of or'ed words, not
//a list of or'ed sets to be and'ed together
Set<String> keywordSet = KeywordSearchUtil.makeKeywordSet(this.keywordsString, null, true);
// expand the keyword list according to the thesaurus and create a new set of keywords
for (String keyword: keywordSet) {
Set<String> expandedSet = new TreeSet<String>();
boolean replaceEntered = KeywordSearchUtil.expandKeywordForSearch(keyword, expandedSet, workEffortSearchContext.getDelegator());
if (!replaceEntered) {
expandedSet.add(keyword);
}
Set<String> fixedSet = KeywordSearchUtil.fixKeywordsForSearch(expandedSet, anyPrefix, anySuffix, removeStems, isAnd);
Set<String> fixedKeywordSet = FastSet.newInstance();
fixedKeywordSet.addAll(fixedSet);
workEffortSearchContext.keywordFixedOrSetAndList.add(fixedKeywordSet);
}
} else {
// when isAnd is false, just add all of the new entries to the big list
Set<String> keywordFirstPass = makeFullKeywordSet(workEffortSearchContext.getDelegator()); // includes keyword expansion, etc
Set<String> keywordSet = KeywordSearchUtil.fixKeywordsForSearch(keywordFirstPass, anyPrefix, anySuffix, removeStems, isAnd);
workEffortSearchContext.orKeywordFixedSet.addAll(keywordSet);
}
// add in workEffortSearchConstraint, don't worry about the workEffortSearchResultId or constraintSeqId, those will be fill in later
Map<String, String> valueMap = UtilMisc.toMap("constraintName", constraintName, "infoString", this.keywordsString);
valueMap.put("anyPrefix", this.anyPrefix ? "Y" : "N");
valueMap.put("anySuffix", this.anySuffix ? "Y" : "N");
valueMap.put("isAnd", this.isAnd ? "Y" : "N");
valueMap.put("removeStems", this.removeStems ? "Y" : "N");
workEffortSearchContext.workEffortSearchConstraintList.add(workEffortSearchContext.getDelegator().makeValue("WorkEffortSearchConstraint", valueMap));
}
/** pretty print for log messages and even UI stuff */
@Override
public String prettyPrintConstraint(Delegator delegator, boolean detailed, Locale locale) {
StringBuilder ppBuf = new StringBuilder();
ppBuf.append(UtilProperties.getMessage(resource, "WorkEffortKeywords", locale)).append(": \"");
ppBuf.append(this.keywordsString).append("\", ").append(UtilProperties.getMessage(resource, "WorkEffortKeywordWhere", locale)).append(" ");
ppBuf.append(isAnd ? UtilProperties.getMessage(resource, "WorkEffortKeywordAllWordsMatch", locale) : UtilProperties.getMessage(resource, "WorkEffortKeywordAnyWordMatches", locale));
return ppBuf.toString();
}
@Override
public boolean equals(Object obj) {
WorkEffortSearchConstraint psc = (WorkEffortSearchConstraint) obj;
if (psc instanceof KeywordConstraint) {
KeywordConstraint that = (KeywordConstraint) psc;
if (this.anyPrefix != that.anyPrefix) {
return false;
}
if (this.anySuffix != that.anySuffix) {
return false;
}
if (this.isAnd != that.isAnd) {
return false;
}
if (this.removeStems != that.removeStems) {
return false;
}
if (this.keywordsString == null) {
if (that.keywordsString != null) {
return false;
}
} else {
if (!this.keywordsString.equals(that.keywordsString)) {
return false;
}
}
return true;
} else {
return false;
}
}
}
@SuppressWarnings("serial")
public static class LastUpdatedRangeConstraint extends WorkEffortSearchConstraint {
public static final String constraintName = "LastUpdatedRange";
protected Timestamp fromDate;
protected Timestamp thruDate;
public LastUpdatedRangeConstraint(Timestamp fromDate, Timestamp thruDate) {
this.fromDate = fromDate;
this.thruDate = thruDate;
}
@Override
public void addConstraint(WorkEffortSearchContext workEffortSearchContext) {
workEffortSearchContext.dynamicViewEntity.addAlias("WEFF", "lastModifiedDate", "lastModifiedDate", null, null, null, null);
EntityConditionList<EntityExpr> dateConditions = null;
EntityExpr dateCondition=null;
if (fromDate !=null && thruDate!=null) {
dateConditions= EntityCondition.makeCondition(UtilMisc.toList(
EntityCondition.makeCondition("lastModifiedDate", EntityOperator.GREATER_THAN_EQUAL_TO, fromDate),
EntityCondition.makeCondition("lastModifiedDate", EntityOperator.LESS_THAN_EQUAL_TO, thruDate)), EntityOperator.AND);
} if (fromDate !=null) {
dateCondition=EntityCondition.makeCondition("lastModifiedDate", EntityOperator.GREATER_THAN_EQUAL_TO, fromDate);
} else if (thruDate != null) {
dateCondition = EntityCondition.makeCondition("lastModifiedDate", EntityOperator.LESS_THAN_EQUAL_TO, thruDate);
}
EntityConditionList<? extends EntityCondition> conditions = null;
if (fromDate !=null && thruDate!=null) {
conditions=EntityCondition.makeCondition(UtilMisc.toList(
dateConditions,
EntityCondition.makeCondition("lastModifiedDate", EntityOperator.EQUALS, null)),
EntityOperator.OR);
} else {
conditions=EntityCondition.makeCondition(UtilMisc.toList(
dateCondition,
EntityCondition.makeCondition("lastModifiedDate", EntityOperator.EQUALS, null)),
EntityOperator.OR);
}
workEffortSearchContext.entityConditionList.add(conditions);
// add in workEffortSearchConstraint, don't worry about the workEffortSearchResultId or constraintSeqId, those will be fill in later
workEffortSearchContext.workEffortSearchConstraintList.add(workEffortSearchContext.getDelegator().makeValue("WorkEffortSearchConstraint", UtilMisc.toMap("constraintName", constraintName, "infoString","fromDate : " + fromDate + " thruDate : " + thruDate)));
}
/** pretty print for log messages and even UI stuff */
@Override
public String prettyPrintConstraint(Delegator delegator, boolean detailed, Locale locale) {
StringBuilder ppBuf = new StringBuilder();
ppBuf.append(UtilProperties.getMessage(resource, "WorkEffortLastModified", locale)).append(": \"");
ppBuf.append(fromDate).append("-").append(thruDate).append("\", ").append(UtilProperties.getMessage(resource, "WorkEffortLastModified", locale)).append(" ");
return ppBuf.toString();
}
@Override
public boolean equals(Object obj) {
WorkEffortSearchConstraint psc = (WorkEffortSearchConstraint) obj;
if (psc instanceof LastUpdatedRangeConstraint) {
LastUpdatedRangeConstraint that = (LastUpdatedRangeConstraint) psc;
if (this.fromDate == null) {
if (that.fromDate != null) {
return false;
}
} else {
if (!this.fromDate.equals(that.fromDate)) {
return false;
}
}
if (this.thruDate == null) {
if (that.thruDate != null) {
return false;
}
} else {
if (!this.thruDate.equals(that.thruDate)) {
return false;
}
}
return true;
} else {
return false;
}
}
}
// ======================================================================
// Result Sort Classes
// ======================================================================
@SuppressWarnings("serial")
public static abstract class ResultSortOrder implements java.io.Serializable {
public ResultSortOrder() {
}
public abstract void setSortOrder(WorkEffortSearchContext workEffortSearchContext);
public abstract String getOrderName();
public abstract String prettyPrintSortOrder(boolean detailed, Locale locale);
public abstract boolean isAscending();
}
@SuppressWarnings("serial")
public static class SortKeywordRelevancy extends ResultSortOrder {
public SortKeywordRelevancy() {
}
@Override
public void setSortOrder(WorkEffortSearchContext workEffortSearchContext) {
if (workEffortSearchContext.includedKeywordSearch) {
// we have to check this in order to be sure that there is a totalRelevancy to sort by...
workEffortSearchContext.orderByList.add("-totalRelevancy");
workEffortSearchContext.fieldsToSelect.add("totalRelevancy");
}
}
@Override
public String getOrderName() {
return "KeywordRelevancy";
}
@Override
public String prettyPrintSortOrder(boolean detailed, Locale locale) {
return UtilProperties.getMessage(resource, "WorkEffortKeywordRelevancy", locale);
}
@Override
public boolean isAscending() {
return false;
}
}
@SuppressWarnings("serial")
public static class SortWorkEffortField extends ResultSortOrder {
protected String fieldName;
protected boolean ascending;
/** Some good field names to try might include:
* [workEffortName]
* [totalQuantityOrdered] for most popular or most purchased
* [lastModifiedDate]
*
* You can also include any other field on the WorkEffort entity.
*/
public SortWorkEffortField(String fieldName, boolean ascending) {
this.fieldName = fieldName;
this.ascending = ascending;
}
@Override
public void setSortOrder(WorkEffortSearchContext workEffortSearchContext) {
if (workEffortSearchContext.getDelegator().getModelEntity("WorkEffort").isField(fieldName)) {
workEffortSearchContext.dynamicViewEntity.addAlias("WEFF", fieldName);
}
if (ascending) {
workEffortSearchContext.orderByList.add("+" + fieldName);
} else {
workEffortSearchContext.orderByList.add("-" + fieldName);
}
workEffortSearchContext.fieldsToSelect.add(fieldName);
}
@Override
public String getOrderName() {
return "WorkEffortField:" + this.fieldName;
}
@Override
public String prettyPrintSortOrder(boolean detailed, Locale locale) {
if ("workEffortName".equals(this.fieldName)) {
return UtilProperties.getMessage(resource, "WorkEffortName", locale);
} else if ("totalQuantityOrdered".equals(this.fieldName)) {
return UtilProperties.getMessage(resource, "WorkEffortPopularityByOrders", locale);
} else if ("totalTimesViewed".equals(this.fieldName)) {
return UtilProperties.getMessage(resource, "WorkEffortPopularityByViews", locale);
} else if ("averageCustomerRating".equals(this.fieldName)) {
return UtilProperties.getMessage(resource, "WorkEffortCustomerRating", locale);
}
return this.fieldName;
}
@Override
public boolean isAscending() {
return this.ascending;
}
}
}