| /******************************************************************************* |
| * 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.apache.ofbiz.workeffort.workeffort; |
| |
| import java.sql.Timestamp; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.Map; |
| |
| import javax.servlet.http.HttpServletRequest; |
| import javax.servlet.http.HttpSession; |
| |
| import org.apache.ofbiz.base.util.Debug; |
| import org.apache.ofbiz.base.util.UtilGenerics; |
| import org.apache.ofbiz.base.util.UtilHttp; |
| import org.apache.ofbiz.base.util.UtilMisc; |
| import org.apache.ofbiz.base.util.UtilValidate; |
| import org.apache.ofbiz.entity.Delegator; |
| import org.apache.ofbiz.workeffort.workeffort.WorkEffortSearch.ResultSortOrder; |
| import org.apache.ofbiz.workeffort.workeffort.WorkEffortSearch.SortKeywordRelevancy; |
| import org.apache.ofbiz.workeffort.workeffort.WorkEffortSearch.WorkEffortSearchConstraint; |
| |
| public class WorkEffortSearchSession { |
| |
| public static final String module = WorkEffortSearchSession.class.getName(); |
| |
| @SuppressWarnings("serial") |
| public static class WorkEffortSearchOptions implements java.io.Serializable { |
| protected List<WorkEffortSearchConstraint> constraintList = null; |
| protected ResultSortOrder resultSortOrder = null; |
| protected Integer viewIndex = null; |
| protected Integer viewSize = null; |
| protected boolean changed = false; |
| public WorkEffortSearchOptions() { } |
| |
| /** Basic copy constructor */ |
| public WorkEffortSearchOptions(WorkEffortSearchOptions workEffortSearchOptions) { |
| this.constraintList = UtilMisc.makeListWritable(workEffortSearchOptions.constraintList); |
| this.resultSortOrder = workEffortSearchOptions.resultSortOrder; |
| this.viewIndex = workEffortSearchOptions.viewIndex; |
| this.viewSize = workEffortSearchOptions.viewSize; |
| this.changed = workEffortSearchOptions.changed; |
| } |
| |
| public List<WorkEffortSearchConstraint> getConstraintList() { |
| return this.constraintList; |
| } |
| public static List<WorkEffortSearchConstraint> getConstraintList(HttpSession session) { |
| return getWorkEffortSearchOptions(session).constraintList; |
| } |
| public static void addConstraint(WorkEffortSearchConstraint workEffortSearchConstraint, HttpSession session) { |
| WorkEffortSearchOptions workEffortSearchOptions = getWorkEffortSearchOptions(session); |
| if (workEffortSearchOptions.constraintList == null) { |
| workEffortSearchOptions.constraintList = new LinkedList<WorkEffortSearch.WorkEffortSearchConstraint>(); |
| } |
| if (!workEffortSearchOptions.constraintList.contains(workEffortSearchConstraint)) { |
| workEffortSearchOptions.constraintList.add(workEffortSearchConstraint); |
| workEffortSearchOptions.changed = true; |
| } |
| } |
| |
| public ResultSortOrder getResultSortOrder() { |
| if (this.resultSortOrder == null) { |
| this.resultSortOrder = new SortKeywordRelevancy(); |
| this.changed = true; |
| } |
| return this.resultSortOrder; |
| } |
| public static ResultSortOrder getResultSortOrder(HttpServletRequest request) { |
| WorkEffortSearchOptions workEffortSearchOptions = getWorkEffortSearchOptions(request.getSession()); |
| return workEffortSearchOptions.getResultSortOrder(); |
| } |
| public static void setResultSortOrder(ResultSortOrder resultSortOrder, HttpSession session) { |
| WorkEffortSearchOptions workEffortSearchOptions = getWorkEffortSearchOptions(session); |
| workEffortSearchOptions.resultSortOrder = resultSortOrder; |
| workEffortSearchOptions.changed = true; |
| } |
| |
| public static void clearSearchOptions(HttpSession session) { |
| WorkEffortSearchOptions workEffortSearchOptions = getWorkEffortSearchOptions(session); |
| workEffortSearchOptions.constraintList = null; |
| workEffortSearchOptions.resultSortOrder = null; |
| } |
| |
| public void clearViewInfo() { |
| this.viewIndex = null; |
| this.viewSize = null; |
| } |
| |
| /** |
| * @return Returns the viewIndex. |
| */ |
| public Integer getViewIndex() { |
| return viewIndex; |
| } |
| /** |
| * @param viewIndex The viewIndex to set. |
| */ |
| public void setViewIndex(Integer viewIndex) { |
| this.viewIndex = viewIndex; |
| } |
| /** |
| * @return Returns the viewSize. |
| */ |
| public Integer getViewSize() { |
| return viewSize; |
| } |
| /** |
| * @param viewSize The viewSize to set. |
| */ |
| public void setViewSize(Integer viewSize) { |
| this.viewSize = viewSize; |
| } |
| |
| public List<String> searchGetConstraintStrings(boolean detailed, Delegator delegator, Locale locale) { |
| List<WorkEffortSearchConstraint> workEffortSearchConstraintList = this.getConstraintList(); |
| List<String> constraintStrings = new LinkedList<String>(); |
| if (workEffortSearchConstraintList == null) { |
| return constraintStrings; |
| } |
| for (WorkEffortSearchConstraint workEffortSearchConstraint: workEffortSearchConstraintList) { |
| if (workEffortSearchConstraint == null) continue; |
| String constraintString = workEffortSearchConstraint.prettyPrintConstraint(delegator, detailed, locale); |
| if (UtilValidate.isNotEmpty(constraintString)) { |
| constraintStrings.add(constraintString); |
| } else { |
| constraintStrings.add("Description not available"); |
| } |
| } |
| return constraintStrings; |
| } |
| } |
| |
| public static WorkEffortSearchOptions getWorkEffortSearchOptions(HttpSession session) { |
| WorkEffortSearchOptions workEffortSearchOptions = (WorkEffortSearchOptions) session.getAttribute("_WORK_EFFORT_SEARCH_OPTIONS_CURRENT_"); |
| if (workEffortSearchOptions == null) { |
| workEffortSearchOptions = new WorkEffortSearchOptions(); |
| session.setAttribute("_WORK_EFFORT_SEARCH_OPTIONS_CURRENT_", workEffortSearchOptions); |
| } |
| return workEffortSearchOptions; |
| } |
| |
| public static void processSearchParameters(Map<String, Object> parameters, HttpServletRequest request) { |
| Boolean alreadyRun = (Boolean) request.getAttribute("processSearchParametersAlreadyRun"); |
| if (Boolean.TRUE.equals(alreadyRun)) { |
| return; |
| } else { |
| request.setAttribute("processSearchParametersAlreadyRun", Boolean.TRUE); |
| } |
| HttpSession session = request.getSession(); |
| boolean constraintsChanged = false; |
| |
| // clear search? by default yes, but if the clearSearch parameter is N then don't |
| String clearSearchString = (String) parameters.get("clearSearch"); |
| if (!"N".equals(clearSearchString)) { |
| searchClear(session); |
| constraintsChanged = true; |
| } else { |
| String removeConstraint = (String) parameters.get("removeConstraint"); |
| if (UtilValidate.isNotEmpty(removeConstraint)) { |
| try { |
| searchRemoveConstraint(Integer.parseInt(removeConstraint), session); |
| constraintsChanged = true; |
| } catch (Exception e) { |
| Debug.logError(e, "Error removing constraint [" + removeConstraint + "]", module); |
| } |
| } |
| } |
| |
| // add a Work Effort Review to the search |
| if (UtilValidate.isNotEmpty(parameters.get("SEARCH_STRING_REVIEW_TEXT"))) { |
| String reviewText = (String) parameters.get("SEARCH_STRING_REVIEW_TEXT"); |
| searchAddConstraint(new WorkEffortSearch.WorkEffortReviewConstraint(reviewText), session); |
| constraintsChanged = true; |
| } |
| // add a Work Effort Assoc Type to the search |
| if (UtilValidate.isNotEmpty(parameters.get("SEARCH_WORK_EFFORT_ID"))) { |
| String workEffortId=(String) parameters.get("SEARCH_WORK_EFFORT_ID"); |
| String workEffortAssocTypeId=(String) parameters.get("workEffortAssocTypeId"); |
| boolean includeAllSubWorkEfforts =!"N".equalsIgnoreCase((String) parameters.get("SEARCH_SUB_WORK_EFFORTS")); |
| searchAddConstraint(new WorkEffortSearch.WorkEffortAssocConstraint(workEffortId,workEffortAssocTypeId,includeAllSubWorkEfforts), session); |
| constraintsChanged = true; |
| } |
| // add a Work Effort Party Assignment to the search |
| if (UtilValidate.isNotEmpty(parameters.get("partyId"))) { |
| String partyId=(String) parameters.get("partyId"); |
| String roleTypeId=(String) parameters.get("roleTypeId"); |
| searchAddConstraint(new WorkEffortSearch.PartyAssignmentConstraint(partyId,roleTypeId), session); |
| constraintsChanged = true; |
| } |
| |
| // add a Product Set to the search |
| if (UtilValidate.isNotEmpty(parameters.get("productId_1"))) { |
| List<String> productSet = new LinkedList<String>(); |
| productSet.add((String) parameters.get("productId_1")); |
| if (UtilValidate.isNotEmpty(parameters.get("productId_2"))) { |
| productSet.add((String) parameters.get("productId_2")); |
| } |
| searchAddConstraint(new WorkEffortSearch.ProductSetConstraint(productSet), session); |
| constraintsChanged = true; |
| } |
| |
| // add a WorkEfort fromDate thruDate to the search |
| if (UtilValidate.isNotEmpty(parameters.get("fromDate")) || UtilValidate.isNotEmpty(parameters.get("thruDate"))) { |
| Timestamp fromDate =null; |
| if (UtilValidate.isNotEmpty(parameters.get("fromDate"))) { |
| fromDate=Timestamp.valueOf((String) parameters.get("fromDate")); |
| } |
| |
| Timestamp thruDate = null; |
| if (UtilValidate.isNotEmpty(parameters.get("thruDate"))) { |
| thruDate = Timestamp.valueOf((String) parameters.get("thruDate")); |
| } |
| searchAddConstraint(new WorkEffortSearch.LastUpdatedRangeConstraint(fromDate,thruDate), session); |
| constraintsChanged = true; |
| } |
| |
| // if keywords were specified, add a constraint for them |
| if (UtilValidate.isNotEmpty(parameters.get("SEARCH_STRING"))) { |
| String keywordString = (String) parameters.get("SEARCH_STRING"); |
| String searchOperator = (String) parameters.get("SEARCH_OPERATOR"); |
| // defaults to true/Y, ie anything but N is true/Y |
| boolean anyPrefixSuffix = !"N".equals(parameters.get("SEARCH_ANYPRESUF")); |
| searchAddConstraint(new WorkEffortSearch.KeywordConstraint(keywordString, anyPrefixSuffix, anyPrefixSuffix, null, "AND".equals(searchOperator)), session); |
| constraintsChanged = true; |
| } |
| // set the sort order |
| String sortOrder = (String) parameters.get("sortOrder"); |
| String sortAscending = (String) parameters.get("sortAscending"); |
| boolean ascending = !"N".equals(sortAscending); |
| if (sortOrder != null) { |
| if (sortOrder.equals("SortKeywordRelevancy")) { |
| searchSetSortOrder(new WorkEffortSearch.SortKeywordRelevancy(), session); |
| } else if (sortOrder.startsWith("SortWorkEffortField:")) { |
| String fieldName = sortOrder.substring("SortWorkEffortField:".length()); |
| searchSetSortOrder(new WorkEffortSearch.SortWorkEffortField(fieldName, ascending), session); |
| } |
| } |
| |
| WorkEffortSearchOptions workEffortSearchOptions = getWorkEffortSearchOptions(session); |
| if (constraintsChanged) { |
| // query changed, clear out the VIEW_INDEX & VIEW_SIZE |
| workEffortSearchOptions.clearViewInfo(); |
| } |
| |
| String viewIndexStr = (String) parameters.get("VIEW_INDEX"); |
| if (UtilValidate.isNotEmpty(viewIndexStr)) { |
| try { |
| workEffortSearchOptions.setViewIndex(Integer.valueOf(viewIndexStr)); |
| } catch (Exception e) { |
| Debug.logError(e, "Error formatting VIEW_INDEX, setting to 0", module); |
| // we could just do nothing here, but we know something was specified so we don't want to use the previous value from the session |
| workEffortSearchOptions.setViewIndex(Integer.valueOf(0)); |
| } |
| } |
| |
| String viewSizeStr = (String) parameters.get("VIEW_SIZE"); |
| if (UtilValidate.isNotEmpty(viewSizeStr)) { |
| try { |
| workEffortSearchOptions.setViewSize(Integer.valueOf(viewSizeStr)); |
| } catch (Exception e) { |
| Debug.logError(e, "Error formatting VIEW_SIZE, setting to 20", module); |
| workEffortSearchOptions.setViewSize(Integer.valueOf(20)); |
| } |
| } |
| } |
| |
| public static void searchAddConstraint(WorkEffortSearchConstraint workEffortSearchConstraint, HttpSession session) { |
| WorkEffortSearchOptions.addConstraint(workEffortSearchConstraint, session); |
| } |
| public static void searchSetSortOrder(ResultSortOrder resultSortOrder, HttpSession session) { |
| WorkEffortSearchOptions.setResultSortOrder(resultSortOrder, session); |
| } |
| public static List<WorkEffortSearchOptions> getSearchOptionsHistoryList(HttpSession session) { |
| List<WorkEffortSearchOptions> optionsHistoryList = UtilGenerics.checkList(session.getAttribute("_WORK_EFFORT_SEARCH_OPTIONS_HISTORY_")); |
| if (optionsHistoryList == null) { |
| optionsHistoryList = new LinkedList<WorkEffortSearchSession.WorkEffortSearchOptions>(); |
| session.setAttribute("_WORK_EFFORT_SEARCH_OPTIONS_HISTORY_", optionsHistoryList); |
| } |
| return optionsHistoryList; |
| } |
| |
| public static List<String> searchGetConstraintStrings(boolean detailed, HttpSession session, Delegator delegator) { |
| Locale locale = UtilHttp.getLocale(session); |
| WorkEffortSearchOptions workEffortSearchOptions = getWorkEffortSearchOptions(session); |
| return workEffortSearchOptions.searchGetConstraintStrings(detailed, delegator, locale); |
| } |
| public static String searchGetSortOrderString(boolean detailed, HttpServletRequest request) { |
| Locale locale = UtilHttp.getLocale(request); |
| ResultSortOrder resultSortOrder = WorkEffortSearchOptions.getResultSortOrder(request); |
| if (resultSortOrder == null) return ""; |
| return resultSortOrder.prettyPrintSortOrder(detailed, locale); |
| } |
| public static void checkSaveSearchOptionsHistory(HttpSession session) { |
| WorkEffortSearchOptions workEffortSearchOptions = WorkEffortSearchSession.getWorkEffortSearchOptions(session); |
| // if the options have changed since the last search, add it to the beginning of the search options history |
| if (workEffortSearchOptions.changed) { |
| List<WorkEffortSearchOptions> optionsHistoryList = WorkEffortSearchSession.getSearchOptionsHistoryList(session); |
| optionsHistoryList.add(0, new WorkEffortSearchOptions(workEffortSearchOptions)); |
| workEffortSearchOptions.changed = false; |
| } |
| } |
| public static void searchRemoveConstraint(int index, HttpSession session) { |
| List<WorkEffortSearchConstraint> workEffortSearchConstraintList = WorkEffortSearchOptions.getConstraintList(session); |
| if (workEffortSearchConstraintList == null) { |
| return; |
| } else if (index >= workEffortSearchConstraintList.size()) { |
| return; |
| } else { |
| workEffortSearchConstraintList.remove(index); |
| } |
| } |
| public static void searchClear(HttpSession session) { |
| WorkEffortSearchOptions.clearSearchOptions(session); |
| } |
| } |
