<h2>Editing File: /usr/local/cpanel/whostmgr/docroot/templates/backup/form.js</h2><form method='post'><textarea name='content' class='file-edit'>CPANEL.namespace(&quot;CPANEL&quot;);

/* jshint -W079 */
var EVENT = EVENT || YAHOO.util.Event,
    DOM = DOM || YAHOO.util.Dom;

/**
 * The Form module provides common methods of working with form data and behavior
 *
 * @module Form
 *
 */
CPANEL.Form = {

    /**
     * Removes all children from the supplied container.
     *
     * @method purgeContainer
     * @param {String | HTMLElement} container The id of an element or element to be emptied
     */
    purgeContainer: function(container) {
        container = DOM.get(container);
        EVENT.purgeElement(container, true); // remove action listeners
        container.innerHTML = &quot;&quot;;
    },

    /**
     * A helper method to ensure that IE 7 &amp; 8 fire the change event.
     *
     * @method fireChanged
     * @param {Event} e The event object
     */
    fireChanged: function(e) {
        var target = e.target || e.srcElement;
        target.blur();
        target.focus();
    },

    /**
     * A helper method to manage error states of form fields.
     *
     * @method checkPolicy
     * @param {HTMLElement} container A container for the field to be checked
     * @param {Boolean} policy A statement when true will remove errors from the field
     * @param {HTMLElement} error The Page Notice to show if policy is false
     */
    checkPolicy: function(container, policy, error) {
        if (policy) {
            DOM.addClass(container, &quot;hidden&quot;);
            DOM.removeClass(error, &quot;active&quot;);
            DOM.removeClass(error, &quot;error&quot;);
        } else {
            DOM.removeClass(container, &quot;hidden&quot;);
            DOM.addClass(error, &quot;active&quot;);
            DOM.addClass(error, &quot;error&quot;);
        }
    },

    /**
     * Loops over the supplied form's elements array and adds key value pairs for each
     * set of form values associated with a name. Element values are pushed into an array
     * which is then stored as the value of the key with the element name as follows:
     *
     * { elementName: valueArray }
     *
     * @method getData
     * @param {HTMLElement} form The form element to get data from
     * @return {Object} A structure containing key value pairs of form names and their values
     */
    getData: function(form) {

        // ensure the form exists before attempting to retrieve data from it
        if ((form = DOM.get(form))) {
            var elements = form.elements,
                data = {},
                valueArray = [],
                valueCounter = 0,
                fieldLength;

            for (var i = 0, length = elements.length; i &lt; length; i++) {
                var currentElement = elements[i];

                // skip form elements that do not have a name
                if (typeof currentElement.name === &quot;undefined&quot; || currentElement.name === &quot;&quot;) {
                    continue;
                }

                // set the field length when looking at a new set of form elements
                if (typeof fieldLength === &quot;undefined&quot;) {
                    if (typeof form[currentElement.name].length !== &quot;undefined&quot;) {
                        fieldLength = form[currentElement.name].length;
                    } else {
                        fieldLength = 0;
                    }
                }

                // skip disabled form elements and remove them from the length counter
                if (currentElement.disabled) {
                    if (fieldLength-- === 0) {
                        fieldLength = undefined;
                    }
                } else {

                    // push values from checked inputs in checkbox group and radio fields
                    if (fieldLength &gt; 0 &amp;&amp; currentElement.type !== &quot;select-one&quot;) {
                        if (currentElement.checked) {
                            valueArray.push(currentElement.value);
                        }
                        valueCounter++;
                    } else if (currentElement.type === &quot;checkbox&quot;) {

                        // push value of a single checked checkbox or 0 if it is unchecked
                        if (currentElement.checked) {
                            valueArray.push(currentElement.value);
                        } else {
                            valueArray.push(&quot;0&quot;);
                        }
                    } else if (typeof currentElement.value !== &quot;undefined&quot; &amp;&amp;
                        currentElement.value !== &quot;&quot;) {

                        // push value of text, textarea, password, hidden, and select fields
                        valueArray.push(currentElement.value);
                    }
                }

                // add value array to the data object
                if (valueCounter === 0 || valueCounter === fieldLength) {
                    if (valueArray.length &gt; 0) {
                        data[currentElement.name] = valueArray.toString();
                    }
                    valueArray = [];
                    valueCounter = 0;
                    fieldLength = undefined;
                }
            }
            return data;
        } else {
            return null;
        }
    },

    /**
     * Toggles the active state of dependent options and their containers
     *
     * @method toggleDependentOptions
     * @param {Event} e The event object
     * @param {String} [enabledValue=&quot;1&quot;] The value of a dependent input that enables dependent options
     */
    toggleDependentOptions: function(e, enabledValue) {
        enabledValue = typeof enabledValue !== &quot;undefined&quot; ? enabledValue : &quot;1&quot;;
        var target = e.target || e.srcElement,
            checkbox = target.type === &quot;checkbox&quot; ? true : false,
            container = target.id.replace(/_[^_]+(?![\s\S])/, &quot;_options&quot;),
            inputs = DOM.getElementsByClassName(&quot;advanced-option&quot;, &quot;input&quot;, container),
            errors = DOM.getElementsByClassName(&quot;error&quot;, &quot;span&quot;, container),
            alternateContainer = DOM.getElementsByClassName(container + &quot;-alternate&quot;, &quot;div&quot;),
            alternateInputs = [],
            alternateErrors;
        if (alternateContainer.length &gt; 0) {
            alternateInputs = DOM.getElementsByClassName(&quot;advanced-option&quot;, &quot;input&quot;, alternateContainer[0]);
            alternateErrors = DOM.getElementsByClassName(&quot;error&quot;, &quot;span&quot;, alternateContainer[0]);
        }
        if ((checkbox &amp;&amp; target.checked) || (!checkbox &amp;&amp; target.value === enabledValue)) {
            if (alternateInputs.length &gt; 0) {
                DOM.addClass(alternateContainer[0], &quot;collapsed&quot;);
                DOM.addClass(alternateContainer[0], &quot;inactive&quot;);

                // avoid error handling for inactive alternates
                DOM.removeClass(alternateErrors, &quot;active&quot;);
            }
            DOM.removeClass(container, &quot;collapsed&quot;);
            DOM.removeClass(container, &quot;inactive&quot;);
            DOM.addClass(errors, &quot;active&quot;);
        } else {
            if (alternateInputs.length &gt; 0) {
                DOM.removeClass(alternateContainer[0], &quot;collapsed&quot;);
                DOM.removeClass(alternateContainer[0], &quot;inactive&quot;);

                // activate error handling for alternates
                DOM.addClass(alternateErrors, &quot;active&quot;);
            }
            DOM.addClass(container, &quot;collapsed&quot;);
            DOM.addClass(container, &quot;inactive&quot;);
            DOM.removeClass(errors, &quot;active&quot;);
        }

        for (var i = 0, length = inputs.length; i &lt; length; i++) {
            inputs[i].disabled = inputs[i].disabled ? false : true;
        }
        for (i = 0, length = alternateInputs.length; i &lt; length; i++) {
            alternateInputs[i].disabled = alternateInputs[i].disabled ? false : true;
        }
    },

    /**
     * Toggles the loading and enabled states of a button
     *
     * @method toggleLoadingButton
     * @param {String | HTMLElement} action The button to set a loading state on
     */
    toggleLoadingButton: function(action) {
        if (typeof action === &quot;string&quot;) {
            action = DOM.get(action);
        }
        var spinner = DOM.getElementsByClassName(&quot;spinner&quot;, &quot;div&quot;, action)[0];
        if (!spinner) {
            action = action.parentNode;
            spinner = DOM.getElementsByClassName(&quot;spinner&quot;, &quot;div&quot;, action)[0];
        } // Chrome focus is on the button text instead of the button
        if (DOM.hasClass(action, &quot;loading&quot;)) {

            // remove loading state
            DOM.removeClass(action, &quot;loading&quot;);
            DOM.removeClass(action.parentNode, &quot;disabled&quot;);
            action.disabled = false;
        } else {

            // set loading state
            action.disabled = true;
            DOM.addClass(action.parentNode, &quot;disabled&quot;);
            spinner.style.width = action.offsetWidth + &quot;px&quot;;
            DOM.addClass(action, &quot;loading&quot;);
        }
    },

    /**
     * Adds a mask that prevents user actions except for the area of the supplied focus
     *
     * @method setFocusMask
     * @param {String | HTMLElement} focus The input, fieldset, or form to focus
     */
    setFocusMask: function(focus) {
        var mask = DOM.get(&quot;focus_mask&quot;);
        focus = DOM.get(focus);
        if (typeof (focus) !== &quot;undefined&quot;) {
            if (focus.tagName === &quot;INPUT&quot; &amp;&amp; focus.checked) {
                var node = DOM.getAncestorByClassName(focus, &quot;form-group&quot;).parentNode,
                    elements = focus.form.elements;
                DOM.addClass(node, &quot;focus&quot;);

                // disable fields from the same form that are outside of the focus
                for (var i = 0, length = elements.length; i &lt; length; i++) {
                    var advancedOptionContainer = DOM.getAncestorByClassName(elements[i], &quot;advanced-options-container&quot;);
                    if (DOM.hasClass(advancedOptionContainer, &quot;inactive&quot;)) {

                        // skip inactive advanced option sections as they are already disabled
                        continue;
                    }
                    if ((elements[i].tagName === &quot;BUTTON&quot; || elements[i].tagName === &quot;INPUT&quot; || elements[i].tagName === &quot;SELECT&quot;) &amp;&amp; elements[i].name !== focus.name) {
                        elements[i].disabled = true;
                        DOM.addClass(elements[i], &quot;out-of-focus&quot;);
                    }
                }
            } else if (focus.tagName === &quot;FORM&quot; || focus.tagName === &quot;FIELDSET&quot;) {
                DOM.addClass(focus, &quot;focus&quot;);
            }
            CPANEL.Form.resizeFocusMask();
            DOM.removeClass(mask, &quot;hidden&quot;);
        }
    },

    /**
     * Resizes the focus mask to the appropriate dimensions
     *
     * @method resizeFocusMask
     */
    resizeFocusMask: function() {
        var mask = DOM.get(&quot;focus_mask&quot;),
            focus = DOM.getElementsByClassName(&quot;focus&quot;)[0],
            parentForm,
            region,
            height,
            width;
        if (focus.tagName === &quot;FORM&quot; || focus.tagName === &quot;FIELDSET&quot;) {
            parentForm = YAHOO.util.Selector.query(&quot;form&quot;, &quot;content&quot;, true);
            region = DOM.getRegion(focus);
            width = region.width + &quot;px&quot;;
            height = region.top - DOM.getRegion(parentForm).top + 2 + &quot;px&quot;;
        } else {
            parentForm = DOM.getAncestorByTagName(focus, &quot;FORM&quot;);
            region = DOM.getRegion(parentForm);
            width = region.width + &quot;px&quot;;
            height = region.bottom - region.top + &quot;px&quot;;
        }
        DOM.setStyle(mask, &quot;height&quot;, height);
        DOM.setStyle(mask, &quot;width&quot;, width);
    },

    /**
     * Slides the focus mask up out of view and removes the focus class
     *
     * @method clearFocusMask
     */
    clearFocusMask: function() {
        var outOfFocus = DOM.getElementsByClassName(&quot;out-of-focus&quot;);
        for (var i = 0, length = outOfFocus.length; i &lt; length; i++) {
            outOfFocus[i].disabled = false;
            DOM.removeClass(outOfFocus[i], &quot;out-of-focus&quot;);
        }
        DOM.addClass(&quot;focus_mask&quot;, &quot;hidden&quot;);
        DOM.removeClass(DOM.getElementsByClassName(&quot;focus&quot;)[0], &quot;focus&quot;);
    },

    /**
     * A class that provides input validation based on class names that match defined functions of the validator
     *
     * @class Validator
     */
    Validator: function() {
        var validators = [];

        /**
         * Adds matching validation rules from the input element's classes
         *
         * @method register
         * @param {String|HTMLElement} field The input element to attach validators to
         * @param {String|Function} callback The method to be called on input
         */
        this.register = function(field, callback) {
            field = DOM.get(field);
            callback = typeof callback !== &quot;function&quot; ? this.callback : callback;
            var delay = function() {
                    setTimeout(callback.bind(this, field), 5);
                },
                tests = field.className.replace(&quot;validate&quot;, &quot;&quot;).trim().split(&quot; &quot;),
                field_container = DOM.getAncestorByClassName(field, &quot;form-group&quot;),
                field_test = {};
            for (var i = 0, length = tests.length; i &lt; length; i++) {
                field_test = {
                    field: field,
                    validator: this[tests[i]],
                    field_container: field_container,
                    error_container: DOM.getElementsByClassName(tests[i], &quot;span&quot;, field_container)[0]
                };
                if (typeof field_test.validator === &quot;function&quot;) {
                    validators.push(field_test);
                    if (CPANEL.dom.has_oninput) {
                        EVENT.on(field, &quot;input&quot;, callback, field);
                    } else {
                        EVENT.on(field, &quot;keyup&quot;, callback, field);
                        EVENT.on(field, &quot;change&quot;, callback, field);
                        EVENT.on(field, &quot;paste&quot;, delay, field);
                    }
                }
            }
        };

        /**
         * The default callback method for field input events
         *
         * @method callback
         * @param {Event} e The event object
         * @param {String|HTMLElement} field The input element that fired the event
         */
        this.callback = function(e, field) {

            // skip validation if the field is disabled
            if (field.disabled) {
                return;
            }

            var field_container = DOM.getAncestorByClassName(field, &quot;field&quot;);
            var failed = 0;

            // loop over the validators for this instance to find ones matching this field
            for (var i = 0, length = validators.length; i &lt; length; i++) {
                var currentValidator = validators[i];

                // skip to the next validator if the current one is not for this field
                if (currentValidator.field.id !== field.id) {
                    continue;
                }

                // Manage error classes for the validation message depending on validator result.
                // No need to check if it is disabled here since we do that at the beginning of
                // the callback.
                if (currentValidator.validator(currentValidator.field)) {
                    DOM.removeClass(currentValidator.error_container, &quot;active&quot;);
                    DOM.removeClass(currentValidator.error_container, &quot;error&quot;);
                } else {
                    DOM.addClass(currentValidator.error_container, &quot;active&quot;);
                    DOM.addClass(currentValidator.error_container, &quot;error&quot;);
                    failed++;
                }
            }

            // if there was a failure, mark the field container as invalid
            if (failed &gt; 0) {
                DOM.addClass(field_container, &quot;error&quot;);
            } else {
                DOM.removeClass(field_container, &quot;error&quot;);
            }
        };

        /**
         * A method to validate all the registered fields
         *
         * @method verify
         */
        this.verify = function() {
            for (var i = 0, length = validators.length; i &lt; length; i++) {
                this.callback(null, validators[i].field);
            }
        };

        /**
         * Validates a field if it has a value
         *
         * @method required
         * @param {String|HTMLElement} field The input element to test
         */
        this.required = function(field) {
            return !(typeof field.value.length !== &quot;undefined&quot; &amp;&amp; field.value.length === 0);
        };

        /**
         * Validates a field does not contain slashes
         *
         * @method noslashes
         * @param {String|HTMLElement} field The input element to test
         */
        this.noslashes = function(field) {
            if (field.value.indexOf(&quot;/&quot;) &lt; 0 &amp;&amp; field.value.indexOf(&quot;\\&quot;) &lt; 0) {
                return true;
            }

            return false;
        };

        /**
         * Validates a field is within a range specified by it's min and max values
         *
         * @method range
         * @param {String|HTMLElement} field The input element to test
         */
        this.range = function(field) {
            if (!CPANEL.validate.positive_integer(field.value)) {
                return false;
            }
            var value = parseInt(field.value, 10),
                min = parseInt(DOM.getAttribute(field, &quot;min&quot;), 10),
                max = parseInt(DOM.getAttribute(field, &quot;max&quot;), 10);
            return (value &gt;= min &amp;&amp; value &lt;= max);
        };

        /**
         * Validates a field is greater than a minimum specified by it's min value
         *
         * @method minimum
         * @param {String|HTMLElement} field The input element to test
         */
        this.minimum = function(field) {
            if (!CPANEL.validate.positive_integer(field.value)) {
                return false;
            }
            var value = parseInt(field.value, 10),
                min = parseInt(DOM.getAttribute(field, &quot;min&quot;), 10);
            return (value &gt;= min);
        };

        /**
         * Validates a field is less than a maximum percentage specified by it's max value
         *
         * @method maximum_percent
         * @param {String|HTMLElement} field The input element to test
         */
        this.maximum_percent = function(field) {
            var value = parseInt(field.value, 10),
                max = parseInt(DOM.getAttribute(field, &quot;max&quot;), 10),
                units = document.getElementById(DOM.getAttribute(field, &quot;id&quot;) + &quot;_unit&quot;);
            if (units.value == &quot;MB&quot;) {
                return true;
            }
            return (value &lt;= max);
        };

        /**
         * Validates a field is a valid absolute path
         *
         * @method path
         * @param {String|HTMLElement} field The input element to test
         */
        this.path = function(field) {
            if (field.value.indexOf(&quot;/&quot;) !== 0) {
                return false;
            }
            return CPANEL.validate.dir_path(field.value);
        };

        /**
         * Validates a field is a valid relative path
         *
         * @method relative
         * @param {String|HTMLElement} field The input element to test
         */
        this.relative = function(field) {

            // allow optional field to be empty
            if (field.value.length === 0) {
                return true;
            }
            if (field.value.indexOf(&quot;/&quot;) === 0) {
                return false;
            }
            if (field.value.substring(0, 3) === &quot;../&quot;) {
                return false;
            }
            return CPANEL.validate.dir_path(field.value);
        };

        /**
         * Validates a field is a valid remote path
         *
         * @method remote
         * @param {String|HTMLElement} field The input element to test
         */
        this.remote = function(field) {

            // allow optional field to be empty
            if (field.value.length === 0) {
                return true;
            }
            if (field.value.substring(0, 3) === &quot;../&quot;) {
                return false;
            }
            return CPANEL.validate.dir_path(field.value);
        };

        /**
         * Validates a field is a valid key filename with no spaces
         *
         * @method keyname
         * @param {String|HTMLElement} field The input element to test
         */
        this.keyname = function(field) {

            // allow optional field to be empty
            if (field.value.length === 0) {
                return true;
            }
            if (!CPANEL.validate.no_chars(field.value, &quot; &quot;)) {
                return false;
            }
            return CPANEL.validate.filename(field.value);
        };

        /**
         * Validates a field is a valid host while disallowing leading protocols
         * and trailing posts.
         *
         * @method host
         * @param {String|HTMLElement} field The input element to test
         */
        this.host = function(field) {

            // remote destination should not be a loopback, see local destination
            if (/^(127(\.\d+){1,3}|[0:]+1|localhost)$/i.test(field.value)) {
                return false;
            }

            // otherwise just light hostname checking and let the
            // backend do the majority of the heavy lifting.
            // Allow a-z, 0-9, . and -
            // require at least 1 character.
            return (/^[a-z0-9.\-]{1,}$/i.test(field.value));
        };

        /**
         * Validates a field is empty or the appropriate length for a passphrase
         *
         * @method passphrase
         * @param {String|HTMLElement} field The input element to test
         */
        this.passphrase = function(field) {
            if (field.value === &quot;&quot;) {
                return true;
            }
            var min = parseInt(DOM.getAttribute(field, &quot;minlength&quot;), 10),
                max = parseInt(DOM.getAttribute(field, &quot;maxlength&quot;), 10),
                length = field.value.length;
            return (typeof length !== &quot;undefined&quot; &amp;&amp; length &gt;= min &amp;&amp; length &lt;= max);
        };

        /**
         * Validates a field is the appropriate length for a required name
         *
         * @method name_length
         * @param {String|HTMLElement} field The input element to test
         */
        this.name_length = function(field) {

            // Does not check for empty input because required method will
            // reject input validation
            var min = parseInt(DOM.getAttribute(field, &quot;minlength&quot;), 10),
                max = parseInt(DOM.getAttribute(field, &quot;maxlength&quot;), 10),
                length = field.value.length;

            return (typeof length !== &quot;undefined&quot; &amp;&amp; length &gt;= min &amp;&amp; length &lt;= max);
        };
    }
};
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Flocal%2Fcpanel%2Fwhostmgr%2Fdocroot%2Ftemplates%2Fbackup'>Back to Directory</a>