/**
    * Copyright 2005-2015 The Kuali Foundation
    *
    * Licensed under the Educational Community 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.opensource.org/licenses/ecl2.php
    *
   * 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.kuali.rice.krad.lookup;
  
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.commons.lang.StringUtils;
  import org.kuali.rice.core.api.mo.common.active.Inactivatable;
  import org.kuali.rice.coreservice.framework.CoreFrameworkServiceLocator;
  import org.kuali.rice.kim.api.identity.Person;
  import org.kuali.rice.krad.datadictionary.AttributeDefinition;
  import org.kuali.rice.krad.datadictionary.parse.BeanTag;
  import org.kuali.rice.krad.datadictionary.parse.BeanTagAttribute;
  import org.kuali.rice.krad.service.KRADServiceLocatorWeb;
  import org.kuali.rice.krad.uif.UifConstants;
  import org.kuali.rice.krad.uif.UifConstants.ViewType;
  import org.kuali.rice.krad.uif.UifParameters;
  import org.kuali.rice.krad.uif.UifPropertyPaths;
  import org.kuali.rice.krad.uif.component.Component;
  import org.kuali.rice.krad.uif.component.RequestParameter;
  import org.kuali.rice.krad.uif.container.CollectionGroup;
  import org.kuali.rice.krad.uif.container.Group;
  import org.kuali.rice.krad.uif.control.Control;
  import org.kuali.rice.krad.uif.control.FilterableLookupCriteriaControl;
  import org.kuali.rice.krad.uif.control.FilterableLookupCriteriaControlPostData;
  import org.kuali.rice.krad.uif.control.TextAreaControl;
  import org.kuali.rice.krad.uif.control.TextControl;
  import org.kuali.rice.krad.uif.element.Action;
  import org.kuali.rice.krad.uif.element.Message;
  import org.kuali.rice.krad.uif.field.FieldGroup;
  import org.kuali.rice.krad.uif.field.InputField;
  import org.kuali.rice.krad.uif.layout.TableLayoutManager;
  import org.kuali.rice.krad.uif.lifecycle.ViewLifecycle;
  import org.kuali.rice.krad.uif.lifecycle.ViewLifecycleRestriction;
  import org.kuali.rice.krad.uif.lifecycle.ViewLifecycleUtils;
  import org.kuali.rice.krad.uif.lifecycle.ViewPostMetadata;
  import org.kuali.rice.krad.uif.lifecycle.initialize.AssignIdsTask;
  import org.kuali.rice.krad.uif.util.ComponentFactory;
  import org.kuali.rice.krad.uif.util.ComponentUtils;
  import org.kuali.rice.krad.uif.util.LifecycleElement;
  import org.kuali.rice.krad.uif.view.FormView;
  import org.kuali.rice.krad.util.GlobalVariables;
  import org.kuali.rice.krad.util.KRADConstants;
  
  /**
   * View type for lookups.
   *
   * <p>Supports doing a search against a data object class or performing a more advanced query. The view
   * type is primarily made up of two groups, the search (or criteria) group and the results group. Many
   * options are supported on the view to enable/disable certain features, like what actions are available
   * on the search results.</p>
   *
   * <p>Works in conjunction with {@link org.kuali.rice.krad.lookup.Lookupable} which customizes the view and
   * carries out the business functionality</p>
   *
   * @author Kuali Rice Team (rice.collab@kuali.org)
   */
  @BeanTag(name = "lookupView", parent = "Uif-LookupView")
  public class LookupView extends FormView {
  
      private static final long serialVersionUID = 716926008488403616L;
  
      private Class<?> dataObjectClass;
  
      private List<Component> criteriaFields;
      private Group criteriaGroup;
  
      @RequestParameter
      private boolean hideCriteriaOnSearch;
  
      private List<Component> resultFields;
      private CollectionGroup resultsGroup;
  
      private List<String> defaultSortAttributeNames;
      private boolean defaultSortAscending;
  
      @RequestParameter
      private Boolean renderReturnLink;
  
      @RequestParameter
      private boolean renderResultActions;
  
     @RequestParameter
     private Boolean renderMaintenanceLinks;
 
     @RequestParameter
     private boolean multipleValuesSelect;
 
     @RequestParameter
     private boolean renderLookupCriteria;
 
     @RequestParameter
     private boolean renderCriteriaActions;
 
     private Integer resultSetLimit;
     private Integer multipleValuesSelectResultSetLimit;
 
     private String maintenanceUrlMapping;
 
     private FieldGroup rangeFieldGroupPrototype;
     private Message rangedToMessage;
 
     private boolean autoAddActiveCriteria;
 
     private List<String> additionalSecurePropertyNames;
 
     public LookupView() {
         super();
 
         setViewTypeName(ViewType.LOOKUP);
 
         defaultSortAscending = true;
         autoAddActiveCriteria = true;
         renderLookupCriteria = true;
         renderCriteriaActions = true;
         renderResultActions = true;
 
         additionalSecurePropertyNames = new ArrayList<String>();
     }
 
     /**
      * Initializes Lookupable with data object class and sets the abstractTypeClasses map for the
      * lookup object path.
      *
      * {@inheritDoc}
      */
     @Override
     public void performInitialization(Object model) {
         // init the view helper with the data object class
         Lookupable lookupable = (Lookupable) getViewHelperService();
         lookupable.setDataObjectClass(dataObjectClass);
 
         initializeGroups();
 
         super.performInitialization(model);
 
         getObjectPathToConcreteClassMapping().put(UifPropertyPaths.LOOKUP_CRITERIA, getDataObjectClass());
         if (StringUtils.isNotBlank(getDefaultBindingObjectPath())) {
             getObjectPathToConcreteClassMapping().put(getDefaultBindingObjectPath(), getDataObjectClass());
         }
     }
 
     /**
      * Reads the convenience render flags and sets the corresponding component property, processing the criteria
      * fields for any adjustments, and invokes the lookup authorizer to determine whether maintenance links should
      * be shown.
      *
      * {@inheritDoc}
      */
     @Override
     public void performApplyModel(Object model, LifecycleElement parent) {
         LookupForm lookupForm = (LookupForm) model;
 
         // don't render criteria group footer/actions
         if (!renderCriteriaActions || hideCriteriaOnSearch) {
             criteriaGroup.getFooter().setRender(false);
         }
 
         // don't render criteria if not supposed to or (hide on search results and displaying the results)
         if (!renderLookupCriteria || (hideCriteriaOnSearch && lookupForm.isDisplayResults())) {
             criteriaGroup.setRender(false);
         }
 
         // if hide on search results and not displaying search results don't render results
         if (hideCriteriaOnSearch && !lookupForm.isDisplayResults()) {
             resultsGroup.setRender(false);
         }
 
         boolean returnLinkAllowed = false;
         boolean maintenanceLinksAllowed = false;
 
         // neither return nor maintenance links are shown for multi-value select
         if (!multipleValuesSelect) {
             // if coming from a quickfinder we will show the return URL
             if ((lookupForm.getInitialRequestParameters() != null) && lookupForm.getInitialRequestParameters()
                     .containsKey(UifParameters.CONVERSION_FIELDS)) {
                 returnLinkAllowed = true;
             } else {
                 maintenanceLinksAllowed = true;
             }
         } else {
             renderResultActions = false;
         }
 
         // only override view properties if they were not manually configured
         if (renderReturnLink == null) {
             renderReturnLink = returnLinkAllowed;
         }
 
         if (renderMaintenanceLinks == null) {
             renderMaintenanceLinks = maintenanceLinksAllowed;
         }
 
         // if maintenance links enabled, verify the user had permission
         if (renderMaintenanceLinks) {
             LookupViewAuthorizerBase lookupAuthorizer = (LookupViewAuthorizerBase) getAuthorizer();
 
             Person user = GlobalVariables.getUserSession().getPerson();
             renderMaintenanceLinks = lookupAuthorizer.canInitiateMaintenanceDocument(getDataObjectClass().getName(),
                     user);
         }
 
         // autoTruncateColumns: use system wide lookup result configuration if not specified
         if (this.getResultsGroup().getLayoutManager() instanceof TableLayoutManager) {
             TableLayoutManager resultsTableLayoutManager =
                     (TableLayoutManager) this.getResultsGroup().getLayoutManager();
             if (resultsTableLayoutManager.isAutoTruncateColumns() == null) {
                 resultsTableLayoutManager.setAutoTruncateColumns(
                         CoreFrameworkServiceLocator.getParameterService().getParameterValueAsBoolean(
                                 KRADConstants.KRAD_NAMESPACE, KRADConstants.DetailTypes.LOOKUP_PARM_DETAIL_TYPE,
                                 KRADConstants.SystemGroupParameterNames.AUTO_TRUNCATE_COLUMNS, false));
             }
         }
 
         convertLookupCriteriaFields(criteriaGroup);
 
         super.performApplyModel(model, parent);
     }
 
     /**
      * Forces session persistence on the criteria fields so the search criteria can be validated on post.
      *
      * {@inheritDoc}
      */
     @Override
     public void performFinalize(Object model, LifecycleElement parent) {
         super.performFinalize(model, parent);
 
         LookupForm lookupForm = (LookupForm) model;
         String viewId = lookupForm.getViewId();
 
         Map<String, FilterableLookupCriteriaControlPostData> filterableLookupCriteria =
                 new HashMap<String, FilterableLookupCriteriaControlPostData>();
 
         List<InputField> fields = ViewLifecycleUtils.getElementsOfTypeDeep(criteriaGroup, InputField.class);
 
         for (InputField field : fields) {
             field.setForceSessionPersistence(true);
 
             String propertyName = field.getPropertyName();
 
             if (field.getControl() instanceof FilterableLookupCriteriaControl) {
                 FilterableLookupCriteriaControl control = (FilterableLookupCriteriaControl) field.getControl();
                 filterableLookupCriteria.put(propertyName, control.getPostData(propertyName));
             }
         }
 
         ViewPostMetadata viewPostMetadata = ViewLifecycle.getViewPostMetadata();
         viewPostMetadata.addComponentPostData(viewId, UifConstants.PostMetadata.FILTERABLE_LOOKUP_CRITERIA,
                 filterableLookupCriteria);
 
         if (lookupForm.isReturnByScript()) {
             getAdditionalHiddenValues().put(UifParameters.RETURN_BY_SCRIPT, "true");
         }
 
         // if the lookup was called within a dialog then we want to add it to the action's parameters
         String dialogId = lookupForm.getShowDialogId();
         if (StringUtils.isNotBlank(dialogId)) {
             List<Action> actions = ViewLifecycleUtils.getElementsOfTypeDeep(getFooter().getItems(), Action.class);
 
             for (Action action : actions) {
                 action.addActionParameter(UifParameters.DIALOG_ID, dialogId);
             }
         } else {
             dialogId = lookupForm.getActionParamaterValue(UifParameters.DIALOG_ID);
             lookupForm.setShowDialogId(dialogId);
         }
     }
 
     /**
      * Adds the 'active' property criteria to the criteria fields if the BO is inactivatable and their is
      * not already a lookup field for the active property.
      */
     protected void addActiveCriteriaIfNecessary() {
         boolean isInactivatableClass = Inactivatable.class.isAssignableFrom(dataObjectClass);
 
         if (!autoAddActiveCriteria || !isInactivatableClass) {
             return;
         }
 
         boolean hasActiveCriteria = false;
         for (Component field : getCriteriaFields()) {
             if (((InputField) field).getPropertyName().equals(UifPropertyPaths.ACTIVE)) {
                 hasActiveCriteria = true;
             }
         }
 
         if (hasActiveCriteria) {
             return;
         }
 
         AttributeDefinition attributeDefinition =
                 KRADServiceLocatorWeb.getDataDictionaryService().getAttributeDefinition(dataObjectClass.getName(),
                         UifPropertyPaths.ACTIVE);
 
         LookupInputField activeLookupField;
         if (attributeDefinition == null) {
             activeLookupField = (LookupInputField) ComponentFactory.getNewComponentInstance(
                     ComponentFactory.LOOKUP_ACTIVE_INPUT_FIELD);
         } else {
             activeLookupField = (LookupInputField) ComponentFactory.getNewComponentInstance(
                     ComponentFactory.LOOKUP_INPUT_FIELD);
 
             activeLookupField.setPropertyName(UifPropertyPaths.ACTIVE);
             activeLookupField.copyFromAttributeDefinition(attributeDefinition);
         }
 
         getCriteriaFields().add(activeLookupField);
     }
 
     /**
      * Adds the list of criteria and result fields to their group prototypes, then adds the criteria and result
      * groups to the items for the view.
      */
     protected void initializeGroups() {
         if ((getCriteriaGroup() != null) && (getCriteriaGroup().getItems().isEmpty())) {
             getCriteriaGroup().setItems(getCriteriaFields());
         }
 
         if (getResultsGroup() != null) {
             if ((getResultsGroup().getItems().isEmpty()) && (getResultFields() != null)) {
                 getResultsGroup().setItems(getResultFields());
             }
 
             if (getResultsGroup().getCollectionObjectClass() == null) {
                 getResultsGroup().setCollectionObjectClass(getDataObjectClass());
             }
         }
 
         if (getItems().isEmpty()) {
             setItems(Arrays.asList(getCriteriaGroup(), getResultsGroup()));
         }
     }
 
     /**
      * Performs conversions of the lookup criteria fields within the given group's items.
      *
      * <p>Max lengths are removed on text controls so wildcards can be added. Ranged date fields are
      * converted to field groups with the from/to date fields</p>
      */
     protected void convertLookupCriteriaFields(Group lookupGroup) {
         @SuppressWarnings("unchecked")
         List<Component> criteriaGroupItems = (List<Component>) lookupGroup.getItems();
 
         // holds the index and range field group for replacement into the items
         HashMap<Integer, Component> dateRangeFieldMap = new HashMap<Integer, Component>();
 
         int rangeIndex = 0;
         for (Component component : criteriaGroupItems) {
             if (component == null) {
                 continue;
             }
 
             if (Group.class.isAssignableFrom(component.getClass())) {
                 convertLookupCriteriaFields((Group) component);
             } else if (FieldGroup.class.isAssignableFrom(component.getClass())) {
                 convertLookupCriteriaFields(((FieldGroup) component).getGroup());
             } else if (LookupInputField.class.isAssignableFrom(component.getClass())) {
                 LookupInputField lookupInputField = (LookupInputField) component;
 
                 // set the max length on the controls to allow for wildcards
                 Control control = lookupInputField.getControl();
 
                 if (control instanceof TextControl) {
                     ((TextControl) control).setMaxLength(null);
                 } else if (control instanceof TextAreaControl) {
                     ((TextAreaControl) control).setMaxLength(null);
                 }
 
                 if (lookupInputField.isRanged()) {
                     FieldGroup rangeFieldGroup = createDateRangeFieldGroup(lookupInputField);
 
                     dateRangeFieldMap.put(rangeIndex, rangeFieldGroup);
                 }
             }
 
             rangeIndex++;
         }
 
         // replace original fields with range field groups
         for (Integer index : dateRangeFieldMap.keySet()) {
             criteriaGroupItems.set(index, dateRangeFieldMap.get(index));
         }
 
         criteriaGroup.setItems(criteriaGroupItems);
     }
 
     /**
      * Creates a {@link FieldGroup} instance to replace the given lookup input field as a
      * date criteria range.
      *
      * <p>The field group is created by copying {@link LookupView#rangeFieldGroupPrototype}. This can be
      * used to configure how the field group will appear. In addition, the two lookup fields are separated
      * with a message that can be configured with {@link LookupView#rangedToMessage}</p>
      *
      * @param toDate lookup input field that field group should be build for
      * @return field group that contains a from and to lookup input field for searching a date range
      *
      * @see LookupView#rangeFieldGroupPrototype
      * @see LookupView#rangedToMessage
      */
     protected FieldGroup createDateRangeFieldGroup(LookupInputField toDate) {
         // Generate an ID when the "to date" field is out of the normal lifecycle flow
         if (toDate.getId() == null) {
             toDate.setId(AssignIdsTask.generateId(toDate, ViewLifecycle.getView()));
         }
 
         FieldGroup rangeFieldGroup = ComponentUtils.copy(getRangeFieldGroupPrototype());
 
         // Copy some properties from the "to date" field to the field group
         rangeFieldGroup.setFieldLabel(ComponentUtils.copy(toDate.getFieldLabel()));
         rangeFieldGroup.setPropertyExpressions(toDate.getPropertyExpressions());
         rangeFieldGroup.setProgressiveRender(toDate.getProgressiveRender());
         rangeFieldGroup.setProgressiveRenderViaAJAX(toDate.isProgressiveRenderViaAJAX());
         rangeFieldGroup.setConditionalRefresh(toDate.getConditionalRefresh());
         rangeFieldGroup.setRefreshWhenChangedPropertyNames(toDate.getRefreshWhenChangedPropertyNames());
         rangeFieldGroup.setForceSessionPersistence(true);
 
         // Reset some fields for the "to date" field
         toDate.getFieldLabel().setRender(false);
         toDate.setRefreshWhenChangedPropertyNames(null);
         toDate.setForceSessionPersistence(true);
 
         // Create a "from date" field from the "to date" field
         LookupInputField fromDate = ComponentUtils.copy(toDate,
                 KRADConstants.LOOKUP_DEFAULT_RANGE_SEARCH_LOWER_BOUND_LABEL);
         fromDate.getBindingInfo().setBindingName(
                 KRADConstants.LOOKUP_RANGE_LOWER_BOUND_PROPERTY_PREFIX + fromDate.getPropertyName());
         fromDate.setPropertyName(KRADConstants.LOOKUP_RANGE_LOWER_BOUND_PROPERTY_PREFIX + fromDate.getPropertyName());
         fromDate.setOrder(0);
 
         // add the criteria fields to the field group
         List<Component> fieldGroupItems = new ArrayList<Component>();
         fieldGroupItems.add(fromDate);
         fieldGroupItems.add(rangedToMessage);
         fieldGroupItems.add(toDate);
         rangeFieldGroup.setItems(fieldGroupItems);
 
         return rangeFieldGroup;
     }
 
     /**
      * Class for the data object the lookup applies to.
      *
      * <p>The object class name is used to pick up a dictionary entry which will feed the attribute field
      * definitions and other configuration. In addition it is to configure the
      * {@link org.kuali.rice.krad.lookup.Lookupable} which will carry out the search action</p>
      *
      * @return lookup data object class
      */
     @BeanTagAttribute(name = "dataObjectClass")
     public Class<?> getDataObjectClass() {
         return this.dataObjectClass;
     }
 
     /**
      * @see LookupView#getDataObjectClass()
      */
     public void setDataObjectClass(Class<?> dataObjectClass) {
         this.dataObjectClass = dataObjectClass;
     }
 
     /**
      * Convenience setter to configure the lookup data object class by class name.
      *
      * @param dataObjectClassName full class name for the lookup data object
      */
     public void setDataObjectClassName(String dataObjectClassName) {
         try {
             this.dataObjectClass = Class.forName(dataObjectClassName);
         } catch (ClassNotFoundException e) {
             throw new RuntimeException("Unable to set class for class name: " + dataObjectClassName, e);
         }
     }
 
     /**
      * Indicates whether a return value link should be rendered for each result row.
      *
      * <p>When the lookup is called from a view (using a {@link org.kuali.rice.krad.uif.widget.QuickFinder} the return
      * link can be returned to allow the user to return a value(s) for a selected row. Note, if this is not manually
      * set the framework will determine when the lookup is called from a quickfinder and turn this flag on</p>
      *
      * @return boolean true if the return link should be rendered for each result row, false if not
      */
     @BeanTagAttribute(name = "renderReturnLink")
     public Boolean isRenderReturnLink() {
         return this.renderReturnLink;
     }
 
     /**
      * @see LookupView#isRenderReturnLink()
      */
     public void setRenderReturnLink(Boolean renderReturnLink) {
         this.renderReturnLink = renderReturnLink;
     }
 
     /**
      * Indicates whether the actions column for the search results collection group should be rendered (default
      * is true).
      *
      * <p>Note this is a convenience property for setting the render property on the result collection group</p>
      *
      * @return boolean true if the result actions column should be rendered, false if not
      */
     @BeanTagAttribute(name = "isRenderResultActions")
     public boolean isRenderResultActions() {
         return this.renderResultActions;
     }
 
     /**
      * @see LookupView#isRenderResultActions()
      */
     public void setRenderResultActions(boolean renderResultActions) {
         this.renderResultActions = renderResultActions;
     }
 
     /**
      * Indicates whether links for maintenance actions (new, edit, copy, delete) should be rendered.
      *
      * <p>When this property is not manually set it will be enabled by the framework when a lookup is not invoked
      * from a quickfinder (for example a standard link from a menu). Regardless if the flag is manually enabled
      * or enabled by the framework, an additional authorization check will be performed to determine if the user
      * has initiate permission for the maintenance document associated with the lookup data object class. If not,
      * this flag will be disabled</p>
      *
      * @return boolean true if maintenance links should be rendered, false if not
      */
     @BeanTagAttribute(name = "renderMaintenanceLinks")
     public Boolean isRenderMaintenanceLinks() {
         return this.renderMaintenanceLinks;
     }
 
     /**
      * @see LookupView#isRenderMaintenanceLinks()
      */
     public void setRenderMaintenanceLinks(Boolean renderMaintenanceLinks) {
         this.renderMaintenanceLinks = renderMaintenanceLinks;
     }
 
     /**
      * Indicates whether multiple values select should be enabled for the lookup.
      *
      * <p>When set to true, the select field is enabled for the lookup results group that allows the user
      * to select one or more rows for returning. The framework will also set the {@link #isRenderReturnLink()}
      * and {@link #isRenderMaintenanceLinks()} properties to false (unless manually overridden)</p>
      *
      * @return true if multiple values select should be enabled, false otherwise
      */
     @BeanTagAttribute(name = "multipleValueSelect")
     public boolean isMultipleValuesSelect() {
         return multipleValuesSelect;
     }
 
     /**
      * @see LookupView#isMultipleValuesSelect()
      */
     public void setMultipleValuesSelect(boolean multipleValuesSelect) {
         this.multipleValuesSelect = multipleValuesSelect;
     }
 
     /**
      * List of fields that will be rendered for the lookup criteria.
      *
      * <p>This is a convenience property for setting the items in {@link #getCriteriaGroup()}, which is the
      * group the criteria for the lookup is rendered in. This property can be bypassed and the items set
      * directly in the criteria group (for more flexibility)</p>
      *
      * @return List of components to render as the lookup criteria
      */
     @ViewLifecycleRestriction
     @BeanTagAttribute(name = "criteriaFields", type = BeanTagAttribute.AttributeType.LISTBEAN)
     public List<Component> getCriteriaFields() {
         return this.criteriaFields;
     }
 
     /**
      * @see LookupView#getCriteriaFields()
      */
     public void setCriteriaFields(List<Component> criteriaFields) {
         this.criteriaFields = criteriaFields;
     }
 
     /**
      * Component {@link Group} instance to render as search criteria.
      *
      * <p>Fields that make up the criteria for the lookup will be rendered in this group. This can be used in a few
      * different ways:
      *
      * <ul>
      * <li>Set the group to have the desired layout, style, and other general group properties. Note this
      * is done in the base lookup view. The actual criteria fields can then be configured using
      * {@link #getCriteriaFields()}</li>
      * <li>Configure the criteria group entirely (ignoring criteria fields). This would allow you to do things
      * like have multiple groups for the criteria.</li>
      * </ul></p>
      *
      * <p>Note the footer for the criteria group can contain actions (such as search, clear, custom actions)</p>
      *
      * @return group instance that will hold the search criteria fields
      */
     @ViewLifecycleRestriction
     @BeanTagAttribute(name = "criteriaGroup", type = BeanTagAttribute.AttributeType.SINGLEBEAN)
     public Group getCriteriaGroup() {
         return this.criteriaGroup;
     }
 
     /**
      * @see LookupView#getCriteriaGroup()
      */
     public void setCriteriaGroup(Group criteriaGroup) {
         this.criteriaGroup = criteriaGroup;
     }
 
     public boolean isHideCriteriaOnSearch() {
         return hideCriteriaOnSearch;
     }
 
     public void setHideCriteriaOnSearch(boolean hideCriteriaOnSearch) {
         this.hideCriteriaOnSearch = hideCriteriaOnSearch;
     }
 
     /**
      * List of fields that will be rendered for the result collection group, each field will be a column
      * (assuming table layout is used).
      *
      * <p>This is a convenience property for setting the items in {@link #getResultsGroup()}, which is the
      * collection group the results for the lookup is rendered in. This property can be bypassed and the items set
      * directly in the results group (for more flexibility)</p>
      *
      * @return List of components to render in the results group
      */
     @ViewLifecycleRestriction
     @BeanTagAttribute(name = "resultFields", type = BeanTagAttribute.AttributeType.LISTBEAN)
     public List<Component> getResultFields() {
         return this.resultFields;
     }
 
     /**
      * @see LookupView#getResultFields()
      */
     public void setResultFields(List<Component> resultFields) {
         this.resultFields = resultFields;
     }
 
     /**
      * Component {@link CollectionGroup} instance to render for the lookup results.
      *
      * <p>After a search is performed, the resulting data objects will be rendered in this collection group. This
      * collection group can be used in two ways:
      *
      * <ul>
      * <li>Set the desired layout, style, and other general collection group properties. Note this is done
      * in the base lookup view. Then the actual fields that are rendered in the collection group can be
      * configured using {@link #getResultFields()}</li>
      * <li>Configure the results group entirely (ignoring result fields)</li>
      * </ul></p>
      *
      * <p>Note actions that are presented for the results can be configured using the
      * {@link org.kuali.rice.krad.uif.container.CollectionGroup#getLineActions()} property</p>
      *
      * @return collection group instance to render for the lookup results
      */
     @ViewLifecycleRestriction
     @BeanTagAttribute(name = "resultsGroup", type = BeanTagAttribute.AttributeType.SINGLEBEAN)
     public CollectionGroup getResultsGroup() {
         return this.resultsGroup;
     }
 
     /**
      * @see LookupView#getResultsGroup()
      */
     public void setResultsGroup(CollectionGroup resultsGroup) {
         this.resultsGroup = resultsGroup;
     }
 
     /**
      * List of property names on the configured data object class that will be used to perform the initial
      * sorting of the search results.
      *
      * @return list of property names valid for the configured data object class
      *
      * @see LookupView#isDefaultSortAscending()
      */
     @BeanTagAttribute(name = "defaultSortAttributeNames", type = BeanTagAttribute.AttributeType.LISTVALUE)
     public List<String> getDefaultSortAttributeNames() {
         return this.defaultSortAttributeNames;
     }
 
     /**
      * @see LookupView#getDefaultSortAttributeNames()
      */
     public void setDefaultSortAttributeNames(List<String> defaultSortAttributeNames) {
         this.defaultSortAttributeNames = defaultSortAttributeNames;
     }
 
     /**
      * Indicates whether the initial sort performed using {@link #getDefaultSortAttributeNames()} is done based
      * on ascending or descending order (default is true, ascending).
      *
      * @return boolean true if ascending sort should be performed, false if descending sort should be
      * performed
      */
     @BeanTagAttribute(name = "defaultSortAscending")
     public boolean isDefaultSortAscending() {
         return this.defaultSortAscending;
     }
 
     /**
      * @see LookupView#isDefaultSortAscending()
      */
     public void setDefaultSortAscending(boolean defaultSortAscending) {
         this.defaultSortAscending = defaultSortAscending;
     }
 
     /**
      * Retrieves the maximum number of records that will be listed as a result of the lookup search.
      *
      * @return Integer result set limit
      */
     @BeanTagAttribute(name = "resultSetLimit")
     public Integer getResultSetLimit() {
         return resultSetLimit;
     }
 
     /**
      * @see LookupView#getResultSetLimit()
      */
     public void setResultSetLimit(Integer resultSetLimit) {
         this.resultSetLimit = resultSetLimit;
     }
 
     /**
      * Retrieves the maximum number of records that will be listed as a result of the multiple
      * values select lookup search.
      *
      * @return multiple values select result set limit
      */
     @BeanTagAttribute(name = "multipleValuesSelectResultSetLimit")
     public Integer getMultipleValuesSelectResultSetLimit() {
         return multipleValuesSelectResultSetLimit;
     }
 
     /**
      * @see LookupView#getMultipleValuesSelectResultSetLimit()
      */
     public void setMultipleValuesSelectResultSetLimit(Integer multipleValuesSelectResultSetLimit) {
         this.multipleValuesSelectResultSetLimit = multipleValuesSelectResultSetLimit;
     }
 
     /**
      * String that maps to the maintenance controller for the maintenance document (if any) associated with the
      * lookup data object class.
      *
      * <p>Mapping will be used to build the maintenance action links (such as edit, copy, and new). If not given, the
      * default maintenance mapping will be used</p>
      *
      * @return mapping string
      */
     @BeanTagAttribute(name = "maintenanceUrlMapping")
     public String getMaintenanceUrlMapping() {
         return maintenanceUrlMapping;
     }
 
     /**
      * @see LookupView#getMaintenanceUrlMapping()
      */
     public void setMaintenanceUrlMapping(String maintenanceUrlMapping) {
         this.maintenanceUrlMapping = maintenanceUrlMapping;
     }
 
     /**
      * Indicates whether the action buttons like search in the criteria group footer should be rendered,
      * defaults to true.
      *
      * @return boolean true if the criteria actions should be rendered, false if not
      */
     public boolean isRenderCriteriaActions() {
         return renderCriteriaActions;
     }
 
     /**
      * @see LookupView#isRenderCriteriaActions()
      */
     public void setRenderCriteriaActions(boolean renderCriteriaActions) {
         this.renderCriteriaActions = renderCriteriaActions;
     }
 
     /**
      * Indicates whether the lookup criteria group should be rendered, default to true.
      *
      * <p>Hiding the criteria group can be useful in cases where the criteria is passed in through the request and
      * also the search is executed on the initial request</p>
      *
      * @return boolean true if criteria group should be rendered, false if not
      */
     public boolean isRenderLookupCriteria() {
         return renderLookupCriteria;
     }
 
     /**
      * @see LookupView#isRenderLookupCriteria()
      */
     public void setRenderLookupCriteria(boolean renderLookupCriteria) {
         this.renderLookupCriteria = renderLookupCriteria;
     }
 
     /**
      * Field group prototype that will be copied to create any date range field groups.
      *
      * @return field group instance to use for creating range field groups
      */
     @ViewLifecycleRestriction(UifConstants.ViewPhases.INITIALIZE)
     public FieldGroup getRangeFieldGroupPrototype() {
         return rangeFieldGroupPrototype;
     }
 
     /**
      * @see LookupView#getRangeFieldGroupPrototype()
      */
     public void setRangeFieldGroupPrototype(FieldGroup rangeFieldGroupPrototype) {
         this.rangeFieldGroupPrototype = rangeFieldGroupPrototype;
     }
 
     /**
      * Component {@link Message} instance to render between the range criteria fields within a range
      * field group.
      *
      * @return message instance for range field group
      */
     @ViewLifecycleRestriction(UifConstants.ViewPhases.INITIALIZE)
     public Message getRangedToMessage() {
         return rangedToMessage;
     }
 
     /**
      * @see LookupView#getRangedToMessage()
      */
     public void setRangedToMessage(Message rangedToMessage) {
         this.rangedToMessage = rangedToMessage;
     }
 
     /**
      * Indicates whether the 'active' criteria field must be added automatically for Inactivatable business
      * objects.
      *
      * @return boolean true if active criteria should be added
      */
     public boolean isAutoAddActiveCriteria() {
         return autoAddActiveCriteria;
     }
 
     /**
      * @see LookupView#isAutoAddActiveCriteria()
      */
     public void setAutoAddActiveCriteria(boolean autoAddActiveCriteria) {
         this.autoAddActiveCriteria = autoAddActiveCriteria;
     }
 
     /**
      * List of secure property names that are in addition to the
      * {@link org.kuali.rice.krad.uif.component.ComponentSecurity} or
      * {@link org.kuali.rice.krad.datadictionary.AttributeSecurity} attributes.
      *
      * @return list of secure property names
      */
     @BeanTagAttribute(name = "additionalSecurePropertyNames", type = BeanTagAttribute.AttributeType.LISTVALUE)
     public List<String> getAdditionalSecurePropertyNames() {
         return additionalSecurePropertyNames;
     }
 
     /**
      * @see LookupView#getAdditionalSecurePropertyNames()
      */
     public void setAdditionalSecurePropertyNames(List<String> additionalSecurePropertyNames) {
         this.additionalSecurePropertyNames = additionalSecurePropertyNames;
     }
 }