mirror of
https://salsa.debian.org/freeipa-team/freeipa.git
synced 2025-01-04 13:17:15 -06:00
a17bf5e754
Splitting IPA.widget into IPA.field (logical part) and IPA.widget, IPA.input_widget (visual part). https://fedorahosted.org/freeipa/ticket/2040
384 lines
10 KiB
JavaScript
384 lines
10 KiB
JavaScript
/*jsl:import ipa.js */
|
|
/* Authors:
|
|
* Endi Sukma Dewata <edewata@redhat.com>
|
|
* Adam Young <ayoung@redhat.com>
|
|
* Pavel Zuna <pzuna@redhat.com>
|
|
* Petr Vobornik <pvoborni@redhat.com>
|
|
*
|
|
* Copyright (C) 2011 Red Hat
|
|
* see file 'COPYING' for use and warranty information
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/* REQUIRES: ipa.js, widget.js */
|
|
|
|
IPA.field = function(spec) {
|
|
spec = spec || {};
|
|
|
|
var that = {};
|
|
|
|
that.entity = spec.entity;
|
|
that.container = null;
|
|
that.name = spec.name;
|
|
that.label = spec.label;
|
|
that.tooltip = spec.tooltip;
|
|
|
|
that.widget = null;
|
|
that.widget_name = spec.widget;
|
|
|
|
// override the required flag in metadata
|
|
that.required = spec.required;
|
|
|
|
// read_only is set when widget is created
|
|
that.read_only = spec.read_only;
|
|
|
|
// writable is set during load
|
|
that.writable = true;
|
|
|
|
that.undo = spec.undo === undefined ? true : spec.undo;
|
|
that.join = spec.join;
|
|
|
|
that.metadata = spec.metadata;
|
|
|
|
that.priority = spec.priority;
|
|
|
|
that.values = [];
|
|
that.dirty = false;
|
|
that.valid = true;
|
|
|
|
that.dirty_changed = IPA.observer();
|
|
|
|
var init = function() {
|
|
if (!that.metadata && that.entity) {
|
|
that.metadata = IPA.get_entity_param(that.entity.name, that.name);
|
|
}
|
|
if (that.metadata) {
|
|
if (that.label === undefined) {
|
|
that.label = that.metadata.label;
|
|
}
|
|
if (that.tooltip === undefined) {
|
|
that.tooltip = that.metadata.doc;
|
|
}
|
|
}
|
|
};
|
|
|
|
that.is_required = function() {
|
|
if (that.read_only) return false;
|
|
if (!that.writable) return false;
|
|
|
|
if (that.required !== undefined) return that.required;
|
|
return that.metadata && that.metadata.required;
|
|
};
|
|
|
|
that.set_required = function(required) {
|
|
that.required = required;
|
|
|
|
that.update_required();
|
|
};
|
|
|
|
that.update_required = function() {
|
|
if(that.widget) {
|
|
that.widget.set_required(that.is_required());
|
|
}
|
|
};
|
|
|
|
that.validate_required = function() {
|
|
var values = that.save();
|
|
if (!values || !values.length || values[0] === '') {
|
|
if (that.is_required()) {
|
|
that.valid = false;
|
|
that.show_error(IPA.messages.widget.validation.required);
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
};
|
|
|
|
/*returns true and clears the error message if the field value passes
|
|
* the validation pattern. If the field value does not pass validation,
|
|
* displays the error message and returns false. */
|
|
that.validate = function() {
|
|
that.hide_error();
|
|
that.valid = true;
|
|
|
|
var values = that.save();
|
|
if (!values) {
|
|
return that.valid;
|
|
}
|
|
if (values.length === 0) {
|
|
return that.valid;
|
|
}
|
|
var value = values[0];
|
|
if (!value) {
|
|
return that.valid;
|
|
}
|
|
|
|
if (!that.metadata) {
|
|
return that.valid;
|
|
}
|
|
|
|
var message;
|
|
|
|
if (that.metadata.type == 'int') {
|
|
if (!value.match(/^-?\d+$/)) {
|
|
that.valid = false;
|
|
that.show_error(IPA.messages.widget.validation.integer);
|
|
return that.valid;
|
|
}
|
|
|
|
if (that.metadata.minvalue !== undefined && value < that.metadata.minvalue) {
|
|
that.valid = false;
|
|
message = IPA.messages.widget.validation.min_value;
|
|
message = message.replace('${value}', that.metadata.minvalue);
|
|
that.show_error(message);
|
|
return that.valid;
|
|
}
|
|
|
|
if (that.metadata.maxvalue !== undefined && value > that.metadata.maxvalue) {
|
|
that.valid = false;
|
|
message = IPA.messages.widget.validation.max_value;
|
|
message = message.replace('${value}', that.metadata.maxvalue);
|
|
that.show_error(message);
|
|
return that.valid;
|
|
}
|
|
}
|
|
|
|
if (that.metadata.pattern) {
|
|
var regex = new RegExp(that.metadata.pattern);
|
|
if (!value.match(regex)) {
|
|
that.valid = false;
|
|
that.show_error(that.metadata.pattern_errmsg);
|
|
return that.valid;
|
|
}
|
|
}
|
|
|
|
return that.valid;
|
|
};
|
|
|
|
/**
|
|
* This function stores the entire record and the values
|
|
* of the field, then invoke reset() to update the UI.
|
|
*/
|
|
that.load = function(record) {
|
|
that.record = record;
|
|
|
|
var value = record[that.name];
|
|
if (value instanceof Array) {
|
|
that.values = value;
|
|
} else {
|
|
that.values = value !== undefined ? [value] : [];
|
|
}
|
|
|
|
if (!that.values.length) {
|
|
that.values = [''];
|
|
}
|
|
|
|
that.writable = true;
|
|
|
|
if (that.metadata) {
|
|
if (that.metadata.primary_key) {
|
|
that.writable = false;
|
|
}
|
|
|
|
if (that.metadata.flags && 'no_update' in that.metadata.flags) {
|
|
that.writable = false;
|
|
}
|
|
}
|
|
|
|
if (that.record.attributelevelrights) {
|
|
var rights = that.record.attributelevelrights[that.name];
|
|
if (!rights || rights.indexOf('w') < 0) {
|
|
that.writable = false;
|
|
}
|
|
}
|
|
|
|
that.reset();
|
|
};
|
|
|
|
that.reset = function() {
|
|
that.update_required();
|
|
that.update();
|
|
that.validate();
|
|
that.set_dirty(false);
|
|
};
|
|
|
|
that.update = function() {
|
|
if(that.widget && that.widget.update) that.widget.update(that.values);
|
|
};
|
|
|
|
that.get_update_info = function() {
|
|
|
|
var update_info = IPA.update_info_builder.new_update_info();
|
|
if(that.is_dirty()) {
|
|
update_info.fields.push(IPA.update_info_builder.new_field_info(
|
|
that,
|
|
that.save()));
|
|
}
|
|
return update_info;
|
|
};
|
|
|
|
/**
|
|
* This function saves the values entered in the UI.
|
|
* It returns the values in an array, or null if
|
|
* the field should not be saved.
|
|
*/
|
|
that.save = function(record) {
|
|
|
|
var values = that.values;
|
|
|
|
if(that.widget) {
|
|
values = that.widget.save();
|
|
}
|
|
|
|
if(record) {
|
|
record[that.name] = values;
|
|
}
|
|
|
|
return values;
|
|
};
|
|
|
|
/**
|
|
* This function compares the original values and the
|
|
* values entered in the UI. If the values have changed
|
|
* it will return true.
|
|
*/
|
|
that.test_dirty = function() {
|
|
|
|
if (that.read_only) {
|
|
return false;
|
|
}
|
|
|
|
var values = that.save();
|
|
|
|
if (!values) { // ignore null values
|
|
return false;
|
|
}
|
|
|
|
if (!that.values) {
|
|
|
|
if (values instanceof Array) {
|
|
|
|
if ((values.length === 0) ||
|
|
(values.length === 1) &&
|
|
(values[0] === '')) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
if (values.length != that.values.length) {
|
|
return true;
|
|
}
|
|
|
|
values.sort();
|
|
that.values.sort();
|
|
|
|
for (var i=0; i<values.length; i++) {
|
|
if (values[i] != that.values[i]) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
/**
|
|
* This function compares the original values and the
|
|
* values entered in the UI. If the values have changed
|
|
* it will return true.
|
|
*/
|
|
that.is_dirty = function() {
|
|
return that.dirty;
|
|
};
|
|
|
|
that.set_dirty = function(dirty) {
|
|
var old = that.dirty;
|
|
that.dirty = dirty;
|
|
if (that.undo) {
|
|
that.show_undo(dirty);
|
|
}
|
|
|
|
if(old !== dirty) {
|
|
that.dirty_changed.notify([], that);
|
|
}
|
|
};
|
|
|
|
|
|
that.show_error = function(message) {
|
|
if(that.widget) that.widget.show_error(message);
|
|
};
|
|
|
|
that.hide_error = function() {
|
|
if(that.widget) that.widget.hide_error();
|
|
};
|
|
|
|
that.show_undo = function(value) {
|
|
if(that.widget) {
|
|
if(value) { that.widget.show_undo(); }
|
|
else { that.widget.hide_undo();}
|
|
}
|
|
};
|
|
|
|
that.set_enabled = function() {
|
|
};
|
|
|
|
that.refresh = function() {
|
|
};
|
|
|
|
that.set_widget_flags = function() {
|
|
|
|
that.widget.label = that.label;
|
|
that.widget.title = that.title;
|
|
that.widget.undo = that.undo;
|
|
that.widget.writable = that.writable;
|
|
that.widget.read_only = that.read_only;
|
|
};
|
|
|
|
that.widgets_created = function() {
|
|
|
|
that.widget = that.container.widgets.get_widget(that.widget_name);
|
|
|
|
if(that.widget) {
|
|
that.set_widget_flags();
|
|
|
|
that.widget.value_changed.attach(that.widget_value_changed);
|
|
that.widget.undo_clicked.attach(that.widget_undo_clicked);
|
|
}
|
|
};
|
|
|
|
that.widget_value_changed = function() {
|
|
that.set_dirty(that.test_dirty());
|
|
that.validate();
|
|
};
|
|
|
|
that.widget_undo_clicked = function() {
|
|
that.reset();
|
|
};
|
|
|
|
init();
|
|
|
|
// methods that should be invoked by subclasses
|
|
that.field_load = that.load;
|
|
that.field_reset = that.reset;
|
|
that.field_save = that.save;
|
|
that.field_set_dirty = that.set_dirty;
|
|
that.field_show_error = that.show_error;
|
|
that.field_test_dirty = that.test_dirty;
|
|
that.field_widgets_created = that.widgets_created;
|
|
|
|
return that;
|
|
}; |