/**
    * 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.uif.container;
  
  import org.apache.commons.lang.StringUtils;
  import org.kuali.rice.kim.api.identity.Person;
  import org.kuali.rice.krad.uif.CssConstants;
  import org.kuali.rice.krad.uif.UifConstants;
  import org.kuali.rice.krad.uif.UifParameters;
  import org.kuali.rice.krad.uif.UifPropertyPaths;
  import org.kuali.rice.krad.uif.component.BindingInfo;
  import org.kuali.rice.krad.uif.component.Component;
  import org.kuali.rice.krad.uif.component.ComponentSecurity;
  import org.kuali.rice.krad.uif.component.DataBinding;
  import org.kuali.rice.krad.uif.container.collections.LineBuilderContext;
  import org.kuali.rice.krad.uif.control.Control;
  import org.kuali.rice.krad.uif.control.ControlBase;
  import org.kuali.rice.krad.uif.element.Action;
  import org.kuali.rice.krad.uif.field.DataField;
  import org.kuali.rice.krad.uif.field.Field;
  import org.kuali.rice.krad.uif.field.FieldGroup;
  import org.kuali.rice.krad.uif.field.InputField;
  import org.kuali.rice.krad.uif.field.RemoteFieldsHolder;
  import org.kuali.rice.krad.uif.layout.CollectionLayoutManager;
  import org.kuali.rice.krad.uif.layout.TableLayoutManagerBase;
  import org.kuali.rice.krad.uif.lifecycle.ViewLifecycle;
  import org.kuali.rice.krad.uif.lifecycle.ViewLifecycleUtils;
  import org.kuali.rice.krad.uif.util.ComponentFactory;
  import org.kuali.rice.krad.uif.util.ComponentUtils;
  import org.kuali.rice.krad.uif.util.ContextUtils;
  import org.kuali.rice.krad.uif.util.ObjectPropertyUtils;
  import org.kuali.rice.krad.uif.util.ScriptUtils;
  import org.kuali.rice.krad.uif.view.ExpressionEvaluator;
  import org.kuali.rice.krad.uif.view.View;
  import org.kuali.rice.krad.uif.view.ViewAuthorizer;
  import org.kuali.rice.krad.uif.view.ViewModel;
  import org.kuali.rice.krad.uif.view.ViewPresentationController;
  import org.kuali.rice.krad.util.GlobalVariables;
  import org.kuali.rice.krad.web.form.UifFormBase;
  
  import java.io.Serializable;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  
  /**
   * Process configuration from the collection group to prepare components for a new line and invokes the associated
   * layout manager to add the line.
   *
   * @author Kuali Rice Team (rice.collab@kuali.org)
   */
  public class CollectionGroupLineBuilder implements Serializable {
  
      private static final long serialVersionUID = 981187437246864378L;
  
      private LineBuilderContext lineBuilderContext;
      private List<Field> unauthorizedFields = new ArrayList<Field>();
  
      public CollectionGroupLineBuilder(LineBuilderContext lineBuilderContext) {
          this.lineBuilderContext = lineBuilderContext;
      }
  
      /**
       * Invoked to build a line in the collection.
       *
       * <p>First the context for the line is preprocessed in {@link CollectionGroupLineBuilder#preprocessLine()}.
       * After preprocessing the configured layout manager is invoked to place the line into the layout.</p>
       */
      public void buildLine() {
          preprocessLine();
  
          boolean hasLineFields =
                  (lineBuilderContext.getLineFields() != null) && (!lineBuilderContext.getLineFields().isEmpty());
          boolean hasSubCollections =
                  (lineBuilderContext.getSubCollectionFields() != null) && (!lineBuilderContext.getSubCollectionFields()
                          .isEmpty());
  
          // invoke layout manager and setup edit line dialog to build the complete line
          if (hasLineFields || hasSubCollections) {
              // setup the edit dialog if its not an add line
              if (!lineBuilderContext.isAddLine()) {
                  setupEditLineDetails();
              }
  
             // add the lineDialogs to the lineActions
             List<Component> actions = new ArrayList<Component>();
             actions.addAll(lineBuilderContext.getLineActions());
             List<DialogGroup> dialogGroups = lineBuilderContext.getCollectionGroup().getLineDialogs();
             if (Boolean.TRUE.equals(lineBuilderContext.getCollectionGroup().getReadOnly())) {
                 for (DialogGroup group : dialogGroups) {
                     group.setReadOnly(true);
                 }
             }
             actions.addAll(dialogGroups);
             lineBuilderContext.setLineActions(actions);
             lineBuilderContext.getCollectionGroup().getLineDialogs().clear();
 
             // invoke the layout manager
             lineBuilderContext.getLayoutManager().buildLine(lineBuilderContext);
         }
 
         // After the lines have been processed and correct value set for readOnly and other properties
         // set the script for enabling/disabling save button
         applyOnChangeForSave(lineBuilderContext.getLineFields());
     }
 
     /**
      * Performs various preprocessing of the line components and configuration.
      *
      * <p>Preprocessing includes:
      * <ul>
      * <li>Make a copy of the collection groups items and adjust binding and id</li>
      * <li>Process any remotable fields within the line</li>
      * <li>Check line and field authorization</li>
      * <li>Remove fields that should not be rendered</li>
      * <li>Configure client side functionality such as save enable and add line validation</li>
      * <li>Build field groups to hold any configured sub-collections</li>
      * </ul></p>
      */
     public void preprocessLine() {
         List<? extends Component> lineItems = initializeLineItems();
 
         List<Field> lineFields = processAnyRemoteFieldsHolder(lineBuilderContext.getCollectionGroup(), lineItems);
 
         adjustFieldBindingAndId(lineFields, lineBuilderContext.getBindingPath());
 
         ContextUtils.updateContextsForLine(lineFields, lineBuilderContext.getCollectionGroup(),
                 lineBuilderContext.getCurrentLine(), lineBuilderContext.getLineIndex(),
                 lineBuilderContext.getIdSuffix());
 
         boolean canViewLine = checkViewLineAuthorization();
         if (!canViewLine) {
             return;
         }
 
         List<Action> actions = ViewLifecycleUtils.getElementsOfTypeDeep(lineBuilderContext.getLineActions(),
                 Action.class);
         setFocusOnIdForActions(actions, lineFields);
 
         boolean canEditLine = checkEditLineAuthorization(lineFields);
         ContextUtils.pushObjectToContextDeep(lineFields, UifConstants.ContextVariableNames.READONLY_LINE, !canEditLine);
         ContextUtils.pushObjectToContextDeep(actions, UifConstants.ContextVariableNames.READONLY_LINE, !canEditLine);
 
         if (!canEditLine) {
             Iterator<Action> actionsIterator = actions.iterator();
             while (actionsIterator.hasNext()) {
                 Action action = actionsIterator.next();
                 if (action.getId().startsWith(ComponentFactory.EDIT_LINE_IN_DIALOG_ACTION + "_" +
                         lineBuilderContext.getCollectionGroup().getId())) {
                     actionsIterator.remove();
                     break;
                 }
             }
             lineBuilderContext.setLineActions(actions);
         }
 
         // check authorization for line fields
         applyLineFieldAuthorizationAndPresentationLogic(!canEditLine, lineFields, actions);
 
         // remove fields from the line that have render false
         lineFields = removeNonRenderLineFields(lineFields);
 
         buildSubCollectionFieldGroups();
 
         // update action parameters for any actions that were added in the line items (as opposed to the line actions)
         List<Action> lineFieldActions = ViewLifecycleUtils.getElementsOfTypeDeep(lineFields, Action.class);
         if (lineFieldActions != null) {
             lineBuilderContext.getCollectionGroup().getCollectionGroupBuilder().initializeActions(lineFieldActions,
                     lineBuilderContext.getCollectionGroup(), lineBuilderContext.getLineIndex());
         }
 
         setupAddLineControlValidation(lineFields);
 
         lineBuilderContext.setLineFields(lineFields);
     }
 
     /**
      * Copies either the collections groups items or add line items to a list of components that will be used
      * for the collection line.
      *
      * @return list of component instance for the collection line
      */
     protected List<? extends Component> initializeLineItems() {
         List<? extends Component> lineItems;
 
         if (lineBuilderContext.isAddLine()) {
             lineItems = ComponentUtils.copyComponentList(lineBuilderContext.getCollectionGroup().getAddLineItems(),
                     null);
         } else {
             lineItems = ComponentUtils.copyComponentList(lineBuilderContext.getCollectionGroup().getItems(), null);
         }
 
         return lineItems;
     }
 
     /**
      * Iterates through the given items checking for {@code RemotableFieldsHolder}, if found
      * the holder is invoked to retrieved the remotable fields and translate to attribute fields.
      *
      * <p>The translated list is then inserted into the returned list at the position of the holder</p>
      *
      * @param group collection group instance to check for any remotable fields holder
      * @param items list of items to process
      */
     public List<Field> processAnyRemoteFieldsHolder(CollectionGroup group, List<? extends Component> items) {
         List<Field> processedItems = new ArrayList<Field>();
 
         // check for holders and invoke to retrieve the remotable fields and translate
         // translated fields are placed into the processed items list at the position of the holder
         for (Component item : items) {
             if (item instanceof RemoteFieldsHolder) {
                 List<InputField> translatedFields = ((RemoteFieldsHolder) item).fetchAndTranslateRemoteFields(group);
                 processedItems.addAll(translatedFields);
             } else if (item instanceof Field) {
                 processedItems.add((Field) item);
             }
         }
 
         return processedItems;
     }
 
     /**
      * Adjusts the binding path for the given fields to match the collections path, and sets the container id
      * suffix for the fields so all nested components will get their ids adjusted.
      *
      * @param lineFields list of fields to update
      * @param bindingPath binding path to add
      */
     protected void adjustFieldBindingAndId(List<Field> lineFields, String bindingPath) {
         for (Field lineField : lineFields) {
             adjustFieldBinding(lineField, bindingPath);
             adjustFieldId(lineField);
         }
 
         if (lineBuilderContext.isBindToForm()) {
             ComponentUtils.setComponentsPropertyDeep(lineFields, UifPropertyPaths.BIND_TO_FORM, Boolean.valueOf(true));
         }
     }
 
     /**
      * Adjusts the binding path for the given field to match the collections path.
      *
      * @param lineField field to update
      * @param bindingPath binding path to add
      */
     protected void adjustFieldBinding(Field lineField, String bindingPath) {
         if (lineField instanceof DataBinding && ((DataBinding) lineField).getBindingInfo().isBindToForm()) {
             BindingInfo bindingInfo = ((DataBinding) lineField).getBindingInfo();
             bindingInfo.setCollectionPath(null);
             bindingInfo.setBindingName(bindingInfo.getBindingName() + "[" + lineBuilderContext.getLineIndex() + "]");
         } else {
             ComponentUtils.prefixBindingPath(lineField, bindingPath);
         }
     }
 
     /**
      * Adjusts the id suffix for the given field.
      *
      * @param lineField field to update
      */
     protected void adjustFieldId(Field lineField) {
         ComponentUtils.updateIdWithSuffix(lineField, lineBuilderContext.getIdSuffix());
 
         lineField.setContainerIdSuffix(lineBuilderContext.getIdSuffix());
     }
 
     /**
      * For any actions with focus id {@link org.kuali.rice.krad.uif.UifConstants.Order#LINE_FIRST}, the focus id
      * is replaced to match to id of the first control in the line.
      *
      * @param actions list of actions to potientially update
      * @param lineFields list of line fields, the control for the first field in the list
      * will be used for the focus id
      */
     protected void setFocusOnIdForActions(List<Action> actions, List<Field> lineFields) {
         for (Action action : actions) {
             if (action == null) {
                 continue;
             }
 
             boolean focusLineFirst = StringUtils.isNotBlank(action.getFocusOnIdAfterSubmit()) && action
                     .getFocusOnIdAfterSubmit().equalsIgnoreCase(UifConstants.Order.LINE_FIRST.toString());
             boolean lineHasFields = !lineFields.isEmpty();
             if (focusLineFirst && lineHasFields) {
                 action.setFocusOnIdAfterSubmit(lineFields.get(0).getId() + UifConstants.IdSuffixes.CONTROL);
             }
         }
     }
 
     /**
      * If {@link CollectionGroup#isRenderSaveLineActions()} is true and the line has been added by the user, on change
      * script is added to any controls in the line to enable the save action.
      *
      * @param lineFields list of line fields
      */
     protected void applyOnChangeForSave(List<Field> lineFields) {
         boolean isLineNewlyAdded = ((UifFormBase) lineBuilderContext.getModel()).isAddedCollectionItem(
                 lineBuilderContext.getCurrentLine());
         boolean saveLineEnabled = lineBuilderContext.getCollectionGroup().isRenderSaveLineActions();
 
         if (!isLineNewlyAdded && !saveLineEnabled) {
             return;
         }
 
         for (Field field : lineFields) {
             boolean isInputField = (field instanceof InputField);
             if (field.isHidden() || Boolean.TRUE.equals(field.getReadOnly()) || !isInputField) {
                 continue;
             }
 
             // if control null, assign default
             InputField inputField = (InputField) field;
             if (inputField.getControl() == null) {
                 inputField.setControl(ComponentFactory.getTextControl());
             }
 
             ControlBase control = (ControlBase) ((InputField) field).getControl();
 
             String onBlurScript = UifConstants.JsFunctions.COLLECTION_LINE_CHANGED + "(this, '" +
                     CssConstants.Classes.NEW_COLLECTION_ITEM + "');";
             onBlurScript = ScriptUtils.appendScript(control.getOnBlurScript(), onBlurScript);
 
             control.setOnBlurScript(onBlurScript);
         }
     }
 
     /**
      * Evaluates the render property for the given list of field instances for the line and removes any fields
      * from the returned list that have render false.
      *
      * <p>The conditional render string is also taken into account. This needs to be done here as opposed
      * to during the normal condition evaluation so the the fields are not used while building the
      * collection lines</p>
      *
      * @param lineFields list of fields configured for the line
      * @return list of field instances that should be rendered
      */
     protected List<Field> removeNonRenderLineFields(List<Field> lineFields) {
         List<Field> fields = new ArrayList<Field>();
 
         ExpressionEvaluator expressionEvaluator = ViewLifecycle.getExpressionEvaluator();
 
         for (Field lineField : lineFields) {
             String conditionalRender = lineField.getPropertyExpression(UifPropertyPaths.RENDER);
 
             // evaluate conditional render string if set
             if (StringUtils.isNotBlank(conditionalRender)) {
                 Map<String, Object> context = getContextForField(ViewLifecycle.getView(),
                         lineBuilderContext.getCollectionGroup(), lineField);
 
                 // Adjust the condition as ExpressionUtils.adjustPropertyExpressions will only be
                 // executed after the collection is built.
                 conditionalRender = expressionEvaluator.replaceBindingPrefixes(ViewLifecycle.getView(), lineField,
                         conditionalRender);
 
                 Boolean render = (Boolean) expressionEvaluator.evaluateExpression(context, conditionalRender);
                 lineField.setRender(render);
             }
 
             // only add line field if set to render or if it is hidden by progressive render
             if (lineField.isRender() || StringUtils.isNotBlank(lineField.getProgressiveRender())) {
                 fields.add(lineField);
             }
         }
 
         return fields;
     }
 
     /**
      * Determines whether the user is authorized to the view the line.
      *
      * @return boolean true if the user can view the line, false if not
      */
     protected boolean checkViewLineAuthorization() {
         boolean canViewLine = true;
 
         // check view line authorization if collection is not hidden
         if (!lineBuilderContext.isAddLine()) {
             canViewLine = checkViewLineAuthorizationAndPresentationLogic();
         }
 
         if (!canViewLine) {
             addUnauthorizedBindingInfo();
         }
 
         return canViewLine;
     }
 
     /**
      * Invokes the view's configured authorizer and presentation controller to determine if the user has permission
      * to view the line (if a permission has been established).
      *
      * @return true if the user can view the line, false if not
      */
     protected boolean checkViewLineAuthorizationAndPresentationLogic() {
         ViewPresentationController presentationController = ViewLifecycle.getView().getPresentationController();
         ViewAuthorizer authorizer = ViewLifecycle.getView().getAuthorizer();
 
         Person user = GlobalVariables.getUserSession().getPerson();
 
         CollectionGroup collectionGroup = lineBuilderContext.getCollectionGroup();
 
         boolean canViewLine = authorizer.canViewLine(ViewLifecycle.getView(), lineBuilderContext.getModel(),
                 collectionGroup, collectionGroup.getPropertyName(), lineBuilderContext.getCurrentLine(), user);
         if (canViewLine) {
             canViewLine = presentationController.canViewLine(ViewLifecycle.getView(), lineBuilderContext.getModel(),
                     collectionGroup, collectionGroup.getPropertyName(), lineBuilderContext.getCurrentLine());
         }
 
         return canViewLine;
     }
 
     /**
      * Determines whether the user is authorized to the edit the line.
      *
      * @param lineFields list of fields configured for the line
      * @return boolean true if the user can edit the line, false if not
      */
     protected boolean checkEditLineAuthorization(List<Field> lineFields) {
         boolean canEditLine = !Boolean.TRUE.equals(lineBuilderContext.getCollectionGroup().getReadOnly());
 
         if (!canEditLine) {
             ExpressionEvaluator expressionEvaluator = ViewLifecycle.getExpressionEvaluator();
             View view = ViewLifecycle.getView();
 
             for (Field field : lineFields) {
                 field.pushObjectToContext(UifConstants.ContextVariableNames.PARENT,
                         lineBuilderContext.getCollectionGroup());
                 field.pushAllToContext(view.getContext());
                 field.pushObjectToContext(UifConstants.ContextVariableNames.COMPONENT, field);
 
                 expressionEvaluator.evaluatePropertyExpression(view, field.getContext(), field,
                         UifPropertyPaths.READ_ONLY, true);
 
                 if (!Boolean.TRUE.equals(field.getReadOnly())) {
                     canEditLine = true;
                     break;
                 }
             }
         }
 
         if (canEditLine && !lineBuilderContext.isAddLine()) {
             canEditLine = checkEditLineAuthorizationAndPresentationLogic(lineBuilderContext.getCollectionGroup(),
                     lineBuilderContext.getModel(), lineBuilderContext.getCurrentLine());
         }
 
         if (!canEditLine) {
             addUnauthorizedBindingInfo();
         }
 
         return canEditLine;
     }
 
     /**
      * Invokes the view's configured authorizer and presentation controller to determine if the user has permission
      * to edit the line (if a permission has been established).
      *
      * @return true if the user can edit the line, false if not
      */
     protected boolean checkEditLineAuthorizationAndPresentationLogic(CollectionGroup collectionGroup, ViewModel model,
             Object currentLine) {
         ViewPresentationController presentationController = ViewLifecycle.getView().getPresentationController();
         ViewAuthorizer authorizer = ViewLifecycle.getView().getAuthorizer();
 
         Person user = GlobalVariables.getUserSession().getPerson();
 
         boolean canEditLine = authorizer.canEditLine(ViewLifecycle.getView(), model, collectionGroup,
                 collectionGroup.getPropertyName(), currentLine, user);
         if (canEditLine) {
             canEditLine = presentationController.canEditLine(ViewLifecycle.getView(), model, collectionGroup,
                     collectionGroup.getPropertyName(), currentLine);
         }
 
         return canEditLine;
     }
 
     /**
      * Adds a {@link org.kuali.rice.krad.uif.component.BindingInfo} instance for the given binding
      * path to the collection groups unauthorized list.
      */
     protected void addUnauthorizedBindingInfo() {
         if (lineBuilderContext.getCollectionGroup().getUnauthorizedLineBindingInfos() == null) {
             lineBuilderContext.getCollectionGroup().setUnauthorizedLineBindingInfos(new ArrayList<BindingInfo>());
         }
 
         BindingInfo bindingInfo = new BindingInfo();
         bindingInfo.setDefaults(ViewLifecycle.getView(), lineBuilderContext.getBindingPath());
         lineBuilderContext.getCollectionGroup().getUnauthorizedLineBindingInfos().add(bindingInfo);
     }
 
     /**
      * Iterates through the line fields and checks the view field authorization using the view's configured authorizer
      * and presentation controller.
      *
      * <p>If the field is viewable, then sets the edit field authorization. Finally iterates
      * through the line actions invoking the authorizer and presentation controller to authorizer the action</p>
      *
      * @param readOnlyLine flag indicating whether the line has been marked as read only (which will force the fields
      * to be read only)
      * @param lineFields list of fields instances for the line
      * @param actionList list of action field instances for the line
      */
     protected void applyLineFieldAuthorizationAndPresentationLogic(boolean readOnlyLine, List<Field> lineFields,
             List<? extends Component> actionList) {
         ViewPresentationController presentationController = ViewLifecycle.getView().getPresentationController();
         ViewAuthorizer authorizer = ViewLifecycle.getView().getAuthorizer();
 
         Person user = GlobalVariables.getUserSession().getPerson();
         ExpressionEvaluator expressionEvaluator = ViewLifecycle.getExpressionEvaluator();
 
         CollectionGroup collectionGroup = lineBuilderContext.getCollectionGroup();
         View view = ViewLifecycle.getView();
         ViewModel model = lineBuilderContext.getModel();
         Object currentLine = lineBuilderContext.getCurrentLine();
 
         for (Field lineField : lineFields) {
             String propertyName = null;
             if (lineField instanceof DataBinding) {
                 propertyName = ((DataBinding) lineField).getPropertyName();
             }
 
             // evaluate expression on fields component security (since apply model phase has not been invoked on
             // them yet
             ComponentSecurity componentSecurity = lineField.getComponentSecurity();
 
             Map<String, Object> context = getContextForField(ViewLifecycle.getView(), collectionGroup, lineField);
             expressionEvaluator.evaluateExpressionsOnConfigurable(ViewLifecycle.getView(), componentSecurity, context);
 
             // check view field auth
             if (!lineField.isRender() || lineField.isHidden()) {
                 continue;
             }
 
             boolean canViewField = authorizer.canViewLineField(view, model, collectionGroup,
                     collectionGroup.getPropertyName(), currentLine, lineField, propertyName, user);
             if (canViewField) {
                 canViewField = presentationController.canViewLineField(view, model, collectionGroup,
                         collectionGroup.getPropertyName(), currentLine, lineField, propertyName);
             }
 
             if (!canViewField) {
                 // since removing can impact layout, set to hidden
                 // TODO: check into encryption setting
                 lineField.setHidden(true);
 
                 if (lineField.getPropertyExpressions().containsKey(UifPropertyPaths.HIDDEN)) {
                     lineField.getPropertyExpressions().remove(UifPropertyPaths.HIDDEN);
                 }
 
                 continue;
             }
 
             // check edit field auth
             boolean canEditField = !readOnlyLine;
             if (!readOnlyLine) {
                 canEditField = authorizer.canEditLineField(view, model, collectionGroup,
                         collectionGroup.getPropertyName(), currentLine, lineField, propertyName, user);
                 if (canEditField) {
                     canEditField = presentationController.canEditLineField(view, model, collectionGroup,
                             collectionGroup.getPropertyName(), currentLine, lineField, propertyName);
                 }
             }
 
             if (readOnlyLine || !canEditField) {
                 lineField.setReadOnly(true);
 
                 if (lineField.getPropertyExpressions().containsKey(UifPropertyPaths.READ_ONLY)) {
                     lineField.getPropertyExpressions().remove(UifPropertyPaths.READ_ONLY);
                 }
             }
         }
 
         // check auth on line actions
         List<Action> actions = ViewLifecycleUtils.getElementsOfTypeDeep(actionList, Action.class);
         for (Action action : actions) {
             if (!action.isRender()) {
                 continue;
             }
 
             boolean canPerformAction = authorizer.canPerformLineAction(view, model, collectionGroup,
                     collectionGroup.getPropertyName(), currentLine, action, action.getActionEvent(), action.getId(),
                     user);
             if (canPerformAction) {
                 canPerformAction = presentationController.canPerformLineAction(view, model, collectionGroup,
                         collectionGroup.getPropertyName(), currentLine, action, action.getActionEvent(),
                         action.getId());
             }
 
             if (!canPerformAction) {
                 action.setRender(false);
 
                 if (action.getPropertyExpressions().containsKey(UifPropertyPaths.RENDER)) {
                     action.getPropertyExpressions().remove(UifPropertyPaths.RENDER);
                 }
             }
         }
     }
 
     /**
      * For each configured sub collection of the collection group, creates a field group by copying
      * {@link org.kuali.rice.krad.uif.layout.CollectionLayoutManager#getSubCollectionFieldGroupPrototype()} and adds
      * to a list which is stored in the line context.
      */
     protected void buildSubCollectionFieldGroups() {
         CollectionGroup collectionGroup = lineBuilderContext.getCollectionGroup();
 
         String idSuffix = lineBuilderContext.getIdSuffix();
 
         // sub collections are not created for the add line
         if (lineBuilderContext.isAddLine() || (collectionGroup.getSubCollections() == null)) {
             return;
         }
 
         List<FieldGroup> subCollectionFields = new ArrayList<FieldGroup>();
         for (int subLineIndex = 0; subLineIndex < collectionGroup.getSubCollections().size(); subLineIndex++) {
             CollectionGroup subCollectionPrototype = collectionGroup.getSubCollections().get(subLineIndex);
             CollectionGroup subCollectionGroup = ComponentUtils.copy(subCollectionPrototype);
 
             // verify the sub-collection should be rendered
             boolean renderSubCollection = checkSubCollectionRender(subCollectionGroup);
             if (!renderSubCollection) {
                 continue;
             }
 
             subCollectionGroup.getBindingInfo().setBindByNamePrefix(lineBuilderContext.getBindingPath());
             if (subCollectionGroup.isRenderAddLine()) {
                 subCollectionGroup.getAddLineBindingInfo().setBindByNamePrefix(lineBuilderContext.getBindingPath());
             }
 
             FieldGroup fieldGroupPrototype =
                     lineBuilderContext.getLayoutManager().getSubCollectionFieldGroupPrototype();
 
             FieldGroup subCollectionFieldGroup = ComponentUtils.copy(fieldGroupPrototype,
                     idSuffix + UifConstants.IdSuffixes.SUB + subLineIndex);
             subCollectionFieldGroup.setGroup(subCollectionGroup);
 
             subCollectionFieldGroup.setContainerIdSuffix(idSuffix);
 
             ContextUtils.updateContextForLine(subCollectionFieldGroup, collectionGroup,
                     lineBuilderContext.getCurrentLine(), lineBuilderContext.getLineIndex(),
                     idSuffix + UifConstants.IdSuffixes.SUB + subLineIndex);
             ContextUtils.pushObjectToContextDeep(subCollectionGroup, UifConstants.ContextVariableNames.PARENT_LINE,
                     lineBuilderContext.getCurrentLine());
 
             subCollectionFields.add(subCollectionFieldGroup);
         }
 
         ContextUtils.pushObjectToContextDeep(subCollectionFields, UifConstants.ContextVariableNames.PARENT_LINE,
                 lineBuilderContext.getCurrentLine());
 
         // set the parent line on the context of every sub-collection field
         for (FieldGroup subCollectionField : subCollectionFields) {
             Group group = subCollectionField.getGroup();
             if (group != null && group instanceof CollectionGroup) {
                 CollectionGroup collectionGroup1 = (CollectionGroup) group;
                 ContextUtils.pushObjectToContextDeep(collectionGroup1.getItems(),
                         UifConstants.ContextVariableNames.PARENT_LINE, lineBuilderContext.getCurrentLine());
             }
         }
 
         lineBuilderContext.setSubCollectionFields(subCollectionFields);
     }
 
     /**
      * Checks whether the given sub-collection should be rendered, any conditional render string is evaluated.
      *
      * @param subCollectionGroup sub collection group to check render status for
      * @return true if sub collection should be rendered, false if it
      * should not be rendered
      */
     protected boolean checkSubCollectionRender(CollectionGroup subCollectionGroup) {
         String conditionalRender = subCollectionGroup.getPropertyExpression(UifPropertyPaths.RENDER);
 
         // TODO: check authorizer
 
         // evaluate conditional render string if set
         if (StringUtils.isNotBlank(conditionalRender)) {
             Map<String, Object> context = new HashMap<String, Object>();
             Map<String, Object> viewContext = ViewLifecycle.getView().getContext();
 
             if (viewContext != null) {
                 context.putAll(viewContext);
             }
 
             context.put(UifConstants.ContextVariableNames.PARENT, lineBuilderContext.getCollectionGroup());
             context.put(UifConstants.ContextVariableNames.COMPONENT, subCollectionGroup);
 
             Boolean render = (Boolean) ViewLifecycle.getExpressionEvaluator().evaluateExpression(context,
                     conditionalRender);
             subCollectionGroup.setRender(render);
         }
 
         return subCollectionGroup.isRender();
     }
 
     /**
      * Add additional information to the fields in the add line to allow for correct add control selection.
      *
      * @param lineFields list of fields instances for the line
      */
     protected void setupAddLineControlValidation(List<Field> lineFields) {
         // don't process for anything but an add line
         if (!lineBuilderContext.isAddLine()) {
             return;
         }
 
         // set up skipping fields with the given selectors in add area during standard form validation calls
         // custom addLineToCollection js call will validate these fields manually on an add
         List<String> selectors = new ArrayList<String>();
         String lineFieldSelector = UifConstants.IdSuffixes.CONTROL;
         String nestedLineFieldSelector = UifConstants.IdSuffixes.ADD_LINE + UifConstants.IdSuffixes.CONTROL;
 
         // apply changes to and collect selectors from all fields and field groups
         for (Field lineField : lineFields) {
             if (lineField instanceof InputField) {
                 setupAddLineControlValidation((InputField) lineField, selectors, lineFieldSelector);
             } else if (lineField instanceof FieldGroup) {
                 Group group = ((FieldGroup) lineField).getGroup();
                 List<InputField> nestedLineFields = ViewLifecycleUtils.getElementsOfTypeDeep(group, InputField.class);
 
                 for (InputField nestedLineField : nestedLineFields) {
                     setupAddLineControlValidation(nestedLineField, selectors, nestedLineFieldSelector);
                 }
             }
         }
 
         // add collected selectors to data attributes
         lineBuilderContext.getCollectionGroup().addDataAttribute(
                 UifConstants.DataAttributes.ADD_CONTROLS, StringUtils.join(selectors, ","));
     }
 
     /**
      * Add additional information to a field in the add line to allow for correct add control selection.
      *
      * @param lineField field instance for the line
      * @param selectors list of selectors
      * @param suffix id suffix to add
      */
     protected void setupAddLineControlValidation(InputField lineField, List<String> selectors, String suffix) {
         Control control = lineField.getControl();
 
         // ignore automatic validation and grab the selector for manual validation
         if (control != null) {
             control.addStyleClass(CssConstants.Classes.IGNORE_VALID);
             selectors.add("#" + lineField.getId() + suffix);
         }
     }
 
     /**
      * Setup edit line dialog group with the line fields
      *
      * <p>The items for a dialog are created from line fields and added if not provided by the user, but
      * if they are then each item is processed.</p>
      */
     protected void setupEditLineDetails() {
         CollectionGroup group = lineBuilderContext.getCollectionGroup();
 
         if (!group.isEditWithDialog()) {
             return;
         }
 
         for (DialogGroup lineDialog : group.getLineDialogs()) {
             String dialogId = lineDialog.getId();
 
             UifFormBase form = (UifFormBase) lineBuilderContext.getModel();
             if (group.getCollectionGroupBuilder().refreshEditLineDialogContents(lineDialog, form, group,
                     lineBuilderContext.getLineIndex()) && lineDialog.getId().contains(
                     ComponentFactory.EDIT_LINE_DIALOG)) {
                 form.setUpdateComponent(lineDialog);
                 // if there are no custom user items or if there are no items, then use the line fields as items
                 if (lineDialog.getItems() == null || lineDialog.getItems().isEmpty() || !group
                         .isCustomEditLineDialog()) {
                     List<Field> lineFields = lineBuilderContext.getLineFields();
 
                     // process and set items
                     lineDialog.setItems(processDialogFieldsFromLineFields(lineFields, dialogId));
 
                     // process the sub-collection items
                     List<Component> items = new ArrayList<Component>(lineDialog.getItems());
                     items.addAll(processDialogSubFieldsFromLineSubFields(lineDialog));
                     items.addAll(processDialogSubFieldsFromRowDetails(lineDialog));
                     lineDialog.setItems(items);
                 } else { // user provided dialog items
                     List<Component> dialogFields = new ArrayList<>(lineDialog.getItems());
                     List<Component> dialogComponents = new ArrayList<>();
                     int fieldIndex = 0;
                     int subIndex = 0;
 
                     // for every user provided dialog item, find its corresponding line field and set the binding info
                     for (Component dialogField : dialogFields) {
                         if (dialogField instanceof DataField) {
                             DataField dataField = (DataField) dialogField;
                             DataField lineField = findItemInLineFields(dataField);
 
                             if (lineField != null) {
                                 dataField.getBindingInfo().setCollectionPath(
                                         lineField.getBindingInfo().getCollectionPath());
                                 // set the line field to read-only
                                 lineField.setReadOnly(true);
                             } else {
                                 // update the binding info on the custom field
                                 dataField.getBindingInfo().setCollectionPath(group.getBindingInfo().getBindingName());
                             }
 
                             dataField.getBindingInfo().setBindByNamePrefix(UifPropertyPaths.DIALOG_DATA_OBJECT);
                             dialogComponents.add(dataField);
                         } else if (dialogField instanceof FieldGroup) {
                             FieldGroup fieldGroup = (FieldGroup) dialogField;
 
                             if (fieldGroup.getGroup() instanceof CollectionGroup) {
                                 dialogComponents.add(getNewFieldGroup(fieldGroup, (CollectionGroup) fieldGroup.
                                         getGroup(), lineDialog, fieldIndex, subIndex, null));
                                 subIndex++;
                             }
                         } else if (dialogField instanceof CollectionGroup) {
                             CollectionGroup collectionGroup = (CollectionGroup) dialogField;
                             FieldGroup fieldGroupPrototype =
                                     lineBuilderContext.getLayoutManager().getSubCollectionFieldGroupPrototype();
 
                             dialogComponents.add(getNewFieldGroup(fieldGroupPrototype, collectionGroup, lineDialog,
                                     fieldIndex, subIndex, UifPropertyPaths.DIALOG_DATA_OBJECT));
                             subIndex++;
                         } else {
                             ComponentUtils.prefixBindingPath(dialogField, UifPropertyPaths.DIALOG_DATA_OBJECT);
                             dialogComponents.add(dialogField);
                         }
                         fieldIndex++;
                     }
                     lineDialog.setItems(dialogComponents);
                 }
             }
 
         }
 
         // set all collection fields and sub-collection fields to readOnly
         if (lineBuilderContext.getCollectionGroup().isEditWithDialog()) {
             for (Field lineField : lineBuilderContext.getLineFields()) {
                 if (lineField instanceof InputField) {
                     lineField.setReadOnly(Boolean.TRUE);
                 }
             }
             List<FieldGroup> subLineFields = lineBuilderContext.getSubCollectionFields();
             if (subLineFields != null) {
                 for (FieldGroup subLineField : subLineFields) {
                     subLineField.setReadOnly(Boolean.TRUE);
                 }
             }
         }
     }
 
     /**
      * Helper method to build sub-collection fields for the given dialog using the line's sub-collection fields
      *
      * @param lineDialog the line dialog to build the sub-collection for
      * @return the list of created sub-collection fields
      */
     private List<FieldGroup> processDialogSubFieldsFromLineSubFields(DialogGroup lineDialog) {
         // process the subcollections
         List<FieldGroup> subCollectionFields = lineBuilderContext.getSubCollectionFields();
         List<FieldGroup> newSubCollectionFields = new ArrayList<FieldGroup>();
         int fieldIndex = lineDialog.getItems().size();
         int subIndex = 0;
 
         for (FieldGroup subCollectionFieldGroup : subCollectionFields) {
             CollectionGroup subCollectionGroup = (CollectionGroup) subCollectionFieldGroup.getGroup();
 
             // make a copy of the sub-group for the dialog
             newSubCollectionFields.add(getNewFieldGroup(subCollectionFieldGroup, subCollectionGroup, lineDialog,
                     fieldIndex, subIndex, UifPropertyPaths.DIALOG_DATA_OBJECT));
             fieldIndex++;
             subIndex++;
 
             List<Component> components = ViewLifecycleUtils.getElementsOfTypeDeep(subCollectionGroup.getItems(),
                     Component.class);
             for (Component component : components) {
                 component.setReadOnly(Boolean.TRUE);
             }
         }
 
         return newSubCollectionFields;
     }
 
     /**
      * Helper method to build sub-collection fields for the given dialog using the row details group
      *
      * @param lineDialog the line dialog to build the sub-collection for
      * @return the list of created sub-collection fields
      */
     private List<Field> processDialogSubFieldsFromRowDetails(DialogGroup lineDialog) {
         List<Field> newSubCollectionFields = new ArrayList<Field>();
 
         // process the row details group
         CollectionLayoutManager layoutManager = (CollectionLayoutManager) lineBuilderContext.
                 getCollectionGroup().getLayoutManager();
 
         // only the table layout manager has row details
         if (layoutManager instanceof TableLayoutManagerBase) {
             TableLayoutManagerBase tableLayoutManagerBase = (TableLayoutManagerBase) layoutManager;
             Group rowDetailsGroup = tableLayoutManagerBase.getRowDetailsGroup();
 
             if (rowDetailsGroup != null) {
                 List<Component> subCollectionComponents = new ArrayList<Component>(rowDetailsGroup.getItems());
 
                 int fieldIndex = lineDialog.getItems().size();
                 int subIndex = 0;
 
                 // for each item in the row details group create a field group to add the the line dialog's items
                 for (Component component : subCollectionComponents) {
                     if (component instanceof CollectionGroup) {
                         CollectionGroup subCollectionGroup = (CollectionGroup) component;
 
                         boolean renderSubCollection = checkSubCollectionRender(subCollectionGroup);
                         if (!renderSubCollection) {
                             continue;
                         }
 
                         FieldGroup fieldGroupPrototype = lineBuilderContext.
                                 getLayoutManager().getSubCollectionFieldGroupPrototype();
                         newSubCollectionFields.add(getNewFieldGroup(fieldGroupPrototype, subCollectionGroup, lineDialog,
                                 fieldIndex, subIndex, UifPropertyPaths.DIALOG_DATA_OBJECT));
                         subIndex++;
                     } else if (component instanceof Field) {
                         Field subCollectionField = (Field) component;
                         Field newSubCollectionField = getNewFieldForEditLineDialog(subCollectionField,
                                 lineDialog.getId() + UifConstants.IdSuffixes.FIELDSET + Integer.toString(fieldIndex++));
 
                         newSubCollectionFields.add(newSubCollectionField);
                     }
 
                     ContextUtils.pushObjectToContextDeep(newSubCollectionFields,
                             UifConstants.ContextVariableNames.PARENT_LINE,
                             ((UifFormBase) lineBuilderContext.getModel()).getDialogDataObject());
                 }
             }
         }
 
         return newSubCollectionFields;
     }
 
     /**
      * Helper method that creates a new field group for a given sub-collection.
      *
      * @param fieldGroupPrototype the field group prototype to use
      * @param subCollectionGroup the sub-collection to create field group for
      * @param lineDialog the line dialog that the field group should be in
      * @param fieldIndex the index to apply for the field group
      * @param subIndex the index to apply for the sub-collection
      * @return the created field group
      */
     private FieldGroup getNewFieldGroup(FieldGroup fieldGroupPrototype, CollectionGroup subCollectionGroup,
             DialogGroup lineDialog, int fieldIndex, int subIndex, String bindingPrefix) {
         FieldGroup newSubCollectionFieldGroup = ComponentUtils.copy(fieldGroupPrototype);
         newSubCollectionFieldGroup.setId(lineDialog.getId() +
                 UifConstants.IdSuffixes.FIELDSET + Integer.toString(fieldIndex));
         newSubCollectionFieldGroup.pushObjectToContext(UifConstants.ContextVariableNames.PARENT, lineDialog);
 
         CollectionGroup newSubCollectionGroup = ComponentUtils.copy(subCollectionGroup);
         newSubCollectionGroup.setId(newSubCollectionFieldGroup.getId() + UifConstants.IdSuffixes.SUB +
                 Integer.toString(subIndex));
         if (bindingPrefix != null) {
             newSubCollectionGroup.getBindingInfo().setBindByNamePrefix(bindingPrefix);
         }
 
         if (newSubCollectionGroup.getBindingInfo().getBindingName() == null) {
             newSubCollectionGroup.getBindingInfo().setBindingName(newSubCollectionGroup.getPropertyName());
         }
 
         newSubCollectionGroup.pushObjectToContext(UifConstants.ContextVariableNames.PARENT, lineDialog);
         newSubCollectionGroup.addDataAttribute(UifConstants.
                 ContextVariableNames.PARENT, lineDialog.getId());
 
         if (newSubCollectionGroup.isRenderAddLine()) {
             newSubCollectionGroup.getAddLineBindingInfo().setBindByNamePrefix(newSubCollectionGroup.
                     getBindingInfo().getBindByNamePrefix());
             newSubCollectionGroup.getAddLineBindingInfo().setBindingName(newSubCollectionGroup.
                     getBindingInfo().getBindingName());
             String addBindingPath = UifPropertyPaths.NEW_COLLECTION_LINES + "['" +
                     newSubCollectionGroup.getBindingInfo().getBindByNamePrefix() + "." +
                     newSubCollectionGroup.getBindingInfo().getBindingName() + "']";
             Object addLine = ObjectPropertyUtils.getPropertyValue(lineBuilderContext.getModel(), addBindingPath);
             if (addLine != null) {
                 ObjectPropertyUtils.setPropertyValue(lineBuilderContext.getModel(), addBindingPath, null);
             }
         }
 
         // set the new collection group's line actions to refresh the entire
         // dialog not just the sub-collection
         List<Action> subLineActions = ViewLifecycleUtils.getElementsOfTypeDeep(newSubCollectionGroup.getLineActions(),
                 Action.class);
         setupSubCollectionActions(subLineActions, lineDialog.getId(),
                 lineBuilderContext.getCollectionGroup().getBindingInfo().getBindingName(),
                 lineBuilderContext.getLineIndex());
 
         // initialize the new sub-collections line actions
         lineBuilderContext.getCollectionGroup().getCollectionGroupBuilder().initializeLineActions(subLineActions,
                 ViewLifecycle.getView(), newSubCollectionGroup, lineBuilderContext.getCurrentLine(),
                 lineBuilderContext.getLineIndex());
 
         // get the add line actions for this group
             List<Component> subAddLineComponents = new ArrayList<Component>(newSubCollectionGroup.getAddLineActions());
             if (newSubCollectionGroup.getAddBlankLineAction() != null) {
                 subAddLineComponents.add(newSubCollectionGroup.getAddBlankLineAction());
             }
             List<Action> subAddLineActions = ViewLifecycleUtils.getElementsOfTypeDeep(subAddLineComponents,
                     Action.class);
 
             // initialize the new sub-collections add line actions
             setupSubCollectionActions(subAddLineActions, lineDialog.getId(), lineBuilderContext.
                             getCollectionGroup().getBindingInfo().getBindingName(), lineBuilderContext.getLineIndex()
             );
 
         newSubCollectionFieldGroup.setGroup(newSubCollectionGroup);
 
         ContextUtils.updateContextForLine(newSubCollectionFieldGroup, lineBuilderContext.
                         getCollectionGroup(), ((UifFormBase) lineBuilderContext.getModel()).
                         getDialogDataObject(), lineBuilderContext.getLineIndex(),
                 lineBuilderContext.getIdSuffix() + UifConstants.IdSuffixes.SUB + subIndex
         );
         ContextUtils.pushObjectToContextDeep(newSubCollectionGroup, UifConstants.ContextVariableNames.PARENT_LINE,
                 ((UifFormBase) lineBuilderContext.getModel()).getDialogDataObject());
         return newSubCollectionFieldGroup;
     }
 
     /**
      * Helper method that builds line dialog fields from the line fields
      *
      * @param lineFields the fields in the component
      * @param prefix the prefix to use in the id for the new fields
      * @return the list of created fields
      */
     private List<Field> processDialogFieldsFromLineFields(List<Field> lineFields, String prefix) {
         List<Field> newLineFields = new ArrayList<Field>();
 
         // for each line field create and add a corresponding dialog field
         int fieldIndex = 0;
         for (Field lineField : lineFields) {
             if (!(lineField instanceof FieldGroup)) {
                 Field newLineField = getNewFieldForEditLineDialog(lineField, prefix +
                         UifConstants.IdSuffixes.FIELDSET + Integer.toString(fieldIndex));
                 newLineFields.add(newLineField);
                 fieldIndex++;
             }
         }
         return newLineFields;
     }
 
     /**
      * Helper method to create a new field that is a copy of a given field for the edit line dialog.
      *
      * @param field the field to copy
      * @param id the id of the new field
      * @return the new field
      */
     private Field getNewFieldForEditLineDialog(Field field, String id) {
         Field newLineField = ComponentUtils.copy(field, id);
 
         // set the line field to point to the dialog's data object
         if (newLineField instanceof DataField) {
             ((DataField) newLineField).getBindingInfo().setBindByNamePrefix(UifPropertyPaths.DIALOG_DATA_OBJECT);
         }
         return newLineField;
     }
 
     /**
      * Helper method to setup edit line dialog's sub-collection's line actions.
      *
      * @param actions the actions to setup
      * @param dialogId the id of the dialog the sub-collection is in
      * @param bindingName the binding name of the dialog's sub-collection
      * @param lineIndex the index of the line being edited in the dialog
      */
     private void setupSubCollectionActions(List<Action> actions, String dialogId, String bindingName, int lineIndex) {
         for (Action action : actions) {
             action.setDialogDismissOption("REQUEST");
             action.setRefreshId(StringUtils.substring(dialogId, dialogId.indexOf("_") + 1, dialogId.lastIndexOf("_")));
             String actionScript = UifConstants.JsFunctions.SHOW_EDIT_LINE_DIALOG + "('" +
                     dialogId + "', '" + bindingName + "', " + lineIndex + ");";
             action.setRefreshedByAction(false);
             action.setSuccessCallback("jQuery.unblockUI();" + actionScript);
             action.setOnClickScript("jQuery('#" + dialogId +
                 "').one('hide.bs.modal', function(e) { jQuery.blockUI({ message: '<h1>Editing line ...</h1>' }); });");
             action.addActionParameter(UifParameters.DIALOG_ID, dialogId);
         }
     }
 
     /**
      * Helper method that gets a line item that corresponds to the given field
      *
      * <p>In this case, the corresponding line item for a field is one where the field's property names
      * are the same.</p>
      *
      * @param dataItem the data field to get the line item for
      */
     private DataField findItemInLineFields(DataField dataItem) {
         for (Field field : lineBuilderContext.getLineFields()) {
             if (field instanceof DataField) {
                 if (dataItem.getPropertyName().equals(((DataField) field).getPropertyName())) {
                     return (DataField) field;
                 }
             }
         }
         return null;
     }
 
     /**
      * Helper method to build the context for a field (needed because the apply model phase for line fields has
      * not been applied yet and their full context not set)
      *
      * @param view view instance the field belongs to
      * @param collectionGroup collection group instance the field belongs to
      * @param field field instance to build context for
      * @return Map<String, Object> context for field
      */
     protected Map<String, Object> getContextForField(View view, CollectionGroup collectionGroup, Field field) {
         Map<String, Object> context = new HashMap<String, Object>();
 
         Map<String, Object> viewContext = view.getContext();
         if (viewContext != null) {
             context.putAll(viewContext);
         }
 
         Map<String, Object> fieldContext = field.getContext();
         if (fieldContext != null) {
             context.putAll(fieldContext);
         }
 
         context.put(UifConstants.ContextVariableNames.PARENT, collectionGroup);
         context.put(UifConstants.ContextVariableNames.COMPONENT, field);
 
         return context;
     }
 }