/**

  * Copyright 2005-2011 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.kns.datadictionary;

 import org.apache.commons.lang.StringUtils;

 import org.kuali.rice.core.api.config.property.ConfigurationService;

 import org.kuali.rice.krad.datadictionary.DataDictionaryDefinitionBase;

 import org.kuali.rice.krad.datadictionary.HelpDefinition;

 import org.kuali.rice.krad.datadictionary.SortDefinition;

 import org.kuali.rice.krad.datadictionary.exception.DuplicateEntryException;

 import org.kuali.rice.krad.service.KRADServiceLocator;

 import org.kuali.rice.krad.util.KRADConstants;

 import java.util.ArrayList;

 import java.util.LinkedHashMap;

 import java.util.List;

 import java.util.Map;

 /**

  * Contains lookup-related information relating to the parent BusinessObject.

  * <p/>

  * The lookup element is used to specify the rules for "looking up"

  * a business object.  These specifications define the following:

  * How to specify the search criteria used to locate a set of business objects

  * How to display the search results

  * <p/>

  * DD: See LookupDefinition.java

  * <p/>

  * JSTL: The lookup element is a Map which is accessed using

  * a key of "lookup".  This map contains the following keys:

  * lookupableID (String, optional)

  * title (String)

  * menubar (String, optional)

  * defaultSort (Map, optional)

  * lookupFields (Map)

  * resultFields (Map)

  * resultSetLimit (String, optional)

  * <p/>

  * See LookupMapBuilder.java

  * <p/>

  * Note: the setters do copious amounts of validation, to facilitate generating errors during the parsing process.

  */

 @Deprecated

 public class LookupDefinition extends DataDictionaryDefinitionBase {

     private static final long serialVersionUID = 6733008572890721359L;

     protected String lookupableID;

     protected String title;

     protected String menubar;

     protected SortDefinition defaultSort;

     protected List<FieldDefinition> lookupFields = new ArrayList<FieldDefinition>();

     protected Map<String, FieldDefinition> lookupFieldMap = new LinkedHashMap<String, FieldDefinition>();

     protected List<FieldDefinition> resultFields = new ArrayList<FieldDefinition>();

     protected Map<String, FieldDefinition> resultFieldMap = new LinkedHashMap<String, FieldDefinition>();

     protected Integer resultSetLimit = null;

     protected Integer multipleValuesResultSetLimit = null;

     protected String extraButtonSource;

     protected String extraButtonParams;

     protected String searchIconOverride;

     protected int numOfColumns;

     protected HelpDefinition helpDefinition;

     protected String helpUrl;

     protected boolean translateCodes = false;

     protected boolean disableSearchButtons = false;

     public LookupDefinition() {

     }

     /**

      * The lookupableID element identifies the name of the Spring bean which

      * will be used to obtain the lookupable helper service for the business object.

      * For example, the Balance.xml file has a lookupableId = "glBalanceLookupable".

      * The KualiSpringBeansGL.xml file determines that the helper service will be an

      * instance of BalanceLookupableHelperServiceImpl.

      * <p/>

      * If this field is omitted, the default bean id used will be kualiLookupable which uses

      * the KualiLookupableHelperServiceImpl helper service.

      */

     public void setLookupableID(String lookupableID) {

         if (lookupableID == null) {

             throw new IllegalArgumentException("invalid (null) lookupableID");

         }

         this.lookupableID = lookupableID;

     }

     /**

      * @return custom lookupable id

      */

     public String getLookupableID() {

         return this.lookupableID;

     }

     /**

      * @return title

      */

     public String getTitle() {

         return title;

     }

     /**

      * Sets title to the given value.

      *

      * @param title

      * @throws IllegalArgumentException if the given title is blank

      */

     public void setTitle(String title) {

         if (StringUtils.isBlank(title)) {

             throw new IllegalArgumentException("invalid (blank) title");

         }

         this.title = title;

     }

     /**

      * @return true if this instance has a menubar

      */

     public boolean hasMenubar() {

         return (menubar != null);

     }

     /**

      * @return menubar

      */

     public String getMenubar() {

         return menubar;

     }

     /**

      * The menubar element is used to add additional html code

      * to the header line on the lookup screen.

      * <p/>

      * For example, Account.xml uses this element to

      * add the "create new global" button to the Account Lookup header.

      *

      * @throws IllegalArgumentException if the given menubar is blank

      */

     public void setMenubar(String menubar) {

         if (StringUtils.isBlank(menubar)) {

             throw new IllegalArgumentException("invalid (blank) menubar");

         }

         // TODO: catch exception if service locator call fails

         ConfigurationService kualiConfigurationservice = KRADServiceLocator.getKualiConfigurationService();

         this.menubar = menubar.replace("${kr.externalizable.images.url}",

                 kualiConfigurationservice.getPropertyValueAsString(KRADConstants.EXTERNALIZABLE_IMAGES_URL_KEY)).replace("${externalizable.images.url}",

                 kualiConfigurationservice.getPropertyValueAsString(

                         KRADConstants.APPLICATION_EXTERNALIZABLE_IMAGES_URL_KEY));

         this.menubar = this.menubar.replace("${application.url}", kualiConfigurationservice.getPropertyValueAsString(

                 KRADConstants.APPLICATION_URL_KEY));

     }

     /**

      * @return true if this instance has a default sort defined

      */

     public boolean hasDefaultSort() {

         return (defaultSort != null);

     }

     /**

      * @return defaultSort

      */

     public SortDefinition getDefaultSort() {

         return defaultSort;

     }

     /**

      * The defaultSort element specifies the sequence in which the

      * lookup search results should be displayed.  It contains an

      * ascending/descending indicator and a list of attribute names.

      * <p/>

      * DD: See SortDefinition.java

      * <p/>

      * JSTL: defaultSort is a Map with the following keys:

      * sortAscending (boolean String)

      * sortAttributes (Map)

      * <p/>

      * By the time JSTL export occurs, the optional attributeName from the defaultSort

      * tag will have been converted into the first contained sortAttribute

      * <p/>

      * See LookupMapBuilder.java

      *

      * @throws IllegalArgumentException if the given defaultSort is blank

      */

     public void setDefaultSort(SortDefinition defaultSort) {

         if (defaultSort == null) {

             throw new IllegalArgumentException("invalid (null) defaultSort");

         }

         this.defaultSort = defaultSort;

     }

     /**

      * @return List of attributeNames of all lookupField FieldDefinitions associated with this LookupDefinition, in the order in

      *         which they were added

      */

     public List getLookupFieldNames() {

         List fieldNames = new ArrayList();

         fieldNames.addAll(this.lookupFieldMap.keySet());

         return fieldNames;

     }

     /**

      * @return Collection of all lookupField FieldDefinitions associated with this LookupDefinition, in the order in which they were

      *         added

      */

     public List<FieldDefinition> getLookupFields() {

         return lookupFields;

     }

     /**

      * @param fieldName

      * @return FieldDefinition associated with the named lookup field, or null if there is none

      */

     public FieldDefinition getLookupField(String attributeName) {

         return lookupFieldMap.get(attributeName);

     }

     /**

      * @return List of attributeNames of all resultField FieldDefinitions associated with this LookupDefinition, in the order in

      *         which they were added

      */

     public List<String> getResultFieldNames() {

         List<String> fieldNames = new ArrayList<String>();

         fieldNames.addAll(resultFieldMap.keySet());

         return fieldNames;

     }

     /**

      * @return Collection of all resultField FieldDefinitions associated with this LookupDefinition, in the order in which they were

      *         added

      */

     public List<FieldDefinition> getResultFields() {

         return resultFields;

     }

     /**

      * @param fieldName

      * @return FieldDefinition associated with the named result field, or null if there is none

      */

     public FieldDefinition getResultField(String attributeName) {

         return resultFieldMap.get(attributeName);

     }

     /**

      * The resultSetLimit element specifies the maximum number of records that will be listed

      * as a result of the lookup search.

      */

     public void setResultSetLimit(Integer resultSetLimit) {

         this.resultSetLimit = resultSetLimit;

     }

     /**

      * @return true if this instance has a result set limit

      */

     public boolean hasResultSetLimit() {

         return (resultSetLimit != null);

     }

     /**

      * The resultSetLimit element specifies the maximum number of records that will be listed

      * as a result of the lookup search.

      */

     public Integer getResultSetLimit() {

         return resultSetLimit;

     }

     /**

      * The multipleValuesResultSetLimit element specifies the maximum number of records that will be listed

      * as a result of a multiple values lookup search.

      */

     public void setMultipleValuesResultSetLimit(Integer multipleValuesResultSetLimit) {

             this.multipleValuesResultSetLimit = multipleValuesResultSetLimit;

         }

     /**

      * @return true if this instance has a multiple values result set limit

      */

     public boolean hasMultipleValuesResultSetLimit() {

             return (multipleValuesResultSetLimit != null);

     }

     /**

      * The multipleValuesResultSetLimit element specifies the maximum number of records that will be listed

      * as a result of a multiple values lookup search.

      */

     public Integer getMultipleValuesResultSetLimit() {

             return multipleValuesResultSetLimit;

     }

     /**

      * Directly validate simple fields, call completeValidation on Definition fields.

      *

      * @see org.kuali.rice.krad.datadictionary.DataDictionaryDefinition#completeValidation(java.lang.Class, java.lang.Object)

      */

     public void completeValidation(Class rootBusinessObjectClass, Class otherBusinessObjectClass) {

         if (hasDefaultSort()) {

             defaultSort.completeValidation(rootBusinessObjectClass, null);

         }

         for (FieldDefinition lookupField : lookupFields) {

             lookupField.completeValidation(rootBusinessObjectClass, null);

         }

         for (FieldDefinition resultField : resultFields) {

             resultField.completeValidation(rootBusinessObjectClass, null);

         }

     }

     /**

      * @return true if this instance has extraButtonSource

      */

     public boolean hasExtraButtonSource() {

         return extraButtonSource != null;

     }

     /**

      * @return extraButtonSource

      */

     public String getExtraButtonSource() {

         return extraButtonSource;

     }

     /**

      * The extraButton element is used to define additional buttons which will

      * appear on the lookup screen next to the Search and Clear buttons.

      * You can define the image source and additional html parameters for

      * each button.

      * <p/>

      * The extraButtonSource element defines the location of an image file

      * to use for the extra button.

      *

      * @throws IllegalArgumentException if the given source is blank

      */

     public void setExtraButtonSource(String extraButtonSource) {

         if (StringUtils.isBlank(extraButtonSource)) {

             throw new IllegalArgumentException("invalid (blank) button source");

         }

         this.extraButtonSource = extraButtonSource;

     }

     /**

      * @return true if this instance has extraButtonParams

      */

     public boolean hasExtraButtonParams() {

         return extraButtonParams != null;

     }

     /**

      * @return extraButtonParams

      */

     public String getExtraButtonParams() {

         return extraButtonParams;

     }

     /**

      * The extraButton element is used to define additional buttons which will

      * appear on the lookup screen next to the Search and Clear buttons.

      * You can define the image source and additional html parameters for

      * each button.

      * <p/>

      * The extraButtonParams contains extra HTML parameters that be associated

      * with the button.

      */

     public void setExtraButtonParams(String extraButtonParams) {

         this.extraButtonParams = extraButtonParams;

     }

     /**

      * @return true if this instance has an alternate icon to use for lookup icon

      */

     public boolean hasSearchIconOverride() {

         return searchIconOverride != null;

     }

     /**

      * @return search icon override url

      */

     public String getSearchIconOverride() {

         return searchIconOverride;

     }

     /**

      * The searchIconOverride element is used to define alternative icons

      * appear on the lookup screen next to the Search and Clear buttons.

      * You can define the image source.

      *

      * @throws IllegalArgumentException if the given source is blank

      */

     public void setSearchIconOverride(String searchIconOverride) {

         if (StringUtils.isBlank(searchIconOverride)) {

             throw new IllegalArgumentException("invalid (blank) search icon override");

         }

         this.searchIconOverride = searchIconOverride;

     }

     public String toString() {

         return "LookupDefinition '" + getTitle() + "'";

     }

     /**

      * The lookupFields element defines the set of fields in which the user

      * can enter values representing search selection criteria.  A search result

      * record will be returned only if the criteria entered in all the

      * lookup fields are met.

      * <p/>

      * DD:  See LookupDefinition.java

      * <p/>

      * JSTL: lookupFields is a Map which is accessed using a key of "lookupFields".

      * This map contains the following keys:

      * attributeName of first lookup field

      * attributeName of second lookup field

      * etc.

      * The corresponding values are lookupField Export Maps.

      * See LookupMapBuilder.java.

      * <p/>

      * The lookupField element defines one lookup search

      * criterion field.

      * DD: See LookupDefinition.java.

      * <p/>

      * JSTL: lookupField is a Map which is accessed by a key

      * which is the attributeName of a lookup field.  This map contains

      * entries with the following keys:

      * "attributeName" (String)

      * "required" (boolean String)

      * <p/>

      * lookupField attribute definitions:

      * <p/>

      * required = true means that the user must enter something

      * into the search criterion lookup field

      * forceLookup = this attribute is not used

      * noLookup = true means that field should not include magnifying glass (i.e. quickfinder)

      */

     public void setLookupFields(List<FieldDefinition> lookupFields) {

         lookupFieldMap.clear();

         for (FieldDefinition lookupField : lookupFields) {

             if (lookupField == null) {

                 throw new IllegalArgumentException("invalid (null) lookupField");

             }

             String keyName = lookupField.getAttributeName();

             if (lookupFieldMap.containsKey(keyName)) {

                 throw new DuplicateEntryException("duplicate lookupField entry for attribute '" + keyName + "'");

             }

             lookupFieldMap.put(keyName, lookupField);

         }

         this.lookupFields = lookupFields;

     }

     /**

      * The resultFields element specifies the list of fields that are shown as a result

      * of the lookup search.

      * <p/>

      * JSTL: resultFields is a Map which is accesseed by a key of "resultFields".

      * This map contains entries with the following keys:

      * attributeName of first result field

      * attributeName of second result field

      * etc.

      * The corresponding values are ExportMap's

      * <p/>

      * The ExportMaps are accessed using a key of attributeName.

      * Each ExportMap contains a single entry as follows:

      * "attributeName"

      * The corresponding value is the attributeName of the field.

      * <p/>

      * See LookupMapBuilder.java.

      */

     public void setResultFields(List<FieldDefinition> resultFields) {

         resultFieldMap.clear();

         for (FieldDefinition resultField : resultFields) {

             if (resultField == null) {

                 throw new IllegalArgumentException("invalid (null) resultField");

             }

             String keyName = resultField.getAttributeName();

             if (resultFieldMap.containsKey(keyName)) {

                 throw new DuplicateEntryException("duplicate resultField entry for attribute '" + keyName + "'");

             }

             resultFieldMap.put(keyName, resultField);

         }

         this.resultFields = resultFields;

     }

     /**

      * @return the numOfColumns

      */

     public int getNumOfColumns() {

         return this.numOfColumns;

     }

     /**

      * @param numOfColumns the numOfColumns to set

      */

     public void setNumOfColumns(int numOfColumns) {

         this.numOfColumns = numOfColumns;

     }

     /**

      * @return the helpDefinition

      */

     public HelpDefinition getHelpDefinition() {

         return this.helpDefinition;

     }

     /**

      * @param helpDefinition the helpDefinition to set

      */

     public void setHelpDefinition(HelpDefinition helpDefinition) {

         this.helpDefinition = helpDefinition;

     }

     /**

      * @return the helpUrl

      */

     public String getHelpUrl() {

         return this.helpUrl;

     }

     /**

      * @param helpUrl the helpUrl to set

      */

     public void setHelpUrl(String helpUrl) {

         this.helpUrl = helpUrl;

     }

     public boolean isTranslateCodes() {

         return this.translateCodes;

     }

     public void setTranslateCodes(boolean translateCodes) {

         this.translateCodes = translateCodes;

     }

     public boolean isDisableSearchButtons() {

         return this.disableSearchButtons;

     }

     public void setDisableSearchButtons(boolean disableSearchButtons) {

         this.disableSearchButtons = disableSearchButtons;

     }

 }