* Licensed to the Apache Software Foundation (ASF) under one

* or more contributor license agreements.  See the NOTICE file

* distributed with this work for additional information

* regarding copyright ownership.  The ASF licenses this file

* to you under the Apache License, Version 2.0 (the

* "License"); you may not use this file except in compliance

* with the License.  You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing,

* software distributed under the License is distributed on an

* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

* KIND, either express or implied.  See the License for the

* specific language governing permissions and limitations

* under the License.

*******************************************************************************/

* Widget Library - Form model class

*/

    public static final String module = ModelForm.class.getName();

    public static final String DEFAULT_FORM_RESULT_LIST_NAME = "defaultFormResultList";

    protected GenericDelegator delegator;

    protected LocalDispatcher dispatcher;

    protected String name;

    protected String type;

    protected FlexibleStringExpander target;

    protected String targetType;

    protected String containerId;

    protected String containerStyle;

    protected String focusFieldName;

    protected String title;

    protected String tooltip;

    protected String listName;

    protected String listEntryName;

    protected FlexibleMapAccessor defaultMapName;

    protected String defaultEntityName;

    protected String defaultServiceName;

    protected String formTitleAreaStyle;

    protected String formWidgetAreaStyle;

    protected String defaultTitleAreaStyle;

    protected String defaultWidgetAreaStyle;

    protected String defaultTitleStyle;

    protected String defaultWidgetStyle;

    protected String defaultTooltipStyle;

    protected String itemIndexSeparator;

    protected FlexibleStringExpander paginateTarget;

    protected FlexibleStringExpander paginateIndexField;

    protected FlexibleStringExpander paginateSizeField;

    protected FlexibleStringExpander overrideListSize;

    protected FlexibleStringExpander paginatePreviousLabel;

    protected FlexibleStringExpander paginateNextLabel;

    protected String paginateTargetAnchor;

    protected String paginatePreviousStyle;

    protected String paginateNextStyle;

    protected boolean separateColumns = false;

    protected boolean paginate = true;

    protected boolean useRowSubmit = false;

    protected FlexibleStringExpander targetWindowExdr;

    protected String defaultRequiredFieldStyle;

    protected String oddRowStyle;

    protected String evenRowStyle;

    protected String defaultTableStyle;

    protected String headerRowStyle;

    protected boolean skipStart = false;

    protected boolean skipEnd = false;

    protected boolean hideHeader = false;

    protected boolean overridenListSize = false;

    protected List altTargets = new LinkedList();

    protected List autoFieldsServices = new LinkedList();

    protected List autoFieldsEntities = new LinkedList();

    protected List sortOrderFields = new LinkedList();

    /** This List will contain one copy of each field for each field name in the order

     * they were encountered in the service, entity, or form definition; field definitions

     * with constraints will also be in this list but may appear multiple times for the same

     * field name.

     *

     * When rendering the form the order in this list should be following and it should not be

     * necessary to use the Map. The Map is used when loading the form definition to keep the

     * list clean and implement the override features for field definitions.

     */

    protected List fieldList = new LinkedList();

    /** This Map is keyed with the field name and has a ModelFormField for the value; fields

     * with conditions will not be put in this Map so field definition overrides for fields

     * with conditions is not possible.

     */

    protected Map fieldMap = new HashMap();

    /** This is a list of FieldGroups in the order they were created.

     * Can also include Banner objects.

     */

    protected List fieldGroupList = new ArrayList();

   

    /** This Map is keyed with the field name and has a FieldGroup for the value.

     * Can also include Banner objects.

     */

    protected Map fieldGroupMap = new HashMap();

   

    /** This field group will be the "catch-all" group for fields that are not

     *  included in an explicit field-group.

     */

    protected FieldGroup defaultFieldGroup;

   

    /** Default hyperlink target. */

    public static String DEFAULT_TARGET_TYPE = "intra-app";

    /** Pagination settings and defaults. */

    public static int DEFAULT_PAGE_SIZE = 100;

    protected int defaultViewSize = DEFAULT_PAGE_SIZE;

    public static String DEFAULT_PAG_INDEX_FIELD = "viewIndex";

    public static String DEFAULT_PAG_SIZE_FIELD = "viewSize";

    public static String DEFAULT_PAG_PREV_LABEL = "Previous";

    public static String DEFAULT_PAG_NEXT_LABEL = "Next";

    public static String DEFAULT_PAG_PREV_STYLE = "buttontext";

    public static String DEFAULT_PAG_NEXT_STYLE = "buttontext";

   

    protected List actions;

    protected List rowActions;

    protected FlexibleStringExpander rowCountExdr;

    protected ModelFormField multiSubmitField;

    protected int rowCount = 0;

    // ===== CONSTRUCTORS =====

    /** Default Constructor */

    public ModelForm() {}

    /** XML Constructor */

    public ModelForm(Element formElement, GenericDelegator delegator, LocalDispatcher dispatcher) {

        this.delegator = delegator;

        this.dispatcher = dispatcher;

        initForm(formElement);

    }

   

    public ModelForm(Element formElement) {

        initForm(formElement);

    }

   

    public void initForm(Element formElement) {

        // check if there is a parent form to inherit from

        String parentResource = formElement.getAttribute("extends-resource");

        String parentForm = formElement.getAttribute("extends");

        if (parentForm.length() > 0) {

            ModelForm parent = null;

            // check if we have a resource name (part of the string before the ?)

            if (parentResource.length() > 0) {

                try {

                    parent = FormFactory.getFormFromLocation(parentResource, parentForm, delegator, dispatcher);

                } catch (Exception e) {

                    Debug.logError(e, "Failed to load parent form definition '" + parentForm + "' at resource '" + parentResource + "'", module);

                }

            } else if (!parentForm.equals(formElement.getAttribute("name"))) {

                // try to find a form definition in the same file

                Element rootElement = formElement.getOwnerDocument().getDocumentElement();

                List formElements = UtilXml.childElementList(rootElement, "form");

                //Uncomment below to add support for abstract forms

                //formElements.addAll(UtilXml.childElementList(rootElement, "abstract-form"));

                Iterator formElementIter = formElements.iterator();

                while (formElementIter.hasNext()) {

                    Element formElementEntry = (Element) formElementIter.next();

                    if (formElementEntry.getAttribute("name").equals(parentForm)) {

                        parent = new ModelForm(formElementEntry, delegator, dispatcher);

                        break;

                    }

                }

                if (parent == null) {

                    Debug.logError("Failed to find parent form definition '" + parentForm + "' in same document.", module);

                }

            } else {

                Debug.logError("Recursive form definition found for '" + formElement.getAttribute("name") + ".'", module);

            }

            if (parent != null) {

                this.type = parent.type;

                this.target = parent.target;

                this.containerId = parent.containerId;

                this.containerStyle = parent.containerStyle;

                this.focusFieldName = parent.focusFieldName;

                this.title = parent.title;

                this.tooltip = parent.tooltip;

                this.listName = parent.listName;

                this.listEntryName = parent.listEntryName;

                this.tooltip = parent.tooltip;

                this.defaultEntityName = parent.defaultEntityName;

                this.defaultServiceName = parent.defaultServiceName;

                this.formTitleAreaStyle = parent.formTitleAreaStyle;

                this.formWidgetAreaStyle = parent.formWidgetAreaStyle;

                this.defaultTitleAreaStyle = parent.defaultTitleAreaStyle;

                this.defaultWidgetAreaStyle = parent.defaultWidgetAreaStyle;

                this.oddRowStyle = parent.oddRowStyle;

                this.evenRowStyle = parent.evenRowStyle;

                this.defaultTableStyle = parent.defaultTableStyle;

                this.headerRowStyle = parent.headerRowStyle;

                this.defaultTitleStyle = parent.defaultTitleStyle;

                this.defaultWidgetStyle = parent.defaultWidgetStyle;

                this.defaultTooltipStyle = parent.defaultTooltipStyle;

                this.itemIndexSeparator = parent.itemIndexSeparator;

                //this.fieldList = parent.fieldList;

                //this.fieldMap = parent.fieldMap;

                this.separateColumns = parent.separateColumns;

                this.targetType = parent.targetType;

                this.defaultMapName = parent.defaultMapName;

                this.targetWindowExdr = parent.targetWindowExdr;

                this.hideHeader = parent.hideHeader;

               

               

                // Create this fieldList/Map from clones of parent's

                Iterator fieldListIter = parent.fieldList.iterator();

                while (fieldListIter.hasNext()) {

                    ModelFormField parentChildField = (ModelFormField)fieldListIter.next();

                    ModelFormField childField = new ModelFormField(this);

                    childField.mergeOverrideModelFormField(parentChildField);

                    this.fieldList.add(childField);

                    this.fieldMap.put(childField.getName(), childField);

                }

            }

        }

        this.name = formElement.getAttribute("name");

        if (this.type == null || formElement.hasAttribute("type")) {

            this.type = formElement.getAttribute("type");

        }

        if (this.target == null || formElement.hasAttribute("target")) {

            setTarget( formElement.getAttribute("target") );

        }

        if (this.targetWindowExdr == null || formElement.hasAttribute("target-window")) {

            setTargetWindow(formElement.getAttribute("target-window"));

        }

        if (this.containerId == null || formElement.hasAttribute("id")) {

            this.containerId = formElement.getAttribute("id");

        }

        if (this.containerStyle == null || formElement.hasAttribute("style")) {

            this.containerStyle = formElement.getAttribute("style");

        }

        if (this.focusFieldName == null || formElement.hasAttribute("focus-field-name")) {

            this.focusFieldName = formElement.getAttribute("focus-field-name");

        }

        if (this.title == null || formElement.hasAttribute("title")) {

            this.title = formElement.getAttribute("title");

        }

        if (this.tooltip == null || formElement.hasAttribute("tooltip")) {

            this.tooltip = formElement.getAttribute("tooltip");

        }

        if (this.listName == null || formElement.hasAttribute("list-name")) {

            this.listName = formElement.getAttribute("list-name");

        }

        // if no list-name then look in the list-iterator-name; this is deprecated but we'll look at it anyway

        if (UtilValidate.isEmpty(this.listName) && formElement.hasAttribute("list-iterator-name")) {

            this.listName = formElement.getAttribute("list-iterator-name");

        }

        if (this.listEntryName == null || formElement.hasAttribute("list-entry-name")) {

            this.listEntryName = formElement.getAttribute("list-entry-name");

        }

        if (this.defaultMapName == null || formElement.hasAttribute("default-map-name")) {

            this.setDefaultMapName(formElement.getAttribute("default-map-name"));

        }

        if (this.defaultServiceName == null || formElement.hasAttribute("default-service-name")) {

            this.defaultServiceName = formElement.getAttribute("default-service-name");

        }

        if (this.defaultEntityName == null || formElement.hasAttribute("default-entity-name")) {

            this.defaultEntityName = formElement.getAttribute("default-entity-name");

        }

        if (this.formTitleAreaStyle == null || formElement.hasAttribute("form-title-area-style")) {

            this.formTitleAreaStyle = formElement.getAttribute("form-title-area-style");

        }

        if (this.formWidgetAreaStyle == null || formElement.hasAttribute("form-widget-area-style")) {

            this.formWidgetAreaStyle = formElement.getAttribute("form-widget-area-style");

        }

        if (this.defaultTitleAreaStyle == null || formElement.hasAttribute("default-title-area-style")) {

            this.defaultTitleAreaStyle = formElement.getAttribute("default-title-area-style");

        }

        if (this.defaultWidgetAreaStyle == null || formElement.hasAttribute("default-widget-area-style")) {

            this.defaultWidgetAreaStyle = formElement.getAttribute("default-widget-area-style");

        }

        if (this.oddRowStyle == null || formElement.hasAttribute("odd-row-style")) {

            this.oddRowStyle = formElement.getAttribute("odd-row-style");

        }

        if (this.evenRowStyle == null || formElement.hasAttribute("even-row-style")) {

            this.evenRowStyle = formElement.getAttribute("even-row-style");

        }

        if (this.defaultTableStyle == null || formElement.hasAttribute("default-table-style")) {

            this.defaultTableStyle = formElement.getAttribute("default-table-style");

        }

        if (this.headerRowStyle == null || formElement.hasAttribute("header-row-style")) {

            this.headerRowStyle = formElement.getAttribute("header-row-style");

        }

        if (this.defaultTitleStyle == null || formElement.hasAttribute("header-row-style")) {

            this.defaultTitleStyle = formElement.getAttribute("default-title-style");

        }

        if (this.defaultWidgetStyle == null || formElement.hasAttribute("default-widget-style")) {

            this.defaultWidgetStyle = formElement.getAttribute("default-widget-style");

        }

        if (this.defaultTooltipStyle == null || formElement.hasAttribute("default-tooltip-style")) {

            this.defaultTooltipStyle = formElement.getAttribute("default-tooltip-style");

        }

        if (this.itemIndexSeparator == null || formElement.hasAttribute("item-index-separator")) {

            this.itemIndexSeparator = formElement.getAttribute("item-index-separator");

        }

        if (this.targetType == null || formElement.hasAttribute("target-type")) {

            this.targetType = formElement.getAttribute("target-type");

        }

        if (this.defaultRequiredFieldStyle == null || formElement.hasAttribute("default-required-field-style")) {

            this.defaultRequiredFieldStyle = formElement.getAttribute("default-required-field-style");

        }

        // pagination settings

        if (this.paginateTarget == null || formElement.hasAttribute("paginate-target")) {

            setPaginateTarget(formElement.getAttribute("paginate-target"));

        }

        if (this.paginateTargetAnchor == null || formElement.hasAttribute("paginate-target-anchor")) {

            this.paginateTargetAnchor = formElement.getAttribute("paginate-target-anchor");

        }

        if (this.paginateIndexField == null || formElement.hasAttribute("paginate-index-field")) {

            setPaginateIndexField(formElement.getAttribute("paginate-index-field"));

        }

        if (this.paginateSizeField == null || formElement.hasAttribute("paginate-size-field")) {

            setPaginateSizeField(formElement.getAttribute("paginate-size-field"));

        }

        if (this.overrideListSize == null || formElement.hasAttribute("override-list-size")) {

            this.overrideListSize = new FlexibleStringExpander(formElement.getAttribute("override-list-size"));

        }

        if (this.paginatePreviousLabel == null || formElement.hasAttribute("paginate-previous-label")) {

            this.paginatePreviousLabel = new FlexibleStringExpander(formElement.getAttribute("paginate-previous-label"));

        }

        if (this.paginateNextLabel == null || formElement.hasAttribute("paginate-next-label")) {

            this.paginateNextLabel = new FlexibleStringExpander(formElement.getAttribute("paginate-next-label"));

        }

        if (this.paginatePreviousStyle == null || formElement.hasAttribute("paginate-previous-style")) {

            setPaginatePreviousStyle(formElement.getAttribute("paginate-previous-style"));

        }

        if (this.paginateNextStyle == null || formElement.hasAttribute("paginate-next-style")) {

            setPaginateNextStyle(formElement.getAttribute("paginate-next-style"));

        }

       

        this.paginate = "true".equals(formElement.getAttribute("paginate"));

        this.skipStart = "true".equals(formElement.getAttribute("skip-start"));

        this.skipEnd = "true".equals(formElement.getAttribute("skip-end"));

        this.hideHeader = "true".equals(formElement.getAttribute("hide-header"));

        if (formElement.hasAttribute("separate-columns")) {

            String sepColumns = formElement.getAttribute("separate-columns");

            if (sepColumns != null && sepColumns.equalsIgnoreCase("true"))

                separateColumns = true;

        }

        if (formElement.hasAttribute("use-row-submit")) {

            String rowSubmit = formElement.getAttribute("use-row-submit");

            if (rowSubmit != null && rowSubmit.equalsIgnoreCase("true"))

                useRowSubmit = true;

        }

        if (formElement.hasAttribute("view-size")) {

            setDefaultViewSize(formElement.getAttribute("view-size"));

        }

        if (this.rowCountExdr == null || formElement.hasAttribute("row-count")) {

            this.rowCountExdr = new FlexibleStringExpander(formElement.getAttribute("row-count"));

        }

        // alt-target

        List altTargetElements = UtilXml.childElementList(formElement, "alt-target");

        Iterator altTargetElementIter = altTargetElements.iterator();

        while (altTargetElementIter.hasNext()) {

            Element altTargetElement = (Element) altTargetElementIter.next();

            AltTarget altTarget = new AltTarget(altTargetElement);

            this.addAltTarget(altTarget);

        }

           

        // auto-fields-service

        List autoFieldsServiceElements = UtilXml.childElementList(formElement, "auto-fields-service");

        Iterator autoFieldsServiceElementIter = autoFieldsServiceElements.iterator();

        while (autoFieldsServiceElementIter.hasNext()) {

            Element autoFieldsServiceElement = (Element) autoFieldsServiceElementIter.next();

            AutoFieldsService autoFieldsService = new AutoFieldsService(autoFieldsServiceElement);

            this.addAutoFieldsFromService(autoFieldsService, dispatcher);

        }

        // auto-fields-entity

        List autoFieldsEntityElements = UtilXml.childElementList(formElement, "auto-fields-entity");

        Iterator autoFieldsEntityElementIter = autoFieldsEntityElements.iterator();

        while (autoFieldsEntityElementIter.hasNext()) {

            Element autoFieldsEntityElement = (Element) autoFieldsEntityElementIter.next();

            AutoFieldsEntity autoFieldsEntity = new AutoFieldsEntity(autoFieldsEntityElement);

            this.addAutoFieldsFromEntity(autoFieldsEntity, delegator);

        }

        // read in add field defs, add/override one by one using the fieldList and fieldMap

        List fieldElements = UtilXml.childElementList(formElement, "field");

        Iterator fieldElementIter = fieldElements.iterator();

        String thisType = this.getType();

        while (fieldElementIter.hasNext()) {

            Element fieldElement = (Element) fieldElementIter.next();

            ModelFormField modelFormField = new ModelFormField(fieldElement, this);

            ModelFormField.FieldInfo fieldInfo = modelFormField.getFieldInfo();

            if (thisType.equals("multi") && fieldInfo instanceof ModelFormField.SubmitField) {

               multiSubmitField = modelFormField;

            } else {

                modelFormField = this.addUpdateField(modelFormField);

            }

            //Debug.logInfo("Added field " + modelFormField.getName() + " from def, mapName=" + modelFormField.getMapName(), module);

        }

        // Create the default field group

        defaultFieldGroup = new FieldGroup(null, this);

        // get the sort-order

        Element sortOrderElement = UtilXml.firstChildElement(formElement, "sort-order");

        if (sortOrderElement != null) {

            FieldGroup lastFieldGroup = new FieldGroup(null, this);

            this.fieldGroupList.add(lastFieldGroup);

            // read in sort-field

            List sortFieldElements = UtilXml.childElementList(sortOrderElement);

            Iterator sortFieldElementIter = sortFieldElements.iterator();

            while (sortFieldElementIter.hasNext()) {

                Element sortFieldElement = (Element) sortFieldElementIter.next();

                String tagName = sortFieldElement.getTagName();

                if (tagName.equals("sort-field")) {

                    String fieldName = sortFieldElement.getAttribute("name");

                    this.sortOrderFields.add(fieldName );

                    this.fieldGroupMap.put(fieldName, lastFieldGroup);

                } else if (tagName.equals("banner")) {

                    Banner thisBanner = new Banner(sortFieldElement, this);

                    this.fieldGroupList.add(thisBanner);

                   

                    lastFieldGroup = new FieldGroup(null, this);

                    this.fieldGroupList.add(lastFieldGroup);

                } else if (tagName.equals("field-group")) {

                    FieldGroup thisFieldGroup = new FieldGroup(sortFieldElement, this);

                    this.fieldGroupList.add(thisFieldGroup);

                   

                    lastFieldGroup = new FieldGroup(null, this);

                    this.fieldGroupList.add(lastFieldGroup);

                }

            }

        }

        // reorder fields according to sort order

        if (sortOrderFields.size() > 0) {

            List sortedFields = new ArrayList(this.fieldList.size());

            Iterator sortOrderFieldIter = this.sortOrderFields.iterator();

            while (sortOrderFieldIter.hasNext()) {

                String fieldName = (String) sortOrderFieldIter.next();

                if (UtilValidate.isEmpty(fieldName)) {

                    continue;

                }

                // get all fields with the given name from the existing list and put them in the sorted list

                Iterator fieldIter = this.fieldList.iterator();

                while (fieldIter.hasNext()) {

                    ModelFormField modelFormField = (ModelFormField) fieldIter.next();

                    if (fieldName.equals(modelFormField.getName())) {

                        // matched the name; remove from the original last and add to the sorted list

                        fieldIter.remove();

                        sortedFields.add(modelFormField);

                    }

                }

            }

            // now add all of the rest of the fields from fieldList, ie those that were not explicitly listed in the sort order

            sortedFields.addAll(this.fieldList);

            // sortedFields all done, set fieldList

            this.fieldList = sortedFields;

        }

        // read all actions under the "actions" element

        Element actionsElement = UtilXml.firstChildElement(formElement, "actions");

        if (actionsElement != null) {

            this.actions = ModelFormAction.readSubActions(this, actionsElement);

        }

        // read all actions under the "row-actions" element

        Element rowActionsElement = UtilXml.firstChildElement(formElement, "row-actions");

        if (rowActionsElement != null) {

            this.rowActions = ModelFormAction.readSubActions(this, rowActionsElement);

        }

    }

    /**

     * add/override modelFormField using the fieldList and fieldMap

     *

     * @return The same ModelFormField, or if merged with an existing field, the existing field.

     */

    public ModelFormField addUpdateField(ModelFormField modelFormField) {

        if (!modelFormField.isUseWhenEmpty()) {

            // is a conditional field, add to the List but don't worry about the Map

            //for adding to list, see if there is another field with that name in the list and if so, put it before that one

            boolean inserted = false;

            for (int i = 0; i < this.fieldList.size(); i++) {

                ModelFormField curField = (ModelFormField) this.fieldList.get(i);

                if (curField.getName() != null && curField.getName().equals(modelFormField.getName())) {

                    this.fieldList.add(i, modelFormField);

                    inserted = true;

                    break;

                }

            }

            if (!inserted) {

                this.fieldList.add(modelFormField);

            }

            return modelFormField;

        } else {

            // not a conditional field, see if a named field exists in Map

            ModelFormField existingField = (ModelFormField) this.fieldMap.get(modelFormField.getName());

            if (existingField != null) {

                // does exist, update the field by doing a merge/override

                existingField.mergeOverrideModelFormField(modelFormField);

                return existingField;

            } else {

                // does not exist, add to List and Map

                this.fieldList.add(modelFormField);

                this.fieldMap.put(modelFormField.getName(), modelFormField);

                return modelFormField;

            }

        }

    }

    public void addAltTarget(AltTarget altTarget) {

        altTargets.add(altTarget);

    }

    public void addAutoFieldsFromService(AutoFieldsService autoFieldsService, LocalDispatcher dispatcher) {

        autoFieldsServices.add(autoFieldsService);

        // read service def and auto-create fields

        ModelService modelService = null;

        try {

            modelService = dispatcher.getDispatchContext().getModelService(autoFieldsService.serviceName);

        } catch (GenericServiceException e) {

            String errmsg = "Error finding Service with name " + autoFieldsService.serviceName + " for auto-fields-service in a form widget";

            Debug.logError(e, errmsg, module);

            throw new IllegalArgumentException(errmsg);

        }

        List modelParams = modelService.getInModelParamList();

        Iterator modelParamIter = modelParams.iterator();

        while (modelParamIter.hasNext()) {

            ModelParam modelParam = (ModelParam) modelParamIter.next();

            // skip auto params that the service engine populates...

            if ("userLogin".equals(modelParam.name) || "locale".equals(modelParam.name)) {

                continue;

            }

            if (modelParam.formDisplay) {

                if (UtilValidate.isNotEmpty(modelParam.entityName) && UtilValidate.isNotEmpty(modelParam.fieldName)) {

                    ModelEntity modelEntity = delegator.getModelEntity(modelParam.entityName);

                    if (modelEntity != null) {

                        ModelField modelField = modelEntity.getField(modelParam.fieldName);

                        if (modelField != null) {

                            // okay, populate using the entity field info...

                            ModelFormField modelFormField = this.addFieldFromEntityField(modelEntity, modelField, autoFieldsService.defaultFieldType);

                            if (UtilValidate.isNotEmpty(autoFieldsService.mapName)) {

                                modelFormField.setMapName(autoFieldsService.mapName);

                            }

                            // continue to skip creating based on service param

                            continue;

                        }

                    }

                }

                ModelFormField modelFormField = this.addFieldFromServiceParam(modelService, modelParam, autoFieldsService.defaultFieldType);

                if (UtilValidate.isNotEmpty(autoFieldsService.mapName)) {

                    modelFormField.setMapName(autoFieldsService.mapName);

                }

            }

        }

    }

    public ModelFormField addFieldFromServiceParam(ModelService modelService, ModelParam modelParam, String defaultFieldType) {

        // create field def from service param def

        ModelFormField newFormField = new ModelFormField(this);

        newFormField.setName(modelParam.name);

        newFormField.setServiceName(modelService.name);

        newFormField.setAttributeName(modelParam.name);

        newFormField.setTitle(modelParam.formLabel);

        newFormField.induceFieldInfoFromServiceParam(modelService, modelParam, defaultFieldType);

        return this.addUpdateField(newFormField);

    }

    public void addAutoFieldsFromEntity(AutoFieldsEntity autoFieldsEntity, GenericDelegator delegator) {

        autoFieldsEntities.add(autoFieldsEntity);

        // read entity def and auto-create fields

        ModelEntity modelEntity = delegator.getModelEntity(autoFieldsEntity.entityName);

        if (modelEntity == null) {

            throw new IllegalArgumentException("Error finding Entity with name " + autoFieldsEntity.entityName + " for auto-fields-entity in a form widget");

        }

        Iterator modelFieldIter = modelEntity.getFieldsIterator();

        while (modelFieldIter.hasNext()) {

            ModelField modelField = (ModelField) modelFieldIter.next();

            if (modelField.getIsAutoCreatedInternal()) {

                // don't ever auto-add these, should only be added if explicitly referenced

                continue;

            }

            ModelFormField modelFormField = this.addFieldFromEntityField(modelEntity, modelField, autoFieldsEntity.defaultFieldType);

            if (UtilValidate.isNotEmpty(autoFieldsEntity.mapName)) {

                modelFormField.setMapName(autoFieldsEntity.mapName);

            }

        }

    }

    public ModelFormField addFieldFromEntityField(ModelEntity modelEntity, ModelField modelField, String defaultFieldType) {

        // create field def from entity field def

        ModelFormField newFormField = new ModelFormField(this);

        newFormField.setName(modelField.getName());

        newFormField.setEntityName(modelEntity.getEntityName());

        newFormField.setFieldName(modelField.getName());

        newFormField.induceFieldInfoFromEntityField(modelEntity, modelField, defaultFieldType);

        return this.addUpdateField(newFormField);

    }

    /**

     * Renders this form to a String, i.e. in a text format, as defined with the

     * FormStringRenderer implementation.

     *

     * @param buffer The StringBuffer that the form text will be written to

     * @param context Map containing the form context; the following are

     *   reserved words in this context: parameters (Map), isError (Boolean),

     *   itemIndex (Integer, for lists only, otherwise null), bshInterpreter,

     *   formName (String, optional alternate name for form, defaults to the

     *   value of the name attribute)

     * @param formStringRenderer An implementation of the FormStringRenderer

     *   interface that is responsible for the actual text generation for

     *   different form elements; implementing your own makes it possible to

     *   use the same form definitions for many types of form UIs

     */

    public void renderFormString(StringBuffer buffer, Map context, FormStringRenderer formStringRenderer) {

        ModelFormAction.runSubActions(this.actions, context);

       

        // if this is a list form, don't useRequestParameters

        if ("list".equals(this.type) || "multi".equals(this.type)) {

            context.put("useRequestParameters", Boolean.FALSE);

        }

        // find the highest position number to get the max positions used

        int positions = 1;

        Iterator fieldIter = this.fieldList.iterator();

        while (fieldIter.hasNext()) {

            ModelFormField modelFormField = (ModelFormField) fieldIter.next();

            int curPos = modelFormField.getPosition();

            if (curPos > positions) {

                positions = curPos;

            }

            ModelFormField.FieldInfo currentFieldInfo = modelFormField.getFieldInfo();

            if (currentFieldInfo != null) {

                ModelFormField fieldInfoFormField = currentFieldInfo.getModelFormField();

                if (fieldInfoFormField != null) {

                    fieldInfoFormField.setModelForm(this);

                }

            } else {

                throw new IllegalArgumentException("Error rendering form, a field has no FieldInfo, ie no sub-element for the type of field for field named: " + modelFormField.getName());

            }

       }

        if ("single".equals(this.type)) {

            this.renderSingleFormString(buffer, context, formStringRenderer, positions);

        } else if ("list".equals(this.type)) {

            this.renderListFormString(buffer, context, formStringRenderer, positions);

        } else if ("multi".equals(this.type)) {

            this.renderMultiFormString(buffer, context, formStringRenderer, positions);

        } else if ("upload".equals(this.type)) {

            this.renderSingleFormString(buffer, context, formStringRenderer, positions);

        } else {

            throw new IllegalArgumentException("The type " + this.getType() + " is not supported for form with name " + this.getName());

        }

    }

    public void renderSingleFormString(StringBuffer buffer, Map context, FormStringRenderer formStringRenderer, int positions) {

        List tempFieldList = FastList.newInstance();

        tempFieldList.addAll(this.fieldList);

       

        // Check to see if there is a field, same name and same use-when (could come from extended form)

        for (int j = 0; j < tempFieldList.size(); j++) {

            ModelFormField modelFormField = (ModelFormField) tempFieldList.get(j);

            if (!modelFormField.isUseWhenEmpty()) {

                boolean shouldUse1 = modelFormField.shouldUse(context);

                for (int i = j+1; i < tempFieldList.size(); i++) {

                    ModelFormField curField = (ModelFormField) tempFieldList.get(i);

                    if (curField.getName() != null && curField.getName().equals(modelFormField.getName())) {

                        boolean shouldUse2 = curField.shouldUse(context);

                        if (shouldUse1 == shouldUse2) {

                            tempFieldList.remove(i--);

                        }

                    } else {

                        continue;

                    }

                }

            }

        }

        Set alreadyRendered = new TreeSet();

        FieldGroup lastFieldGroup = null;

        // render form open

        if (!skipStart) formStringRenderer.renderFormOpen(buffer, context, this);

        // render all hidden & ignored fields

        this.renderHiddenIgnoredFields(buffer, context, formStringRenderer, alreadyRendered);

        // render formatting wrapper open

        // This should be covered by fieldGroup.renderStartString

        //formStringRenderer.renderFormatSingleWrapperOpen(buffer, context, this);

        // render each field row, except hidden & ignored rows

        Iterator fieldIter = tempFieldList.iterator();

        ModelFormField lastFormField = null;

        ModelFormField currentFormField = null;

        ModelFormField nextFormField = null;

        if (fieldIter.hasNext()) {

            currentFormField = (ModelFormField) fieldIter.next();

        }

        if (fieldIter.hasNext()) {

            nextFormField = (ModelFormField) fieldIter.next();

        }

       

        FieldGroup currentFieldGroup = null;

        String currentFieldGroupName = null;

        String lastFieldGroupName = null;

        if (currentFormField != null) {

            currentFieldGroup = (FieldGroup)fieldGroupMap.get(currentFormField.getFieldName());

            if (currentFieldGroup == null) {

                currentFieldGroup = defaultFieldGroup;

            }

            if (currentFieldGroup != null) {

                currentFieldGroupName = currentFieldGroup.getId();

            }

        }

       

           

        boolean isFirstPass = true;

        boolean haveRenderedOpenFieldRow = false;

        while (currentFormField != null) {

            // do the check/get next stuff at the beginning so we can still use the continue stuff easily

            // don't do it on the first pass though...

            if (isFirstPass) {

                isFirstPass = false;

                List inbetweenList = getInbetweenList(lastFieldGroup, currentFieldGroup);

                Iterator iter = inbetweenList.iterator();

                while (iter.hasNext()) {

                    Object obj = iter.next();

                    if (obj instanceof ModelForm.Banner) {

                        ((ModelForm.Banner) obj).renderString(buffer, context, formStringRenderer);  

                    } else {

                        // no need to open and close an empty table, so skip that call

                        formStringRenderer.renderFieldGroupOpen(buffer, context, (FieldGroup) obj);

                        formStringRenderer.renderFieldGroupClose(buffer, context, (FieldGroup) obj);