Mini Shell Moded By TiGER HeX

//var/www/ridazz/notadmin/setup/scripts.js

/**
 * functions used in setup script
 * 
 * @version $Id$
 */

// show this window in top frame
if (top != self) {
    window.top.location.href = location;
}

// default values for fields
var defaultValues = {};

// language strings
var PMA_messages = {};

/**
 * Returns field type
 *
 * @param Element field
 */
function getFieldType(field) {
    if (field.tagName == 'INPUT') {
        return field.getProperty('type');
    } else if (field.tagName == 'SELECT') {
        return 'select';
    } else if (field.tagName == 'TEXTAREA') {
        return 'text';
    }
    return '';
}

/**
 * Sets field value
 *
 * value must be of type:
 * o undefined (omitted) - restore default value (form default, not PMA default)
 * o String - if type is 'text'
 * o boolean - if type is 'checkbox'
 * o Array of values - if type is 'select'
 *
 * @param Element field
 * @param String  field_type  see getFieldType
 * @param mixed   value
 */
function setFieldValue(field, field_type, value) {
    switch (field_type) {
        case 'text':
            field.value = $defined(value) ? value : field.defaultValue;
            break;
        case 'checkbox':
            field.checked = $defined(value) ? value : field.defaultChecked;
            break;
        case 'select':
            var i, imax = field.options.length;
            if (!$defined(value)) {
                for (i = 0; i < imax; i++) {
                    field.options[i].selected = field.options[i].defaultSelected;
                }
            } else {
                for (i = 0; i < imax; i++) {
                    field.options[i].selected = (value.indexOf(field.options[i].value) != -1);
                }
            }
            break;
    }
    markField(field);
}

/**
 * Gets field value
 *
 * Will return one of:
 * o String - if type is 'text'
 * o boolean - if type is 'checkbox'
 * o Array of values - if type is 'select'
 *
 * @param Element field
 * @param String  field_type  see getFieldType
 * @return mixed
 */
function getFieldValue(field, field_type) {
    switch (field_type) {
        case 'text':
            return field.value;
        case 'checkbox':
            return field.checked;
        case 'select':
            var i, imax = field.options.length, items = [];
            for (i = 0; i < imax; i++) {
                if (field.options[i].selected) {
                    items.push(field.options[i].value);
                }
            }
            return items;
    }
}

/**
 * Returns values for all fields in fieldsets
 */
function getAllValues() {
    var elements = $$('fieldset input, fieldset select, fieldset textarea');
    var values = {}
    var type, value;
    for (var i = 0; i < elements.length; i++) {
        type = getFieldType(elements[i]);
        value = getFieldValue(elements[i], type);
        if (typeof value != 'undefined') {
            // we only have single selects, fatten array
            if (type == 'select') {
                value = value[0];
            }
            values[elements[i].name] = value;
        }
    }
    return values;
}

/**
 * Checks whether field has its default value
 *
 * @param Element field
 * @param String  type
 * @return boolean
 */
function checkFieldDefault(field, type) {
    if (!$defined(defaultValues[field.id])) {
        return true;
    }
    var isDefault = true
    var currentValue = getFieldValue(field, type);
    if (type != 'select') {
        isDefault = currentValue == defaultValues[field.id];
    } else {
        // compare arrays, will work for our representation of select values
        if (currentValue.length != defaultValues[field.id].length) {
            isDefault = false;
        }
        else {
            for (var i = 0; i < currentValue.length; i++) {
                if (currentValue[i] != defaultValues[field.id][i]) {
                    isDefault = false;
                    break;
                }
            }
        }
    }
    return isDefault;
}

/**
 * Returns element's id prefix
 * @param Element element
 */
function getIdPrefix(element) {
    return element.id.replace(/[^-]+$/, '');
}

// ------------------------------------------------------------------
// Messages
//

// stores hidden message ids
var hiddenMessages = [];

//
// END: Messages
// ------------------------------------------------------------------

// ------------------------------------------------------------------
// Form validation and field operations
//

// form validator assignments
var validate = {};

// form validator list
var validators = {
    /**
     * Validates positive number
     *
     * @param boolean isKeyUp
     */
    validate_positive_number: function (isKeyUp) {
        var result = this.value.test('^[0-9]*$') && this.value != '0';
        return result ? true : PMA_messages['error_nan_p'];
    },
    /**
     * Validates non-negative number
     *
     * @param boolean isKeyUp
     */
    validate_non_negative_number: function (isKeyUp) {
        var result = this.value.test('^[0-9]*$');
        return result ? true : PMA_messages['error_nan_nneg'];
    },
    /**
     * Validates port number
     *
     * @param boolean isKeyUp
     */
    validate_port_number: function(isKeyUp) {
        var result = this.value.test('^[0-9]*$') && this.value != '0';
        if (!result || this.value > 65536) {
            result = PMA_messages['error_incorrect_port'];
        }
        return result;
    },
    // field validators
    _field: {
        /**
         * hide_db field
         *
         * @param boolean isKeyUp
         */
        hide_db: function(isKeyUp) {
            if (!isKeyUp && this.value != '') {
                var data = {};
                data[this.id] = this.value;
                ajaxValidate(this, 'Servers/1/hide_db', data);
            }
            return true;
        },
		/**
         * TrustedProxies field
         *
         * @param boolean isKeyUp
         */
        TrustedProxies: function(isKeyUp) {
            if (!isKeyUp && this.value != '') {
                var data = {};
                data[this.id] = this.value;
                ajaxValidate(this, 'TrustedProxies', data);
            }
            return true;
        },
    },
    // fieldset validators
    _fieldset: {
        /**
         * Validates Server fieldset
         *
         * @param boolean isKeyUp
         */
        Server: function(isKeyUp) {
            if (!isKeyUp) {
                ajaxValidate(this, 'Server', getAllValues());
            }
            return true;
        },
        /**
         * Validates Server_login_options fieldset
         *
         * @param boolean isKeyUp
         */
        Server_login_options: function(isKeyUp) {
            return validators._fieldset.Server.bind(this)(isKeyUp);
        },
        /**
         * Validates Server_pmadb fieldset
         *
         * @param boolean isKeyUp
         */
        Server_pmadb: function(isKeyUp) {
            if (isKeyUp) {
                return true;
            }

var prefix = getIdPrefix(this.getElement('input'));
            var pmadb_active = $(prefix + 'pmadb').value != '';
            if (pmadb_active) {
                ajaxValidate(this, 'Server_pmadb', getAllValues());
            }

return true;
        }
    }
}

/**
 * Calls server-side validation procedures
 *
 * @param Element parent  input field in <fieldset> or <fieldset>
 * @param String id       validator id
 * @param Object values   values hash (element_id: value)
 */
function ajaxValidate(parent, id, values) {
    // ensure that parent is a fieldset
    if (parent.tagName != 'FIELDSET') {
        parent = parent.getParent('fieldset');
        if (!parent) {
            return false;
        }
    }
    // ensure that we have a Request object
    if (typeof parent.request == 'undefined') {
        parent.validate = {
            request: new Request.JSON({
                url: 'validate.php',
                autoCancel: true,
                onSuccess: function(response) {
                    if (response == null) {
                        return;
                    }
                    var error = {};
                    if ($type(response) != 'object') {
                        error[parent.id] = [response];
                    } else if (typeof response['error'] != 'undefined') {
                        error[parent.id] = [response['error']];
                    } else {
                        $each(response, function(value, key) {
                            error[key] = $type(value) == 'array' ? value : [value];
                        });
                    }
                    displayErrors(error);
                }}),
            token: parent.getParent('form').token.value
        };
    }

parent.validate.request.send({
        data: {
            token: parent.validate.token,
            id: id,
            values: JSON.encode(values)}
    });

return true;
}

/**
 * Registers validator for given field
 *
 * @param String  id       field id
 * @param String  type     validator (key in validators object)
 * @param boolean onKeyUp  whether fire on key up
 * @param mixed   params   validation function parameters
 */
function validateField(id, type, onKeyUp, params) {
    if (typeof validators[type] == 'undefined') {
        return;
    }
    if (typeof validate[id] == 'undefined') {
        validate[id] = [];
    }
    validate[id].push([type, params, onKeyUp]);
}

/**
 * Returns valdiation functions associated with form field
 *
 * @param  String  field_id     form field id
 * @param  boolean onKeyUpOnly  see validateField
 * @return Array  array of [function, paramseters to be passed to function]
 */
function getFieldValidators(field_id, onKeyUpOnly) {
    // look for field bound validator
    var name = field_id.match(/[^-]+$/)[0];
    if (typeof validators._field[name] != 'undefined') {
        return [[validators._field[name], null]];
    }

// look for registered validators
    var functions = [];
    if (typeof validate[field_id] != 'undefined') {
        // validate[field_id]: array of [type, params, onKeyUp]
        for (var i = 0, imax = validate[field_id].length; i < imax; i++) {
            if (onKeyUpOnly && !validate[field_id][i][2]) {
                continue;
            }
            functions.push([validators[validate[field_id][i][0]], validate[field_id][i][1]]);
        }
    }

return functions;
}

/**
 * Displays errors for given form fields
 *
 * WARNING: created DOM elements must be identical with the ones made by
 * display_input() in FormDisplay.tpl.php!
 *
 * @param Object  error list (key: field id, value: error array)
 */
function displayErrors(errors) {
    $each(errors, function(errors, field_id) {
        var field = $(field_id);
        var isFieldset = field.tagName == 'FIELDSET';
        var errorCnt = isFieldset
            ? field.getElement('dl.errors')
            : field.getNext('.inline_errors');

// remove empty errors (used to clear error list)
        errors = errors.filter(function(item) {
            return item != '';
        });

if (errors.length) {
            // if error container doesn't exist, create it
            if (errorCnt === null) {
                if (isFieldset) {
                    errorCnt = new Element('dl', {
                        'class': 'errors'
                    });
                    errorCnt.inject(field.getElement('table'), 'before');
                } else {
                    errorCnt = new Element('dl', {
                        'class': 'inline_errors'
                    });
                    errorCnt.inject(field.getParent('td'), 'bottom');
                }
            }

var html = '';
            for (var i = 0, imax = errors.length; i < imax; i++) {
                html += '<dd>' + errors[i] + '</dd>';
            }
            errorCnt.set('html', html);
        } else if (errorCnt !== null) {
            // remove useless error container
            errorCnt.dispose();
        }
    });
}

/**
 * Validates fieldset and puts errors in 'errors' object
 *
 * @param Element field
 * @param boolean isKeyUp
 * @param Object  errors
 */
function validate_fieldset(fieldset, isKeyUp, errors) {
    if (fieldset && typeof validators._fieldset[fieldset.id] != 'undefined') {
        var fieldset_errors = validators._fieldset[fieldset.id].bind(fieldset)(isKeyUp);
        $each(fieldset_errors, function(field_errors, field_id) {
            if (typeof errors[field_id] == 'undefined') {
                errors[field_id] = [];
            }
            errors[field_id][$type(field_errors) == 'array' ? 'extend' : 'push'](field_errors);
        });
    }
}

/**
 * Validates form field and puts errors in 'errors' object
 *
 * @param Element field
 * @param boolean isKeyUp
 * @param Object  errors
 */
function validate_field(field, isKeyUp, errors) {
    errors[field.id] = [];
    var functions = getFieldValidators(field.id, isKeyUp);
    for (var i = 0; i < functions.length; i++) {
        var result = functions[i][0].bind(field)(isKeyUp, functions[i][1]);
        if (result !== true) {
            errors[field.id][$type(result) == 'array' ? 'extend' : 'push'](result);
        }
    }
}

/**
 * Validates form field and parent fieldset
 *
 * @param Element field
 * @param boolean isKeyUp
 */
function validate_field_and_fieldset(field, isKeyUp) {
    var errors = {};
    validate_field(field, isKeyUp, errors);
    validate_fieldset(field.getParent('fieldset'), isKeyUp, errors);
    displayErrors(errors);
}

/**
 * Marks field depending on its value (system default or custom)
 *
 * @param Element field
 */
function markField(field) {
    var type = getFieldType(field);
    var isDefault = checkFieldDefault(field, type);

// checkboxes uses parent <span> for marking
    var fieldMarker = (type == 'checkbox') ? field.getParent() : field;
    setRestoreDefaultBtn(field, !isDefault);
    fieldMarker[isDefault ? 'removeClass' : 'addClass']('custom');
}

/**
 * Enables or disables the "restore default value" button
 *
 * @param Element field
 * @param bool    display
 */
function setRestoreDefaultBtn(field, display) {
    var td = field.getParent('td');
    if (!td) return;
    var el = td.getElement('.restore-default');
    if (!el) return;
    el.style.display = (display ? '' : 'none');
}

window.addEvent('domready', function() {
    var elements = $$('input[id], select[id], textarea[id]');
    var elements_count = elements.length;

// register validators and mark custom values
    for (var i = 0; i < elements_count; i++) {
        var el = elements[i];
        markField(el);
        el.addEvent('change', function(e) {
            validate_field_and_fieldset(this, false);
            markField(this);
        });
        // text fields can be validated after each change
        if (el.tagName == 'INPUT' && el.type == 'text') {
            el.addEvent('keyup', function(e) {
                validate_field_and_fieldset(this, true);
                markField(el);
            });
        }
        // disable textarea spellcheck
        if (el.tagName == 'TEXTAREA') {
            el.setProperty('spellcheck', false)
        }
    }

// check whether we've refreshed a page and browser remembered modified
	// form values
	var check_page_refresh = $('check_page_refresh');
	if (!check_page_refresh || check_page_refresh.value == '1') {
		// run all field validators
		var errors = {};
		for (var i = 0; i < elements_count; i++) {
			validate_field(elements[i], false, errors);
		}
		// run all fieldset validators
		$$('fieldset').each(function(el){
			validate_fieldset(el, false, errors);
		});
		
		displayErrors(errors);
	} else if (check_page_refresh) {
		check_page_refresh.value = '1';
	}
});

//
// END: Form validation and field operations
// ------------------------------------------------------------------

// ------------------------------------------------------------------
// Tabbed forms
//

/**
 * Sets active tab
 *
 * @param Element tab_link
 */
function setTab(tab_link) {
    var tabs_menu = tab_link.getParent('.tabs');

//
// END: Tabbed forms
// ------------------------------------------------------------------

// ------------------------------------------------------------------
// Form reset buttons
//

//
// END: Form reset buttons
// ------------------------------------------------------------------

// ------------------------------------------------------------------
// "Restore default" and "set value" buttons
//

/**
 * Restores field's default value
 *
 * @param String field_id
 */
function restoreField(field_id) {
    var field = $(field_id);
    if (!field || !$defined(defaultValues[field_id])) {
        return;
    }
    setFieldValue(field, getFieldType(field), defaultValues[field_id]);
}

//
// END: "Restore default" and "set value" buttons
// ------------------------------------------------------------------