// custom Vtypes
Ext.apply(Ext.form.field.VTypes, {
- IPAddress: function(v) {
+ IPAddress: function(v) {
return Proxmox.Utils.IP4_match.test(v);
},
- IPAddressText: gettext('Example') + ': 192.168.1.1',
+ IPAddressText: gettext('Example') + ': 192.168.1.1',
IPAddressMask: /[\d\.]/i,
- IPCIDRAddress: function(v) {
+ IPCIDRAddress: function(v) {
var result = Proxmox.Utils.IP4_cidr_match.exec(v);
// limits according to JSON Schema see
// pve-common/src/PVE/JSONSchema.pm
- return (result !== null && result[1] >= 8 && result[1] <= 32);
+ return result !== null && result[1] >= 8 && result[1] <= 32;
},
- IPCIDRAddressText: gettext('Example') + ': 192.168.1.1/24' + "<br>" + gettext('Valid CIDR Range') + ': 8-32',
+ IPCIDRAddressText: gettext('Example') + ': 192.168.1.1/24' + "<br>" + gettext('Valid CIDR Range') + ': 8-32',
IPCIDRAddressMask: /[\d\.\/]/i,
- IP6Address: function(v) {
+ IP6Address: function(v) {
return Proxmox.Utils.IP6_match.test(v);
},
- IP6AddressText: gettext('Example') + ': 2001:DB8::42',
+ IP6AddressText: gettext('Example') + ': 2001:DB8::42',
IP6AddressMask: /[A-Fa-f0-9:]/,
- IP6CIDRAddress: function(v) {
+ IP6CIDRAddress: function(v) {
var result = Proxmox.Utils.IP6_cidr_match.exec(v);
// limits according to JSON Schema see
// pve-common/src/PVE/JSONSchema.pm
- return (result !== null && result[1] >= 8 && result[1] <= 128);
+ return result !== null && result[1] >= 8 && result[1] <= 128;
},
- IP6CIDRAddressText: gettext('Example') + ': 2001:DB8::42/64' + "<br>" + gettext('Valid CIDR Range') + ': 8-128',
- IP6CIDRAddressMask: /[A-Fa-f0-9:\/]/,
+ IP6CIDRAddressText: gettext('Example') + ': 2001:DB8::42/64' + "<br>" + gettext('Valid CIDR Range') + ': 8-128',
+ IP6CIDRAddressMask: /[A-Fa-f0-9:\/]/,
- IP6PrefixLength: function(v) {
+ IP6PrefixLength: function(v) {
return v >= 0 && v <= 128;
},
- IP6PrefixLengthText: gettext('Example') + ': X, where 0 <= X <= 128',
- IP6PrefixLengthMask: /[0-9]/,
+ IP6PrefixLengthText: gettext('Example') + ': X, where 0 <= X <= 128',
+ IP6PrefixLengthMask: /[0-9]/,
- IP64Address: function(v) {
+ IP64Address: function(v) {
return Proxmox.Utils.IP64_match.test(v);
},
- IP64AddressText: gettext('Example') + ': 192.168.1.1 2001:DB8::42',
+ IP64AddressText: gettext('Example') + ': 192.168.1.1 2001:DB8::42',
IP64AddressMask: /[A-Fa-f0-9\.:]/,
IP64CIDRAddress: function(v) {
MacAddressMask: /[a-fA-F0-9:]/,
MacAddressText: gettext('Example') + ': 01:23:45:67:89:ab',
- MacPrefix: function(v) {
+ MacPrefix: function(v) {
return (/^[a-f0-9][02468ace](?::[a-f0-9]{2}){0,2}:?$/i).test(v);
},
MacPrefixMask: /[a-fA-F0-9:]/,
gettext("Maximum characters") + ": 21" + "<br />" +
gettext("Must start with") + ": 'a-z'",
- StorageId: function(v) {
+ StorageId: function(v) {
return (/^[a-z][a-z0-9\-\_\.]*[a-z0-9]$/i).test(v);
},
StorageIdText: gettext("Allowed characters") + ": 'A-Z', 'a-z', '0-9', '-', '_', '.'" + "<br />" +
gettext("Must start with") + ": 'A-Z', 'a-z'<br />" +
gettext("Must end with") + ": 'A-Z', 'a-z', '0-9'<br />",
- ConfigId: function(v) {
+ ConfigId: function(v) {
return (/^[a-z][a-z0-9\_]+$/i).test(v);
},
ConfigIdText: gettext("Allowed characters") + ": 'A-Z', 'a-z', '0-9', '_'" + "<br />" +
gettext("Minimum characters") + ": 2" + "<br />" +
gettext("Must start with") + ": " + gettext("letter"),
- HttpProxy: function(v) {
+ HttpProxy: function(v) {
return (/^http:\/\/.*$/).test(v);
},
HttpProxyText: gettext('Example') + ": http://username:password@host:port/",
if (field.initialPassField) {
var pwd = field.up('form').down(
'[name=' + field.initialPassField + ']');
- return (val == pwd.getValue());
+ return val == pwd.getValue();
}
return true;
},
- passwordText: gettext('Passwords do not match')
+ passwordText: gettext('Passwords do not match'),
});
// Firefox 52+ Touchscreen bug
// see https://www.sencha.com/forum/showthread.php?336762-Examples-don-t-work-in-Firefox-52-touchscreen/page2
// and https://bugzilla.proxmox.com/show_bug.cgi?id=1223
Ext.define('EXTJS_23846.Element', {
- override: 'Ext.dom.Element'
+ override: 'Ext.dom.Element',
}, function(Element) {
var supports = Ext.supports,
proto = Element.prototype,
});
Ext.define('EXTJS_23846.Gesture', {
- override: 'Ext.event.publisher.Gesture'
+ override: 'Ext.event.publisher.Gesture',
}, function(Gesture) {
var me = Gesture.instance;
override: 'Ext.chart.series.Pie',
// from 6.0.2
- betweenAngle: function (x, a, b) {
+ betweenAngle: function(x, a, b) {
var pp = Math.PI * 2,
offset = this.rotationOffset;
// we always want the number in x.y format and never in, e.g., x,y
Ext.define('PVE.form.field.Number', {
override: 'Ext.form.field.Number',
- submitLocaleSeparator: false
+ submitLocaleSeparator: false,
});
// ExtJs 5-6 has an issue with caching
Ext.define('Proxmox.UnderlayPool', {
override: 'Ext.dom.UnderlayPool',
- checkOut: function () {
+ checkOut: function() {
var cache = this.cache,
len = cache.length,
el;
}
return el;
- }
+ },
});
// 'Enter' in Textareas and aria multiline fields should not activate the
return true;
}
return this.callParent(arguments);
- }
+ },
});
// if the order of the values are not the same in originalValue and value
me.skip_expand_on_focus = true;
}
this.callParent(arguments);
- }
+ },
});
me.on("focus", function(combobox) {
return function() {
// If we still have data, attempt to refocus in the same mode.
if (store.getCount()) {
-
// Adjust expectations of where we are able to refocus according to what kind of destruction
// might have been wrought on this view's DOM during focus save.
refocusRow = Math.min(focusPosition.rowIdx, me.all.getCount() - 1);
navModel.setPosition(focusPosition, null, null, null, true);
if (!me.jumpToFocus) {
- me.scrollTo(x,y);
+ me.scrollTo(x, y);
}
}
}
};
}
return Ext.emptyFn;
- }
+ },
});
// should be fixed with ExtJS 6.0.2, see:
// https://www.sencha.com/forum/showthread.php?307244-Bug-with-datefield-in-window-with-scroll
Ext.define('Proxmox.Datepicker', {
override: 'Ext.picker.Date',
- hideMode: 'visibility'
+ hideMode: 'visibility',
});
// ExtJS 6.0.1 has no setSubmitValue() (although you find it in the docs).
createWheelListener: function() {
var me = this;
if (Ext.isFirefox) {
- me.wheelListener = me.layout.innerCt.on('wheel', me.onMouseWheelFirefox, me, {destroyable: true});
+ me.wheelListener = me.layout.innerCt.on('wheel', me.onMouseWheelFirefox, me, { destroyable: true });
} else {
- me.wheelListener = me.layout.innerCt.on('mousewheel', me.onMouseWheel, me, {destroyable: true});
+ me.wheelListener = me.layout.innerCt.on('mousewheel', me.onMouseWheel, me, { destroyable: true });
}
},
e.stopEvent();
var delta = e.browserEvent.deltaY || 0;
this.scrollBy(delta * this.wheelIncrement, false);
- }
+ },
});
icon: this.ERROR,
buttons: this.OK,
fn: fn,
- scope : scope,
- minWidth: this.minWidth
+ scope: scope,
+ minWidth: this.minWidth,
};
return this.show(config);
}
- }
+ },
});
/*jslint confusion: false */
});
src: 'about:blank',
renderTpl: [
- '<iframe src="{src}" id="{id}-iframeEl" data-ref="iframeEl" name="{frameName}" width="100%" height="100%" frameborder="0" allowfullscreen="true"></iframe>'
+ '<iframe src="{src}" id="{id}-iframeEl" data-ref="iframeEl" name="{frameName}" width="100%" height="100%" frameborder="0" allowfullscreen="true"></iframe>',
],
childEls: ['iframeEl'],
- initComponent: function () {
+ initComponent: function() {
this.callParent();
this.frameName = this.frameName || this.id + '-frame';
},
- initEvents : function() {
+ initEvents: function() {
var me = this;
me.callParent();
me.iframeEl.on('load', me.onLoad, me);
initRenderData: function() {
return Ext.apply(this.callParent(), {
src: this.src,
- frameName: this.frameName
+ frameName: this.frameName,
});
},
return me.iframeEl.dom;
},
- beforeDestroy: function () {
+ beforeDestroy: function() {
this.cleanupListeners(true);
this.callParent();
},
- cleanupListeners: function(destroying){
+ cleanupListeners: function(destroying) {
var doc, prop;
if (this.rendered) {
}
}
}
- } catch(e) { }
+ } catch (e) { }
}
},
me._docListeners = {
mousedown: fn, // menu dismisal (MenuManager) and Window onMouseDown (toFront)
mousemove: fn, // window resize drag detection
- mouseup: fn, // window resize termination
- click: fn, // not sure, but just to be safe
- dblclick: fn, // not sure again
- scope: me
- }
+ mouseup: fn, // window resize termination
+ click: fn, // not sure, but just to be safe
+ dblclick: fn, // not sure again
+ scope: me,
+ },
);
/*jslint nomen: false*/
- } catch(e) {
+ } catch (e) {
// cannot do this xss
}
this.el.unmask();
this.fireEvent('load', this);
-
} else if (me.src) {
-
this.el.unmask();
this.fireEvent('error', this);
}
-
-
},
- onRelayedEvent: function (event) {
+ onRelayedEvent: function(event) {
// relay event from the iframe's document to the document that owns the iframe...
var iframeEl = this.iframeEl,
event.xy = originalEventXY; // restore the original XY (just for safety)
},
- load: function (src) {
+ load: function(src) {
var me = this,
text = me.loadMask,
frame = me.getFrame();
me.el.mask(text);
}
- frame.src = me.src = (src || me.src);
+ frame.src = me.src = src || me.src;
}
- }
+ },
});
listen: {
global: {
proxmoxShowHelp: 'onProxmoxShowHelp',
- proxmoxHideHelp: 'onProxmoxHideHelp'
- }
+ proxmoxHideHelp: 'onProxmoxHideHelp',
+ },
},
onProxmoxShowHelp: function(helpLink) {
var me = this.getView();
if (me.listenToGlobalEvent === true) {
me.hide();
}
- }
+ },
},
// this sets the link and the tooltip text
- setOnlineHelp:function(blockid) {
+ setOnlineHelp: function(blockid) {
var me = this;
var info = Proxmox.Utils.get_help_info(blockid);
me.callParent();
- if (me.onlineHelp) {
+ if (me.onlineHelp) {
me.setOnlineHelp(me.onlineHelp); // set tooltip
}
- }
+ },
});
Ext.apply(config, {
model: rstore.model,
- proxy: { type: 'memory' }
+ proxy: { type: 'memory' },
});
me.callParent([config]);
olditem.commit();
} else {
var newrec = Ext.create(me.model, data);
- var pos = (me.appendAtStart && !first_load) ? 0 : me.data.length;
+ var pos = me.appendAtStart && !first_load ? 0 : me.data.length;
me.insert(pos, newrec);
}
};
var loadFn = function(s, records, success) {
-
if (!success) {
return;
}
}
me.mon(me.rstore, 'load', loadFn);
- }
+ },
});
*
* Designed to work with the KeyValue model and the JsonObject data reader
*/
-Ext.define('Proxmox.data.ObjectStore', {
+Ext.define('Proxmox.data.ObjectStore', {
extend: 'Proxmox.data.UpdateStore',
getRecord: function() {
config = config || {};
if (!config.storeid) {
- config.storeid = 'proxmox-store-' + (++Ext.idSeed);
+ config.storeid = 'proxmox-store-' + ++Ext.idSeed;
}
Ext.applyIf(config, {
type: 'jsonobject',
rows: config.rows,
readArray: config.readArray,
- rootProperty: config.root || 'data'
- }
- }
+ rootProperty: config.root || 'data',
+ },
+ },
});
me.callParent([config]);
- }
+ },
});
Ext.define('Proxmox.RestProxy', {
extend: 'Ext.data.RestProxy',
- alias : 'proxy.proxmox',
+ alias: 'proxy.proxmox',
- pageParam : null,
+ pageParam: null,
startParam: null,
limitParam: null,
groupParam: null,
sortParam: null,
filterParam: null,
- noCache : false,
+ noCache: false,
afterRequest: function(request, success) {
this.fireEvent('afterload', this, request, success);
},
constructor: function(config) {
-
Ext.applyIf(config, {
reader: {
type: 'json',
- rootProperty: config.root || 'data'
- }
+ rootProperty: config.root || 'data',
+ },
});
this.callParent([config]);
- }
+ },
}, function() {
-
Ext.define('KeyValue', {
extend: "Ext.data.Model",
- fields: [ 'key', 'value' ],
- idProperty: 'key'
+ fields: ['key', 'value'],
+ idProperty: 'key',
});
Ext.define('KeyValuePendingDelete', {
extend: "Ext.data.Model",
- fields: [ 'key', 'value', 'pending', 'delete' ],
- idProperty: 'key'
+ fields: ['key', 'value', 'pending', 'delete'],
+ idProperty: 'key',
});
Ext.define('proxmox-tasks', {
extend: 'Ext.data.Model',
- fields: [
- { name: 'starttime', type : 'date', dateFormat: 'timestamp' },
- { name: 'endtime', type : 'date', dateFormat: 'timestamp' },
+ fields: [
+ { name: 'starttime', type: 'date', dateFormat: 'timestamp' },
+ { name: 'endtime', type: 'date', dateFormat: 'timestamp' },
{ name: 'pid', type: 'int' },
- 'node', 'upid', 'user', 'status', 'type', 'id'
+ 'node', 'upid', 'user', 'status', 'type', 'id',
],
- idProperty: 'upid'
+ idProperty: 'upid',
});
Ext.define('proxmox-cluster-log', {
extend: 'Ext.data.Model',
- fields: [
- { name: 'uid' , type: 'int' },
- { name: 'time', type : 'date', dateFormat: 'timestamp' },
+ fields: [
+ { name: 'uid', type: 'int' },
+ { name: 'time', type: 'date', dateFormat: 'timestamp' },
{ name: 'pri', type: 'int' },
{ name: 'pid', type: 'int' },
'node', 'user', 'tag', 'msg',
}
// compute unique ID
return info.uid + ':' + info.node;
- }
- }
+ },
+ },
],
- idProperty: 'id'
+ idProperty: 'id',
});
-
});
},
proxy: {
- type: 'proxmox'
+ type: 'proxmox',
},
timeframe: 'hour',
// set a new storeid
if (!config.storeid) {
- config.storeid = 'rrdstore-' + (++Ext.idSeed);
+ config.storeid = 'rrdstore-' + ++Ext.idSeed;
}
// rrdurl is required
var stateinit = sp.get(stateid);
if (stateinit) {
- if(stateinit.timeframe !== me.timeframe || stateinit.cf !== me.rrdcffn){
+ if (stateinit.timeframe !== me.timeframe || stateinit.cf !== me.rrdcffn) {
me.timeframe = stateinit.timeframe;
me.rrdcffn = stateinit.cf;
}
me.callParent([config]);
me.setRRDUrl();
- me.mon(sp, 'statechange', function(prov, key, state){
+ me.mon(sp, 'statechange', function(prov, key, state) {
if (key === stateid) {
if (state && state.id) {
if (state.timeframe !== me.timeframe || state.cf !== me.cf) {
}
}
});
- }
+ },
});
Ext.define('Timezone', {
extend: 'Ext.data.Model',
- fields: ['zone']
+ fields: ['zone'],
});
Ext.define('Proxmox.data.TimezoneStore', {
['Pacific/Tongatapu'],
['Pacific/Wake'],
['Pacific/Wallis'],
- ['UTC']
- ]
+ ['UTC'],
+ ],
});
if (Proxmox.Utils.authOK()) {
let start = new Date();
me.load(function() {
- let runtime = (new Date()) - start;
+ let runtime = new Date() - start;
let interval = me.getInterval() + runtime*2;
load_task.delay(interval, run_load_task);
});
stopUpdate: function() {
me.setIsStopped(true);
load_task.cancel();
- }
+ },
});
me.callParent([config]);
if (me.getAutoStart()) {
me.startUpdate();
}
- }
+ },
});
Ext.define('Proxmox.data.reader.JsonObject', {
extend: 'Ext.data.reader.Json',
- alias : 'reader.jsonobject',
+ alias: 'reader.jsonobject',
readArray: false,
var root = result[me.getRootProperty()];
if (me.readArray) {
-
var rec_hash = {};
Ext.Array.each(root, function(rec) {
if (Ext.isDefined(rec.key)) {
}
data.push(rec);
} else if (Ext.isDefined(rowdef.defaultValue)) {
- data.push({key: key, value: rowdef.defaultValue} );
+ data.push({ key: key, value: rowdef.defaultValue });
} else if (rowdef.required) {
- data.push({key: key, value: undefined });
+ data.push({ key: key, value: undefined });
}
});
} else {
}
});
}
-
} else {
-
var org_root = root;
if (Ext.isArray(org_root)) {
if (me.rows) {
Ext.Object.each(me.rows, function(key, rowdef) {
if (Ext.isDefined(root[key])) {
- data.push({key: key, value: root[key]});
+ data.push({ key: key, value: root[key] });
} else if (Ext.isDefined(rowdef.defaultValue)) {
- data.push({key: key, value: rowdef.defaultValue});
+ data.push({ key: key, value: rowdef.defaultValue });
} else if (rowdef.required) {
- data.push({key: key, value: undefined});
+ data.push({ key: key, value: undefined });
}
});
} else {
Ext.Object.each(root, function(key, value) {
- data.push({key: key, value: value });
+ data.push({ key: key, value: value });
});
}
}
- }
- catch (ex) {
+ } catch (ex) {
Ext.Error.raise({
response: response,
json: response.responseText,
parseError: ex,
- msg: 'Unable to parse the JSON returned by the server: ' + ex.toString()
+ msg: 'Unable to parse the JSON returned by the server: ' + ex.toString(),
});
}
return data;
- }
+ },
});
}
me.callParent();
- }
+ },
});
Ext.define('Proxmox.form.BondPolicySelector', {
comboItems: [
['layer2', 'layer2'],
['layer2+3', 'layer2+3'],
- ['layer3+4', 'layer3+4']
- ]
+ ['layer3+4', 'layer3+4'],
+ ],
});
config: {
defaultValue: undefined,
deleteDefaultValue: false,
- deleteEmpty: false
+ deleteEmpty: false,
},
inputValue: '1',
val = me.getSubmitValue();
if (val !== null) {
data = {};
- if ((val == me.getDefaultValue()) && me.getDeleteDefaultValue()) {
- data['delete'] = me.getName();
+ if (val == me.getDefaultValue() && me.getDeleteDefaultValue()) {
+ data.delete = me.getName();
} else {
data[me.getName()] = val;
}
} else if (me.getDeleteEmpty()) {
data = {};
- data['delete'] = me.getName();
+ data.delete = me.getName();
}
}
return data;
} else {
me.callParent([value]);
}
- }
+ },
});
handler: function() {
var me = this;
me.setValue('');
- }
- }
+ },
+ },
},
setValue: function(value) {
data[me.getName()] = val;
} else if (me.getDeleteEmpty()) {
data = {};
- data['delete'] = me.getName();
+ data.delete = me.getName();
}
}
return data;
extraKeySpec = {
byValue: {
rootProperty: 'data',
- unique: false
- }
+ unique: false,
+ },
};
extraKeySpec.byValue.property = me.valueField;
store.setExtraKeys(extraKeySpec);
} else {
extraKeySpec.byText = {
rootProperty: 'data',
- unique: false
+ unique: false,
};
extraKeySpec.byText.property = me.displayField;
store.setExtraKeys(extraKeySpec);
rootProperty: 'data',
extraKeys: {
byInternalId: {
- property: 'internalId'
+ property: 'internalId',
},
byValue: {
property: me.valueField,
- rootProperty: 'data'
- }
+ rootProperty: 'data',
+ },
},
// Whenever this collection is changed by anyone, whether by this field adding to it,
// or the BoundList operating, we must refresh our value.
listeners: {
beginupdate: me.onValueCollectionBeginUpdate,
endupdate: me.onValueCollectionEndUpdate,
- scope: me
- }
+ scope: me,
+ },
};
// This becomes our collection of selected records for the Field.
store: store,
listeners: {
scope: me,
- lastselectedchanged: me.updateBindSelection
- }
+ lastselectedchanged: me.updateBindSelection,
+ },
});
if (!initial) {
pageSize: me.pageSize,
tpl: me.tpl,
selModel: me.pickerSelectionModel,
- focusOnToFront: false
+ focusOnToFront: false,
}, me.listConfig, me.defaultListConfig);
picker = me.picker || Ext.widget(pickerCfg);
if (!picker.initialConfig.maxHeight) {
picker.on({
beforeshow: me.onBeforePickerShow,
- scope: me
+ scope: me,
});
}
picker.getSelectionModel().on({
beforeselect: me.onBeforeSelect,
beforedeselect: me.onBeforeDeselect,
focuschange: me.onFocusChange,
- selectionChange: function (sm, selectedRecords) {
+ selectionChange: function(sm, selectedRecords) {
var me = this;
if (selectedRecords.length) {
me.setValue(selectedRecords);
me.fireEvent('select', me, selectedRecords);
}
},
- scope: me
+ scope: me,
});
// hack for extjs6
// it does not select the item
// instead we hide the picker
if (!me.multiSelect) {
- picker.on('itemclick', function (sm,record) {
+ picker.on('itemclick', function(sm, record) {
if (picker.getSelection()[0] === record) {
picker.hide();
}
return found;
},
- validator: function (value) {
+ validator: function(value) {
var me = this;
if (!value) {
//
// we also have to get the 'real' value if the we have a mulitSelect
// Field but got a non array value
- if ((me.valueField && me.valueField !== me.displayField) ||
- (me.multiSelect && !Ext.isArray(value))) {
+ if (me.valueField && me.valueField !== me.displayField ||
+ me.multiSelect && !Ext.isArray(value)) {
value = me.getValue();
}
Ext.apply(me, {
queryMode: 'local',
- matchFieldWidth: false
+ matchFieldWidth: false,
});
- Ext.applyIf(me, { value: ''}); // hack: avoid ExtJS validate() bug
+ Ext.applyIf(me, { value: '' }); // hack: avoid ExtJS validate() bug
Ext.applyIf(me.listConfig, { width: 400 });
}
}
});
- }
+ },
});
editable: false,
reference: 'dateentry',
flex: 1,
- format: 'Y-m-d'
+ format: 'Y-m-d',
},
{
xtype: 'timefield',
format: 'H:i',
width: 80,
value: '00:00',
- increment: 60
- }
+ increment: 60,
+ },
],
setMinValue: function(value) {
// current time is smaller than the time part of the new minimum
// so we have to add 1 to the day
- if ((minhours*60+minminutes) > (hours*60+minutes)) {
+ if (minhours*60+minminutes > hours*60+minutes) {
value.setDate(value.getDate()+1);
}
me.lookup('dateentry').setMinValue(value);
// current time is biger than the time part of the new maximum
// so we have to subtract 1 to the day
- if ((maxhours*60+maxminutes) < (hours*60+minutes)) {
+ if (maxhours*60+maxminutes < hours*60+minutes) {
value.setDate(value.getDate()-1);
}
me.relayEvents(me.lookupReference('dateentry'), ['change']);
me.relayEvents(me.lookupReference('timeentry'), ['change']);
- }
+ },
});
layout: 'fit',
defaults: {
- hideLabel: true
+ hideLabel: true,
},
initComponent: function() {
-Ext.define('Proxmox.form.field.Integer',{
+Ext.define('Proxmox.form.field.Integer', {
extend: 'Ext.form.field.Number',
alias: 'widget.proxmoxintegerfield',
config: {
- deleteEmpty: false
+ deleteEmpty: false,
},
allowDecimals: false,
data[me.getName()] = val;
} else if (me.getDeleteEmpty()) {
data = {};
- data['delete'] = me.getName();
+ data.delete = me.getName();
}
}
return data;
- }
+ },
});
alias: 'widget.proxmoxKVComboBox',
config: {
- deleteEmpty: true
+ deleteEmpty: true,
},
comboItems: undefined,
data[me.getName()] = val;
} else if (me.getDeleteEmpty()) {
data = {};
- data['delete'] = me.getName();
+ data.delete = me.getName();
}
}
return data;
me.store = Ext.create('Ext.data.ArrayStore', {
model: 'KeyValue',
- data : me.comboItems
+ data: me.comboItems,
});
if (me.initialConfig.editable === undefined) {
var me = this;
me.getStore().setData(items);
- }
+ },
});
extend: 'Proxmox.form.KVComboBox',
xtype: 'proxmoxLanguageSelector',
- comboItems: Proxmox.Utils.language_array()
+ comboItems: Proxmox.Utils.language_array(),
});
throw "missing custom view config: nodename";
}
view.getStore().getProxy().setUrl('/api2/json/nodes/'+ view.nodename + '/network');
- }
+ },
});
Ext.define('Proxmox.data.NetworkSelector', {
extend: 'Ext.data.Model',
fields: [
- {name: 'active'},
- {name: 'cidr'},
- {name: 'cidr6'},
- {name: 'address'},
- {name: 'address6'},
- {name: 'comments'},
- {name: 'iface'},
- {name: 'slaves'},
- {name: 'type'}
- ]
+ { name: 'active' },
+ { name: 'cidr' },
+ { name: 'cidr6' },
+ { name: 'address' },
+ { name: 'address6' },
+ { name: 'comments' },
+ { name: 'iface' },
+ { name: 'slaves' },
+ { name: 'type' },
+ ],
});
Ext.define('Proxmox.form.NetworkSelector', {
autoLoad: true,
model: 'Proxmox.data.NetworkSelector',
proxy: {
- type: 'proxmox'
+ type: 'proxmox',
},
sorters: [
{
- property : 'iface',
- direction: 'ASC'
- }
+ property: 'iface',
+ direction: 'ASC',
+ },
],
filters: [
function(item) {
return item.data.cidr;
- }
+ },
],
listeners: {
load: function(store, records, successfull) {
-
if (successfull) {
records.forEach(function(record) {
if (record.data.cidr6) {
- let dest = (record.data.cidr) ? record.copy(null) : record;
+ let dest = record.data.cidr ? record.copy(null) : record;
dest.data.cidr = record.data.cidr6;
dest.data.address = record.data.address6;
delete record.data.cidr6;
}
});
}
- }
- }
+ },
+ },
},
listConfig: {
width: 600,
header: gettext('CIDR'),
dataIndex: 'cidr',
hideable: false,
- flex: 1
+ flex: 1,
},
{
{
header: gettext('Interface'),
width: 90,
- dataIndex: 'iface'
+ dataIndex: 'iface',
},
{
header: gettext('Active'),
renderer: Proxmox.Utils.format_boolean,
width: 60,
- dataIndex: 'active'
+ dataIndex: 'active',
},
{
header: gettext('Type'),
width: 80,
hidden: true,
- dataIndex: 'type'
+ dataIndex: 'type',
},
{
header: gettext('Comment'),
flex: 2,
- dataIndex: 'comments'
- }
- ]
- }
+ dataIndex: 'comments',
+ },
+ ],
+ },
});
editable: false,
queryMode: 'local',
value: 'hour',
- stateEvents: [ 'select' ],
+ stateEvents: ['select'],
stateful: true,
stateId: 'proxmoxRRDTypeSelection',
store: {
type: 'array',
- fields: [ 'id', 'timeframe', 'cf', 'text' ],
- data : [
- [ 'hour', 'hour', 'AVERAGE',
- gettext('Hour') + ' (' + gettext('average') +')' ],
- [ 'hourmax', 'hour', 'MAX',
- gettext('Hour') + ' (' + gettext('maximum') + ')' ],
- [ 'day', 'day', 'AVERAGE',
- gettext('Day') + ' (' + gettext('average') + ')' ],
- [ 'daymax', 'day', 'MAX',
- gettext('Day') + ' (' + gettext('maximum') + ')' ],
- [ 'week', 'week', 'AVERAGE',
- gettext('Week') + ' (' + gettext('average') + ')' ],
- [ 'weekmax', 'week', 'MAX',
- gettext('Week') + ' (' + gettext('maximum') + ')' ],
- [ 'month', 'month', 'AVERAGE',
- gettext('Month') + ' (' + gettext('average') + ')' ],
- [ 'monthmax', 'month', 'MAX',
- gettext('Month') + ' (' + gettext('maximum') + ')' ],
- [ 'year', 'year', 'AVERAGE',
- gettext('Year') + ' (' + gettext('average') + ')' ],
- [ 'yearmax', 'year', 'MAX',
- gettext('Year') + ' (' + gettext('maximum') + ')' ]
- ]
+ fields: ['id', 'timeframe', 'cf', 'text'],
+ data: [
+ ['hour', 'hour', 'AVERAGE',
+ gettext('Hour') + ' (' + gettext('average') +')'],
+ ['hourmax', 'hour', 'MAX',
+ gettext('Hour') + ' (' + gettext('maximum') + ')'],
+ ['day', 'day', 'AVERAGE',
+ gettext('Day') + ' (' + gettext('average') + ')'],
+ ['daymax', 'day', 'MAX',
+ gettext('Day') + ' (' + gettext('maximum') + ')'],
+ ['week', 'week', 'AVERAGE',
+ gettext('Week') + ' (' + gettext('average') + ')'],
+ ['weekmax', 'week', 'MAX',
+ gettext('Week') + ' (' + gettext('maximum') + ')'],
+ ['month', 'month', 'AVERAGE',
+ gettext('Month') + ' (' + gettext('average') + ')'],
+ ['monthmax', 'month', 'MAX',
+ gettext('Month') + ' (' + gettext('maximum') + ')'],
+ ['year', 'year', 'AVERAGE',
+ gettext('Year') + ' (' + gettext('average') + ')'],
+ ['yearmax', 'year', 'MAX',
+ gettext('Year') + ' (' + gettext('maximum') + ')'],
+ ],
},
// save current selection in the state Provider so RRDView can read it
getState: function() {
return {
id: rec.data.id,
timeframe: rec.data.timeframe,
- cf: rec.data.cf
+ cf: rec.data.cf,
};
},
// set selection based on last saved state
- applyState : function(state) {
+ applyState: function(state) {
if (state && state.id) {
this.setValue(state.id);
}
- }
+ },
});
data[me.getName()] = val;
} else if (me.getDeleteEmpty()) {
data = {};
- data['delete'] = me.getName();
+ data.delete = me.getName();
}
}
return data;
setAllowBlank: function(allowBlank) {
this.allowBlank = allowBlank;
this.validate();
- }
+ },
});
subject: text,
onlineHelp: opts.onlineHelp,
fieldDefaults: {
- labelWidth: opts.labelWidth || 100
+ labelWidth: opts.labelWidth || 100,
},
items: {
xtype: 'proxmoxKVComboBox',
name: name,
comboItems: opts.comboItems,
value: opts.defaultValue,
- deleteEmpty: opts.deleteEmpty ? true : false,
+ deleteEmpty: !!opts.deleteEmpty,
emptyText: opts.defaultValue,
labelWidth: Proxmox.Utils.compute_min_label_width(
text, opts.labelWidth),
- fieldLabel: text
- }
- }
+ fieldLabel: text,
+ },
+ },
};
},
subject: text,
onlineHelp: opts.onlineHelp,
fieldDefaults: {
- labelWidth: opts.labelWidth || 100
+ labelWidth: opts.labelWidth || 100,
},
items: {
xtype: 'proxmoxtextfield',
name: name,
- deleteEmpty: opts.deleteEmpty ? true : false,
+ deleteEmpty: !!opts.deleteEmpty,
emptyText: opts.defaultValue,
labelWidth: Proxmox.Utils.compute_min_label_width(
text, opts.labelWidth),
vtype: opts.vtype,
- fieldLabel: text
- }
- }
+ fieldLabel: text,
+ },
+ },
};
},
subject: text,
onlineHelp: opts.onlineHelp,
fieldDefaults: {
- labelWidth: opts.labelWidth || 100
+ labelWidth: opts.labelWidth || 100,
},
items: {
xtype: 'proxmoxcheckbox',
name: name,
uncheckedValue: 0,
- defaultValue: opts.defaultValue || 0,
- checked: opts.defaultValue ? true : false,
- deleteDefaultValue: opts.deleteDefaultValue ? true : false,
+ defaultValue: opts.defaultValue || 0,
+ checked: !!opts.defaultValue,
+ deleteDefaultValue: !!opts.deleteDefaultValue,
labelWidth: Proxmox.Utils.compute_min_label_width(
text, opts.labelWidth),
- fieldLabel: text
- }
- }
+ fieldLabel: text,
+ },
+ },
};
},
add_integer_row: function(name, text, opts) {
var me = this;
- opts = opts || {}
+ opts = opts || {};
me.rows = me.rows || {};
me.rows[name] = {
subject: text,
onlineHelp: opts.onlineHelp,
fieldDefaults: {
- labelWidth: opts.labelWidth || 100
+ labelWidth: opts.labelWidth || 100,
},
items: {
xtype: 'proxmoxintegerfield',
minValue: opts.minValue,
maxValue: opts.maxValue,
emptyText: gettext('Default'),
- deleteEmpty: opts.deleteEmpty ? true : false,
+ deleteEmpty: !!opts.deleteEmpty,
value: opts.defaultValue,
labelWidth: Proxmox.Utils.compute_min_label_width(
text, opts.labelWidth),
- fieldLabel: text
- }
- }
+ fieldLabel: text,
+ },
+ },
};
},
if (Ext.isString(rowdef.editor)) {
config = Ext.apply({
confid: rec.data.key,
- }, me.editorConfig);
+ }, me.editorConfig);
win = Ext.create(rowdef.editor, config);
} else {
config = Ext.apply({
confid: rec.data.key,
- }, me.editorConfig);
+ }, me.editorConfig);
Ext.apply(config, rowdef.editor);
win = Ext.createWidget(rowdef.editor.xtype, config);
win.load();
renderKey: function(key, metaData, record, rowIndex, colIndex, store) {
var me = this;
var rows = me.rows;
- var rowdef = (rows && rows[key]) ? rows[key] : {};
+ var rowdef = rows && rows[key] ? rows[key] : {};
return rowdef.header || key;
},
var me = this;
var rows = me.rows;
var key = record.data.key;
- var rowdef = (rows && rows[key]) ? rows[key] : {};
+ var rowdef = rows && rows[key] ? rows[key] : {};
var renderer = rowdef.renderer;
if (renderer) {
}
this.pressedIndex = undefined;
- }
+ },
},
- initComponent : function() {
+ initComponent: function() {
var me = this;
var rows = me.rows;
url: me.url,
interval: me.interval,
extraParams: me.extraParams,
- rows: me.rows
+ rows: me.rows,
});
}
var store = Ext.create('Proxmox.data.DiffStore', { rstore: rstore,
sorters: [],
- filters: []
+ filters: [],
});
if (rows) {
if (me.sorterFn) {
store.sorters.add(Ext.create('Ext.util.Sorter', {
- sorterFn: me.sorterFn
+ sorterFn: me.sorterFn,
}));
}
filterFn: function(item) {
if (rows) {
var rowdef = rows[item.data.key];
- if (!rowdef || (rowdef.visible === false)) {
+ if (!rowdef || rowdef.visible === false) {
return false;
}
}
return true;
- }
+ },
}));
Proxmox.Utils.monStoreErrors(me, rstore);
header: gettext('Name'),
width: me.cwidth1 || 200,
dataIndex: 'key',
- renderer: me.renderKey
+ renderer: me.renderKey,
},
{
flex: 1,
header: gettext('Value'),
dataIndex: 'value',
- renderer: me.renderValue
- }
- ]
+ renderer: me.renderValue,
+ },
+ ],
});
me.callParent();
if (me.monStoreErrors) {
Proxmox.Utils.monStoreErrors(me, me.store);
}
- }
+ },
});
if (pending) {
if (Ext.isDefined(rec.data.pending) && rec.data.pending !== '') {
value = rec.data.pending;
- } else if (rec.data['delete'] === 1) {
+ } else if (rec.data.delete === 1) {
value = defaultValue;
}
}
- if (Ext.isDefined(value) && (value !== '')) {
+ if (Ext.isDefined(value) && value !== '') {
return value;
} else {
return defaultValue;
hasPendingChanges: function(key) {
var me = this;
var rows = me.rows;
- var rowdef = (rows && rows[key]) ? rows[key] : {};
- var keys = rowdef.multiKey || [ key ];
+ var rowdef = rows && rows[key] ? rows[key] : {};
+ var keys = rowdef.multiKey || [key];
var pending = false;
Ext.Array.each(keys, function(k) {
var rec = me.store.getById(k);
if (rec && rec.data && (
- (Ext.isDefined(rec.data.pending) && rec.data.pending !== '') ||
- rec.data['delete'] === 1
+ Ext.isDefined(rec.data.pending) && rec.data.pending !== '' ||
+ rec.data.delete === 1
)) {
pending = true;
return false; // break
var me = this;
var rows = me.rows;
var key = record.data.key;
- var rowdef = (rows && rows[key]) ? rows[key] : {};
+ var rowdef = rows && rows[key] ? rows[key] : {};
var renderer = rowdef.renderer;
var current = '';
var pendingdelete = '';
pending = record.data.pending;
}
- if (record.data['delete']) {
+ if (record.data.delete) {
var delete_all = true;
if (rowdef.multiKey) {
Ext.Array.each(rowdef.multiKey, function(k) {
var rec = me.store.getById(k);
- if (rec && rec.data && rec.data['delete'] !== 1) {
+ if (rec && rec.data && rec.data.delete !== 1) {
delete_all = false;
return false; // break
}
}
},
- initComponent : function() {
+ initComponent: function() {
var me = this;
var rows = me.rows;
url: me.url,
interval: me.interval,
extraParams: me.extraParams,
- rows: me.rows
+ rows: me.rows,
});
}
me.callParent();
- }
+ },
});
mixinConfig: {
before: {
- initComponent: 'cloneTemplates'
- }
+ initComponent: 'cloneTemplates',
+ },
},
cloneTemplates: function() {
var me = this;
- if (typeof(me.cbindData) == "function") {
+ if (typeof me.cbindData == "function") {
me.cbindData = me.cbindData(me.initialConfig);
}
me.cbindData = me.cbindData || {};
var getConfigValue = function(cname) {
-
if (cname in me.initialConfig) {
return me.initialConfig[cname];
}
if (cname in me.cbindData) {
let res = me.cbindData[cname];
- if (typeof(res) == "function") {
+ if (typeof res == "function") {
return res(me.initialConfig);
} else {
return res;
if (!found) {
throw "unable to parse cbind template '" + cdata + "'";
}
-
}
};
for (prop in me) {
el = me[prop];
if (el === undefined || el === null) continue;
- if (typeof(el) === 'object' && el.constructor == Object) {
+ if (typeof el === 'object' && el.constructor == Object) {
if (el.xtype && prop != 'config') {
me[prop] = cloneTemplateObject(el);
}
};
condCloneProperties();
- }
+ },
});
Ext.define('apt-pkglist', {
extend: 'Ext.data.Model',
- fields: [ 'Package', 'Title', 'Description', 'Section', 'Arch',
- 'Priority', 'Version', 'OldVersion', 'ChangeLogUrl', 'Origin' ],
- idProperty: 'Package'
+ fields: ['Package', 'Title', 'Description', 'Section', 'Arch',
+ 'Priority', 'Version', 'OldVersion', 'ChangeLogUrl', 'Origin'],
+ idProperty: 'Package',
});
Ext.define('Proxmox.node.APT', {
header: gettext('Package'),
width: 200,
sortable: true,
- dataIndex: 'Package'
+ dataIndex: 'Package',
},
{
text: gettext('Version'),
header: gettext('current'),
width: 100,
sortable: false,
- dataIndex: 'OldVersion'
+ dataIndex: 'OldVersion',
},
{
header: gettext('new'),
width: 100,
sortable: false,
- dataIndex: 'Version'
- }
- ]
+ dataIndex: 'Version',
+ },
+ ],
},
{
header: gettext('Description'),
sortable: false,
dataIndex: 'Title',
- flex: 1
- }
+ flex: 1,
+ },
],
- initComponent : function() {
+ initComponent: function() {
var me = this;
if (!me.nodename) {
groupField: 'Origin',
proxy: {
type: 'proxmox',
- url: "/api2/json/nodes/" + me.nodename + "/apt/update"
+ url: "/api2/json/nodes/" + me.nodename + "/apt/update",
},
sorters: [
{
- property : 'Package',
- direction: 'ASC'
- }
- ]
+ property: 'Package',
+ direction: 'ASC',
+ },
+ ],
});
var groupingFeature = Ext.create('Ext.grid.feature.Grouping', {
groupHeaderTpl: '{[ "Origin: " + values.name ]} ({rows.length} Item{[values.rows.length > 1 ? "s" : ""]})',
- enableGroupingMenu: false
+ enableGroupingMenu: false,
});
var rowBodyFeature = Ext.create('Ext.grid.feature.RowBody', {
- getAdditionalData: function (data, rowIndex, record, orig) {
+ getAdditionalData: function(data, rowIndex, record, orig) {
var headerCt = this.view.headerCt;
var colspan = headerCt.getColumnCount();
return {
Ext.String.htmlEncode(data.Description) +
'</div>',
rowBodyCls: me.full_description ? '' : Ext.baseCSSPrefix + 'grid-row-body-hidden',
- rowBodyColspan: colspan
+ rowBodyColspan: colspan,
};
- }
+ },
});
var reload = function() {
Proxmox.Utils.monStoreErrors(me, store, true);
- var apt_command = function(cmd){
+ var apt_command = function(cmd) {
Proxmox.Utils.API2Request({
url: "/nodes/" + me.nodename + "/apt/" + cmd,
method: 'POST',
var upid = response.result.data;
var win = Ext.create('Proxmox.window.TaskViewer', {
- upid: upid
+ upid: upid,
});
win.show();
me.mon(win, 'close', reload);
- }
+ },
});
};
text: gettext('Refresh'),
handler: function() {
Proxmox.Utils.checked_command(function() { apt_command('update'); });
- }
+ },
});
var show_changelog = function(rec) {
'background-color': 'white',
'white-space': 'pre',
'font-family': 'monospace',
- padding: '5px'
- }
+ padding: '5px',
+ },
});
var win = Ext.create('Ext.window.Window', {
height: 400,
layout: 'fit',
modal: true,
- items: [ view ]
+ items: [view],
});
Proxmox.Utils.API2Request({
url: "/nodes/" + me.nodename + "/apt/changelog",
params: {
name: rec.data.Package,
- version: rec.data.Version
+ version: rec.data.Version,
},
method: 'GET',
failure: function(response, opts) {
success: function(response, opts) {
win.show();
view.update(Ext.htmlEncode(response.result.data));
- }
+ },
});
-
};
var changelog_btn = new Proxmox.button.Button({
},
handler: function(b, e, rec) {
show_changelog(rec);
- }
+ },
});
var verbose_desc_checkbox = new Ext.form.field.Checkbox({
change: (f, val) => {
me.full_description = val;
me.getView().refresh();
- }
- }
+ },
+ },
});
if (me.upgradeBtn) {
- me.tbar = [ update_btn, me.upgradeBtn, changelog_btn, '->', verbose_desc_checkbox ];
+ me.tbar = [update_btn, me.upgradeBtn, changelog_btn, '->', verbose_desc_checkbox];
} else {
- me.tbar = [ update_btn, changelog_btn, '->', verbose_desc_checkbox ];
+ me.tbar = [update_btn, changelog_btn, '->', verbose_desc_checkbox];
}
Ext.apply(me, {
selModel: sm,
viewConfig: {
stripeRows: false,
- emptyText: '<div style="display:table; width:100%; height:100%;"><div style="display:table-cell; vertical-align: middle; text-align:center;"><b>' + gettext('No updates available.') + '</div></div>'
+ emptyText: '<div style="display:table; width:100%; height:100%;"><div style="display:table-cell; vertical-align: middle; text-align:center;"><b>' + gettext('No updates available.') + '</div></div>',
},
- features: [ groupingFeature, rowBodyFeature ],
+ features: [groupingFeature, rowBodyFeature],
listeners: {
activate: reload,
itemdblclick: function(v, rec) {
show_changelog(rec);
- }
- }
+ },
+ },
});
me.callParent();
- }
+ },
});
extend: 'Proxmox.window.Edit',
alias: ['widget.proxmoxNodeDNSEdit'],
- initComponent : function() {
+ initComponent: function() {
var me = this;
if (!me.nodename) {
xtype: 'textfield',
fieldLabel: gettext('Search domain'),
name: 'search',
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'proxmoxtextfield',
fieldLabel: gettext('DNS server') + " 1",
vtype: 'IP64Address',
skipEmptyText: true,
- name: 'dns1'
+ name: 'dns1',
},
{
xtype: 'proxmoxtextfield',
fieldLabel: gettext('DNS server') + " 2",
vtype: 'IP64Address',
skipEmptyText: true,
- name: 'dns2'
+ name: 'dns2',
},
{
xtype: 'proxmoxtextfield',
fieldLabel: gettext('DNS server') + " 3",
vtype: 'IP64Address',
skipEmptyText: true,
- name: 'dns3'
- }
+ name: 'dns3',
+ },
];
Ext.applyIf(me, {
subject: gettext('DNS'),
url: "/api2/extjs/nodes/" + me.nodename + "/dns",
fieldDefaults: {
- labelWidth: 120
- }
+ labelWidth: 120,
+ },
});
me.callParent();
me.load();
- }
+ },
});
extend: 'Proxmox.grid.ObjectGrid',
alias: ['widget.proxmoxNodeDNSView'],
- initComponent : function() {
+ initComponent: function() {
var me = this;
if (!me.nodename) {
var run_editor = function() {
var win = Ext.create('Proxmox.node.DNSEdit', {
- nodename: me.nodename
+ nodename: me.nodename,
});
win.show();
};
search: {
header: 'Search domain',
required: true,
- renderer: Ext.htmlEncode
+ renderer: Ext.htmlEncode,
},
dns1: {
header: gettext('DNS server') + " 1",
required: true,
- renderer: Ext.htmlEncode
+ renderer: Ext.htmlEncode,
},
dns2: {
header: gettext('DNS server') + " 2",
- renderer: Ext.htmlEncode
+ renderer: Ext.htmlEncode,
},
dns3: {
header: gettext('DNS server') + " 3",
- renderer: Ext.htmlEncode
- }
+ renderer: Ext.htmlEncode,
+ },
},
tbar: [
{
text: gettext("Edit"),
- handler: run_editor
- }
+ handler: run_editor,
+ },
],
listeners: {
- itemdblclick: run_editor
- }
+ itemdblclick: run_editor,
+ },
});
me.callParent();
me.on('activate', me.rstore.startUpdate);
me.on('deactivate', me.rstore.stopUpdate);
me.on('destroy', me.rstore.stopUpdate);
- }
+ },
});
Proxmox.Utils.API2Request({
params: {
digest: me.digest,
- data: me.down('#hostsfield').getValue()
+ data: me.down('#hostsfield').getValue(),
},
method: 'POST',
url: '/nodes/' + me.nodename + '/hosts',
},
failure: function(response, opts) {
Ext.Msg.alert('Error', response.htmlStatus);
- }
+ },
});
- }
+ },
},
{
text: gettext('Revert'),
handler: function() {
var me = this.up('panel');
me.down('#hostsfield').reset();
- }
- }
+ },
+ },
],
layout: 'fit',
itemId: 'hostsfield',
fieldStyle: {
'font-family': 'monospace',
- 'white-space': 'pre'
+ 'white-space': 'pre',
},
listeners: {
dirtychange: function(ta, dirty) {
var me = this.up('panel');
me.down('#savebtn').setDisabled(!dirty);
me.down('#resetbtn').setDisabled(!dirty);
- }
- }
- }
+ },
+ },
+ },
],
- initComponent : function() {
+ initComponent: function() {
var me = this;
if (!me.nodename) {
proxy: {
type: 'proxmox',
url: "/api2/json/nodes/" + me.nodename + "/hosts",
- }
+ },
});
me.callParent();
});
me.reload();
- }
+ },
});
extend: 'Proxmox.window.Edit',
alias: ['widget.proxmoxNodeNetworkEdit'],
- initComponent : function() {
+ initComponent: function() {
var me = this;
if (!me.nodename) {
fieldLabel: gettext('Autostart'),
name: 'autostart',
uncheckedValue: 0,
- checked: me.isCreate ? true : undefined
+ checked: me.isCreate ? true : undefined,
});
}
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('VLAN aware'),
name: 'bridge_vlan_aware',
- deleteEmpty: !me.isCreate
+ deleteEmpty: !me.isCreate,
});
column2.push({
xtype: 'textfield',
fieldLabel: gettext('Bridge ports'),
- name: 'bridge_ports'
+ name: 'bridge_ports',
});
} else if (me.iftype === 'OVSBridge') {
column2.push({
xtype: 'textfield',
fieldLabel: gettext('Bridge ports'),
- name: 'ovs_ports'
+ name: 'ovs_ports',
});
column2.push({
xtype: 'textfield',
fieldLabel: gettext('OVS options'),
- name: 'ovs_options'
+ name: 'ovs_options',
});
} else if (me.iftype === 'OVSPort' || me.iftype === 'OVSIntPort') {
column2.push({
allowBlank: false,
nodename: me.nodename,
bridgeType: 'OVSBridge',
- name: 'ovs_bridge'
+ name: 'ovs_bridge',
});
column2.push({
xtype: 'pveVlanField',
deleteEmpty: !me.isCreate,
name: 'ovs_tag',
- value: ''
+ value: '',
});
column2.push({
xtype: 'textfield',
fieldLabel: gettext('OVS options'),
- name: 'ovs_options'
+ name: 'ovs_options',
});
} else if (me.iftype === 'vlan') {
-
if (!me.isCreate) {
-
me.disablevlanid = false;
me.disablevlanrawdevice = false;
me.vlanrawdevicevalue = '';
var arr = Proxmox.Utils.VlanInterface_match.exec(me.iface);
me.vlanrawdevicevalue = arr[1];
me.vlanidvalue = arr[2];
-
} else if (Proxmox.Utils.Vlan_match.test(me.iface)) {
me.disablevlanid = true;
var arr = Proxmox.Utils.Vlan_match.exec(me.iface);
me.vlanidvalue = arr[1];
}
} else {
-
me.disablevlanid = true;
me.disablevlanrawdevice = true;
}
fieldLabel: gettext('Vlan raw device'),
name: 'vlan-raw-device',
value: me.vlanrawdevicevalue,
- disabled: me.disablevlanrawdevice
+ disabled: me.disablevlanrawdevice,
});
column2.push({
xtype: 'pveVlanField',
name: 'vlan-id',
value: me.vlanidvalue,
- disabled: me.disablevlanid
+ disabled: me.disablevlanid,
});
columnB.push({
userCls: 'pmx-hint',
text: 'Either add the VLAN number to an existing interface name, or choose your own name and set the VLAN raw device (for the latter ifupdown1 supports vlanXY naming only)',
});
-
} else if (me.iftype === 'bond') {
column2.push({
xtype: 'textfield',
fieldLabel: gettext('Slaves'),
- name: 'slaves'
+ name: 'slaves',
});
var policySelector = Ext.createWidget('bondPolicySelector', {
fieldLabel: gettext('Hash policy'),
name: 'bond_xmit_hash_policy',
deleteEmpty: !me.isCreate,
- disabled: true
+ disabled: true,
});
var primaryfield = Ext.createWidget('textfield', {
fieldLabel: gettext('bond-primary'),
name: 'bond-primary',
value: '',
- disabled: true
+ disabled: true,
});
column2.push({
primaryfield.setDisabled(true);
primaryfield.setValue('');
}
- }
+ },
},
- allowBlank: false
+ allowBlank: false,
});
column2.push(policySelector);
column2.push(primaryfield);
-
} else if (me.iftype === 'OVSBond') {
column2.push({
xtype: me.isCreate ? 'PVE.form.BridgeSelector' : 'displayfield',
allowBlank: false,
nodename: me.nodename,
bridgeType: 'OVSBridge',
- name: 'ovs_bridge'
+ name: 'ovs_bridge',
});
column2.push({
xtype: 'pveVlanField',
deleteEmpty: !me.isCreate,
name: 'ovs_tag',
- value: ''
+ value: '',
});
column2.push({
xtype: 'textfield',
fieldLabel: gettext('OVS options'),
- name: 'ovs_options'
+ name: 'ovs_options',
});
}
fieldLabel: gettext('Comment'),
allowBlank: true,
nodename: me.nodename,
- name: 'comments'
+ name: 'comments',
});
var url;
column1.push({
xtype: 'hiddenfield',
name: 'type',
- value: me.iftype
+ value: me.iftype,
},
{
xtype: me.isCreate ? 'textfield' : 'displayfield',
vlanrawdeviceField.setDisabled(false);
}
}
- }
- }
+ },
+ },
});
if (me.iftype === 'OVSBond') {
name: 'bond_mode',
openvswitch: true,
value: me.isCreate ? 'active-backup' : undefined,
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'textfield',
fieldLabel: gettext('Slaves'),
- name: 'ovs_bonds'
- }
+ name: 'ovs_bonds',
+ },
);
} else {
-
column1.push(
{
xtype: 'proxmoxtextfield',
deleteEmpty: !me.isCreate,
fieldLabel: 'IPv4/CIDR',
vtype: 'IPCIDRAddress',
- name: 'cidr'
+ name: 'cidr',
},
{
xtype: 'proxmoxtextfield',
deleteEmpty: !me.isCreate,
fieldLabel: gettext('Gateway') + ' (IPv4)',
vtype: 'IPAddress',
- name: 'gateway'
+ name: 'gateway',
},
{
xtype: 'proxmoxtextfield',
deleteEmpty: !me.isCreate,
fieldLabel: 'IPv6/CIDR',
vtype: 'IP6CIDRAddress',
- name: 'cidr6'
+ name: 'cidr6',
},
{
xtype: 'proxmoxtextfield',
deleteEmpty: !me.isCreate,
fieldLabel: gettext('Gateway') + ' (IPv6)',
vtype: 'IP6Address',
- name: 'gateway6'
+ name: 'gateway6',
},
);
- advancedColumn1. push(
+ advancedColumn1.push(
{
xtype: 'proxmoxintegerfield',
minValue: 1280,
deleteEmpty: !me.isCreate,
emptyText: 1500,
fieldLabel: 'MTU',
- name: 'mtu'
+ name: 'mtu',
},
);
}
columnB: columnB,
advancedColumn1: advancedColumn1,
advancedColumn2: advancedColumn2,
- }
+ },
});
me.callParent();
}
me.setValues(data);
me.isValid(); // trigger validation
- }
+ },
});
}
- }
+ },
});
'slaves',
'type',
],
- idProperty: 'iface'
+ idProperty: 'iface',
});
Ext.define('Proxmox.node.NetworkView', {
showApplyBtn: false,
- initComponent : function() {
+ initComponent: function() {
var me = this;
if (!me.nodename) {
model: 'proxmox-networks',
proxy: {
type: 'proxmox',
- url: '/api2/json' + baseUrl
+ url: '/api2/json' + baseUrl,
},
sorters: [
{
- property : 'iface',
- direction: 'ASC'
- }
- ]
+ property: 'iface',
+ direction: 'ASC',
+ },
+ ],
});
var reload = function() {
apply_btn.setDisabled(false);
revert_btn.setDisabled(false);
}
- }
+ },
});
};
var win = Ext.create('Proxmox.node.NetworkEdit', {
nodename: me.nodename,
iface: rec.data.iface,
- iftype: rec.data.type
+ iftype: rec.data.type,
});
win.show();
win.on('destroy', reload);
var edit_btn = new Ext.Button({
text: gettext('Edit'),
disabled: true,
- handler: run_editor
+ handler: run_editor,
});
var del_btn = new Ext.Button({
text: gettext('Remove'),
disabled: true,
- handler: function(){
+ handler: function() {
var grid = me.down('gridpanel');
var sm = grid.getSelectionModel();
var rec = sm.getSelection()[0];
},
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
- }
+ },
});
var apply_btn = Ext.create('Proxmox.button.Button', {
var win = Ext.create('Proxmox.window.TaskProgress', {
taskDone: reload,
- upid: upid
+ upid: upid,
});
win.show();
},
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
- }
+ },
});
var set_button_status = function() {
});
win.on('destroy', reload);
win.show();
- }
+ },
});
}
});
win.on('destroy', reload);
win.show();
- }
+ },
});
}
});
win.on('destroy', reload);
win.show();
- }
+ },
});
}
var win = Ext.create('Proxmox.node.NetworkEdit', {
nodename: me.nodename,
iftype: 'OVSBridge',
- iface_default: find_next_iface_id('vmbr')
+ iface_default: find_next_iface_id('vmbr'),
});
win.on('destroy', reload);
win.show();
- }
+ },
},
{
text: Proxmox.Utils.render_network_iface_type('OVSBond'),
var win = Ext.create('Proxmox.node.NetworkEdit', {
nodename: me.nodename,
iftype: 'OVSBond',
- iface_default: find_next_iface_id('bond')
+ iface_default: find_next_iface_id('bond'),
});
win.on('destroy', reload);
win.show();
- }
+ },
},
{
text: Proxmox.Utils.render_network_iface_type('OVSIntPort'),
handler: function() {
var win = Ext.create('Proxmox.node.NetworkEdit', {
nodename: me.nodename,
- iftype: 'OVSIntPort'
+ iftype: 'OVSIntPort',
});
win.on('destroy', reload);
win.show();
- }
- }
+ },
+ },
);
}
text: gettext('Create'),
menu: {
plain: true,
- items: menu_items
- }
+ items: menu_items,
+ },
}, '-',
{
text: gettext('Revert'),
},
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
- }
+ },
},
edit_btn,
del_btn,
'-',
- apply_btn
+ apply_btn,
],
items: [
{
{
header: gettext('Name'),
sortable: true,
- dataIndex: 'iface'
+ dataIndex: 'iface',
},
{
header: gettext('Type'),
sortable: true,
width: 120,
renderer: Proxmox.Utils.render_network_iface_type,
- dataIndex: 'type'
+ dataIndex: 'type',
},
{
xtype: 'booleancolumn',
dataIndex: 'autostart',
trueText: Proxmox.Utils.yesText,
falseText: Proxmox.Utils.noText,
- undefinedText: Proxmox.Utils.noText
+ undefinedText: Proxmox.Utils.noText,
},
{
xtype: 'booleancolumn',
dataIndex: 'bridge_vlan_aware',
trueText: Proxmox.Utils.yesText,
falseText: Proxmox.Utils.noText,
- undefinedText: Proxmox.Utils.noText
+ undefinedText: Proxmox.Utils.noText,
},
{
header: gettext('Ports/Slaves'),
dataIndex: 'type',
- renderer: render_ports
+ renderer: render_ports,
},
{
header: gettext('Bond Mode'),
header: gettext('Comment'),
dataIndex: 'comments',
flex: 1,
- renderer: Ext.String.htmlEncode
- }
+ renderer: Ext.String.htmlEncode,
+ },
],
listeners: {
selectionchange: set_button_status,
- itemdblclick: run_editor
- }
+ itemdblclick: run_editor,
+ },
},
{
border: false,
itemId: 'changes',
tbar: [
gettext('Pending changes') + ' (' +
- gettext("Either reboot or use 'Apply Configuration' (needs ifupdown2) to activate") + ')'
+ gettext("Either reboot or use 'Apply Configuration' (needs ifupdown2) to activate") + ')',
],
split: true,
bodyPadding: 5,
flex: 0.6,
- html: gettext("No changes")
- }
+ html: gettext("No changes"),
+ },
],
});
me.callParent();
reload();
- }
+ },
});
Ext.define('proxmox-services', {
extend: 'Ext.data.Model',
- fields: [ 'service', 'name', 'desc', 'state' ],
- idProperty: 'service'
+ fields: ['service', 'name', 'desc', 'state'],
+ idProperty: 'service',
});
Ext.define('Proxmox.node.ServiceView', {
startOnlyServices: {},
- initComponent : function() {
+ initComponent: function() {
var me = this;
if (!me.nodename) {
model: 'proxmox-services',
proxy: {
type: 'proxmox',
- url: "/api2/json/nodes/" + me.nodename + "/services"
- }
+ url: "/api2/json/nodes/" + me.nodename + "/services",
+ },
});
var store = Ext.create('Proxmox.data.DiffStore', {
sortAfterUpdate: true,
sorters: [
{
- property : 'name',
- direction: 'ASC'
- }
- ]
+ property: 'name',
+ direction: 'ASC',
+ },
+ ],
});
var view_service_log = function() {
xtype: 'proxmoxLogView',
url: "/api2/extjs/nodes/" + me.nodename + "/syslog?service=" +
rec.data.service,
- log_select_timespan: 1
- }
+ log_select_timespan: 1,
+ },
});
win.show();
};
var upid = response.result.data;
var win = Ext.create('Proxmox.window.TaskProgress', {
- upid: upid
+ upid: upid,
});
win.show();
- }
+ },
});
};
var start_btn = new Ext.Button({
text: gettext('Start'),
disabled: true,
- handler: function(){
+ handler: function() {
service_cmd("start");
- }
+ },
});
var stop_btn = new Ext.Button({
text: gettext('Stop'),
disabled: true,
- handler: function(){
+ handler: function() {
service_cmd("stop");
- }
+ },
});
var restart_btn = new Ext.Button({
text: gettext('Restart'),
disabled: true,
- handler: function(){
+ handler: function() {
service_cmd("restart");
- }
+ },
});
var syslog_btn = new Ext.Button({
text: gettext('Syslog'),
disabled: true,
- handler: view_service_log
+ handler: view_service_log,
});
var set_button_status = function() {
restart_btn.disable();
}
stop_btn.disable();
- } else {
- if (state == 'running') {
+ } else if (state == 'running') {
start_btn.disable();
restart_btn.enable();
stop_btn.enable();
restart_btn.disable();
stop_btn.disable();
}
- }
};
me.mon(store, 'refresh', set_button_status);
Ext.apply(me, {
store: store,
stateful: false,
- tbar: [ start_btn, stop_btn, restart_btn, syslog_btn ],
+ tbar: [start_btn, stop_btn, restart_btn, syslog_btn],
columns: [
{
header: gettext('Name'),
flex: 1,
sortable: true,
- dataIndex: 'name'
+ dataIndex: 'name',
},
{
header: gettext('Status'),
width: 100,
sortable: true,
- dataIndex: 'state'
+ dataIndex: 'state',
},
{
header: gettext('Description'),
renderer: Ext.String.htmlEncode,
dataIndex: 'desc',
- flex: 2
- }
+ flex: 2,
+ },
],
listeners: {
selectionchange: set_button_status,
itemdblclick: view_service_log,
activate: rstore.startUpdate,
- destroy: rstore.stopUpdate
- }
+ destroy: rstore.stopUpdate,
+ },
});
me.callParent();
- }
+ },
});
autoLoad: true,
fieldDefaults: {
- labelWidth: 70
+ labelWidth: 70,
},
items: {
editable: true,
anyMatch: true,
forceSelection: true,
- allowBlank: false
+ allowBlank: false,
},
- initComponent : function() {
+ initComponent: function() {
var me = this;
if (!me.nodename) {
me.url = "/api2/extjs/nodes/" + me.nodename + "/time";
me.callParent();
- }
+ },
});
extend: 'Proxmox.grid.ObjectGrid',
alias: ['widget.proxmoxNodeTimeView'],
- initComponent : function() {
+ initComponent: function() {
var me = this;
if (!me.nodename) {
throw "no node name specified";
}
- var tzoffset = (new Date()).getTimezoneOffset()*60000;
+ var tzoffset = new Date().getTimezoneOffset()*60000;
var renderlocaltime = function(value) {
- var servertime = new Date((value * 1000) + tzoffset);
+ var servertime = new Date(value * 1000 + tzoffset);
return Ext.Date.format(servertime, 'Y-m-d H:i:s');
};
var run_editor = function() {
var win = Ext.create('Proxmox.node.TimeEdit', {
- nodename: me.nodename
+ nodename: me.nodename,
});
win.show();
};
rows: {
timezone: {
header: gettext('Time zone'),
- required: true
+ required: true,
},
localtime: {
header: gettext('Server time'),
required: true,
- renderer: renderlocaltime
- }
+ renderer: renderlocaltime,
+ },
},
tbar: [
{
text: gettext("Edit"),
- handler: run_editor
- }
+ handler: run_editor,
+ },
],
listeners: {
- itemdblclick: run_editor
- }
+ itemdblclick: run_editor,
+ },
});
me.callParent();
me.on('activate', me.rstore.startUpdate);
me.on('deactivate', me.rstore.stopUpdate);
me.on('destroy', me.rstore.stopUpdate);
- }
+ },
});
defaults: {
style: {
- 'text-align':'center'
- }
+ 'text-align': 'center',
+ },
},
items: [
{
xtype: 'box',
itemId: 'title',
data: {
- title: ''
+ title: '',
},
- tpl: '<h3>{title}</h3>'
+ tpl: '<h3>{title}</h3>',
},
{
xtype: 'polar',
sectors: [0],
donut: 90,
needleLength: 100,
- totalAngle: Math.PI
+ totalAngle: Math.PI,
}],
sprites: [{
id: 'valueSprite',
textBaseline: 'bottom',
x: 125,
y: 110,
- fontSize: 30
- }]
+ fontSize: 30,
+ }],
},
{
xtype: 'box',
- itemId: 'text'
- }
+ itemId: 'text',
+ },
],
header: false,
me.callParent();
if (me.title) {
- me.getComponent('title').update({title: me.title});
+ me.getComponent('title').update({ title: me.title });
}
me.text = me.getComponent('text');
me.chart = me.getComponent('chart');
me.valueSprite = me.chart.getSurface('chart').get('valueSprite');
- }
+ },
});
if (this.onlineHelp) {
Ext.GlobalEvents.fireEvent('proxmoxHideHelp', this.onlineHelp);
}
- }
+ },
},
border: false,
{
columnWidth: 1,
layout: 'anchor',
- items: me.items
- }
+ items: me.items,
+ },
];
me.items = undefined;
} else if (me.column4) {
columnWidth: 0.25,
padding: '0 10 0 0',
layout: 'anchor',
- items: me.column1
+ items: me.column1,
},
{
columnWidth: 0.25,
padding: '0 10 0 0',
layout: 'anchor',
- items: me.column2
+ items: me.column2,
},
{
columnWidth: 0.25,
padding: '0 10 0 0',
layout: 'anchor',
- items: me.column3
+ items: me.column3,
},
{
columnWidth: 0.25,
padding: '0 0 0 10',
layout: 'anchor',
- items: me.column4
- }
+ items: me.column4,
+ },
];
if (me.columnB) {
items.push({
columnWidth: 1,
padding: '10 0 0 0',
layout: 'anchor',
- items: me.columnB
+ items: me.columnB,
});
}
} else if (me.column1) {
columnWidth: 0.5,
padding: '0 10 0 0',
layout: 'anchor',
- items: me.column1
+ items: me.column1,
},
{
columnWidth: 0.5,
padding: '0 0 0 10',
layout: 'anchor',
- items: me.column2 || [] // allow empty column
- }
+ items: me.column2 || [], // allow empty column
+ },
];
if (me.columnB) {
items.push({
columnWidth: 1,
padding: '10 0 0 0',
layout: 'anchor',
- items: me.columnB
+ items: me.columnB,
});
}
} else {
{
columnWidth: 1,
layout: 'anchor',
- items: me.advancedItems
- }
+ items: me.advancedItems,
+ },
];
me.advancedItems = undefined;
} else if (me.advancedColumn1) {
columnWidth: 0.5,
padding: '0 10 0 0',
layout: 'anchor',
- items: me.advancedColumn1
+ items: me.advancedColumn1,
},
{
columnWidth: 0.5,
padding: '0 0 0 10',
layout: 'anchor',
- items: me.advancedColumn2 || [] // allow empty column
- }
+ items: me.advancedColumn2 || [], // allow empty column
+ },
];
me.advancedColumn1 = undefined;
columnWidth: 1,
padding: '10 0 0 0',
layout: 'anchor',
- items: me.advancedColumnB
+ items: me.advancedColumnB,
});
me.advancedColumnB = undefined;
}
hidden: false,
border: true,
autoEl: {
- tag: 'hr'
- }
+ tag: 'hr',
+ },
});
items.push({
columnWidth: 1,
hidden: !me.showAdvanced,
layout: 'column',
defaults: {
- border: false
+ border: false,
},
- items: advItems
+ items: advItems,
});
}
items: Ext.apply(me.useFieldContainer, {
layout: 'column',
defaultType: 'container',
- items: items
- })
+ items: items,
+ }),
});
} else {
Ext.apply(me, {
layout: 'column',
defaultType: 'container',
- items: items
+ items: items,
});
}
me.callParent();
- }
+ },
});
false,
false,
Ext.Date.format(since, "U"),
- Ext.Date.format(until, "U")
+ Ext.Date.format(until, "U"),
]);
},
if (livemode) {
if (!top && view.startcursor) {
params = {
- startcursor: view.startcursor
+ startcursor: view.startcursor,
};
} else if (view.endcursor) {
params.endcursor = view.endcursor;
} else {
params = {
since: since,
- until: until
+ until: until,
};
}
Proxmox.Utils.API2Request({
url: view.url,
params: params,
- waitMsgTarget: (!livemode) ? view : undefined,
+ waitMsgTarget: !livemode ? view : undefined,
method: 'GET',
success: function(response) {
Proxmox.Utils.setErrorMask(me, false);
me.requested = false;
view.loadTask.delay(200);
}
- }
+ },
});
},
view.loadTask.delay(200, undefined, undefined, [true, false]);
}
},
- interval: 1000
+ interval: 1000,
});
},
var me = this;
me.getViewModel().set('livemode', false);
me.updateView([], false);
- }
+ },
},
onDestroy: function() {
data: {
livemode: true,
until: null,
- since: null
- }
+ since: null,
+ },
},
layout: 'auto',
fn: function(scroller, x, y) {
var controller = this.component.getController();
if (controller) { // on destroy, controller can be gone
- controller.onScroll(x,y);
+ controller.onScroll(x, y);
}
},
- buffer: 200
+ buffer: 200,
},
- }
+ },
},
tbar: {
{
text: gettext('Live Mode'),
bind: {
- pressed: '{livemode}'
+ pressed: '{livemode}',
},
handler: 'onLiveMode',
},
{
text: gettext('Select Timespan'),
bind: {
- pressed: '{!livemode}'
+ pressed: '{!livemode}',
},
handler: 'onTimespan',
- }
- ]
+ },
+ ],
},
{
xtype: 'box',
bind: { disabled: '{livemode}' },
- autoEl: { cn: gettext('Since') + ':' }
+ autoEl: { cn: gettext('Since') + ':' },
},
{
xtype: 'datefield',
bind: {
disabled: '{livemode}',
value: '{since}',
- maxValue: '{until}'
- }
+ maxValue: '{until}',
+ },
},
{
xtype: 'box',
bind: { disabled: '{livemode}' },
- autoEl: { cn: gettext('Until') + ':' }
+ autoEl: { cn: gettext('Until') + ':' },
},
{
xtype: 'datefield',
bind: {
disabled: '{livemode}',
value: '{until}',
- minValue: '{since}'
- }
+ minValue: '{since}',
+ },
},
{
xtype: 'button',
reference: 'updateBtn',
handler: 'updateParams',
bind: {
- disabled: '{livemode}'
- }
- }
- ]
+ disabled: '{livemode}',
+ },
+ },
+ ],
},
items: [
reference: 'content',
style: {
font: 'normal 11px tahoma, arial, verdana, sans-serif',
- 'white-space': 'pre'
+ 'white-space': 'pre',
},
- }
- ]
+ },
+ ],
});
viewModel.set('data', {
first: first,
total: total,
- textlen: text.length
+ textlen: text.length,
});
var scrollPos = me.scrollPosBottom();
me.requested = false;
view.loadTask.delay(200);
}
- }
+ },
});
},
var viewStart = Math.max(parseInt(line - 1 - view.viewBuffer, 10), 0);
var viewEnd = parseInt(line + viewLines + 1 + view.viewBuffer, 10);
- if (viewStart < start || viewEnd > (start+limit)) {
+ if (viewStart < start || viewEnd > start+limit) {
viewModel.set('params.start',
Math.max(parseInt(line - limit/2 + 10, 10), 0));
view.loadTask.delay(200);
view.loadTask.delay(200);
}
},
- interval: 1000
+ interval: 1000,
});
- }
+ },
},
onDestroy: function() {
data: {
start: 0,
total: 0,
- textlen: 0
+ textlen: 0,
},
params: {
start: 0,
limit: 500,
- }
- }
+ },
+ },
},
layout: 'auto',
fn: function(scroller, x, y) {
var controller = this.component.getController();
if (controller) { // on destroy, controller can be gone
- controller.onScroll(x,y);
+ controller.onScroll(x, y);
}
},
- buffer: 200
+ buffer: 200,
},
- }
+ },
},
tbar: {
bind: {
- hidden: '{hide_timespan}'
+ hidden: '{hide_timespan}',
},
items: [
'->',
format: 'Y-m-d',
bind: {
value: '{since}',
- maxValue: '{until}'
- }
+ maxValue: '{until}',
+ },
},
'Until: ',
{
format: 'Y-m-d',
bind: {
value: '{until}',
- minValue: '{since}'
- }
+ minValue: '{since}',
+ },
},
{
xtype: 'button',
text: 'Update',
- handler: 'updateParams'
- }
+ handler: 'updateParams',
+ },
],
},
reference: 'content',
style: {
font: 'normal 11px tahoma, arial, verdana, sans-serif',
- 'white-space': 'pre'
+ 'white-space': 'pre',
},
- }
- ]
+ },
+ ],
});
xclass: 'Ext.app.ViewController',
convertToUnits: function(value) {
- var units = ['', 'k','M','G','T', 'P'];
+ var units = ['', 'k', 'M', 'G', 'T', 'P'];
var si = 0;
let format = '0.##';
if (value < 0.1) format += '#';
- while(value >= 1000 && si < (units.length -1)){
+ while (value >= 1000 && si < units.length -1) {
value = value / 1000;
si++;
}
var ourUndoZoomButton = chart.header.tools[0];
var undoButton = chart.interactions[0].getUndoButton();
ourUndoZoomButton.setDisabled(undoButton.isDisabled());
- }
+ },
},
width: 770,
animation: false,
interactions: [
{
- type: 'crosszoom'
+ type: 'crosszoom',
},
],
legend: {
position: 'left',
grid: true,
renderer: 'leftAxisRenderer',
- minimum: 0
+ minimum: 0,
},
{
type: 'time',
position: 'bottom',
grid: true,
- fields: ['time']
+ fields: ['time'],
},
],
listeners: {
- animationend: 'onAfterAnimation'
+ animationend: 'onAfterAnimation',
},
initComponent: function() {
type: 'minus',
disabled: true,
tooltip: gettext('Undo Zoom'),
- handler: function(){
+ handler: function() {
var undoButton = me.interactions[0].getUndoButton();
if (undoButton.handler) {
undoButton.handler();
}
- }
+ },
});
}
// add a series for each field we get
- me.fields.forEach(function(item, index){
+ me.fields.forEach(function(item, index) {
var title = item;
if (me.fieldTitles && me.fieldTitles[index]) {
title = me.fieldTitles[index];
fill: true,
style: {
lineWidth: 1.5,
- opacity: 0.60
+ opacity: 0.60,
},
marker: {
opacity: 0,
scaling: 0.01,
fx: {
duration: 200,
- easing: 'easeOut'
- }
+ easing: 'easeOut',
+ },
},
highlightCfg: {
opacity: 1,
- scaling: 1.5
+ scaling: 1.5,
},
tooltip: {
trackMouse: true,
- renderer: 'onSeriesTooltipRender'
- }
+ renderer: 'onSeriesTooltipRender',
+ },
},
- me.seriesConfig
+ me.seriesConfig,
));
});
// enable animation after the store is loaded
me.store.onAfter('load', function() {
me.setAnimation(true);
- }, this, {single: true});
- }
+ }, this, { single: true });
+ },
});
Ext.iterate(values, function(id, val) {
let fields = formfields.filterBy((f) =>
- (f.id === id || f.name === id || f.dataIndex === id) && !f.up('inputpanel')
+ (f.id === id || f.name === id || f.dataIndex === id) && !f.up('inputpanel'),
);
fields.each((field) => {
field.setValue(val);
interval: 1000,
rows: {
status: { defaultValue: 'unknown' },
- exitstatus: { defaultValue: 'unknown' }
- }
+ exitstatus: { defaultValue: 'unknown' },
+ },
});
me.on('destroy', statstore.stopUpdate);
handler: function() {
var win = Ext.create('Proxmox.window.TaskViewer', {
taskDone: me.taskDone,
- upid: me.upid
+ upid: me.upid,
});
win.show();
me.close();
- }
- }
- ]
+ },
+ },
+ ],
});
me.callParent();
statstore.startUpdate();
pbar.wait();
- }
+ },
});
// fixme: how can we avoid those lint errors?
if (es) {
return value + ': ' + es;
}
- }
+ },
},
exitstatus: {
- visible: false
+ visible: false,
},
type: {
header: gettext('Task type'),
- required: true
+ required: true,
},
user: {
header: gettext('User name'),
renderer: Ext.String.htmlEncode,
- required: true
+ required: true,
},
node: {
header: gettext('Node'),
- required: true
+ required: true,
},
pid: {
header: gettext('Process ID'),
- required: true
+ required: true,
},
task_id: {
header: gettext('Task ID'),
starttime: {
header: gettext('Start Time'),
required: true,
- renderer: Proxmox.Utils.render_timestamp
+ renderer: Proxmox.Utils.render_timestamp,
},
upid: {
header: gettext('Unique task ID'),
renderer: Ext.String.htmlEncode,
- }
+ },
};
var statstore = Ext.create('Proxmox.data.ObjectStore', {
url: "/api2/json/nodes/" + task.node + "/tasks/" + me.upid + "/status",
interval: 1000,
- rows: rows
+ rows: rows,
});
me.on('destroy', statstore.stopUpdate);
method: 'DELETE',
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
};
var stop_btn1 = new Ext.Button({
text: gettext('Stop'),
disabled: true,
- handler: stop_task
+ handler: stop_task,
});
var stop_btn2 = new Ext.Button({
text: gettext('Stop'),
disabled: true,
- handler: stop_task
+ handler: stop_task,
});
statgrid = Ext.create('Proxmox.grid.ObjectGrid', {
title: gettext('Status'),
layout: 'fit',
- tbar: [ stop_btn1 ],
+ tbar: [stop_btn1],
rstore: statstore,
rows: rows,
- border: false
+ border: false,
});
var logView = Ext.create('Proxmox.panel.LogView', {
title: gettext('Output'),
- tbar: [ stop_btn2 ],
+ tbar: [stop_btn2],
border: false,
- url: "/api2/extjs/nodes/" + task.node + "/tasks/" + me.upid + "/log"
+ url: "/api2/extjs/nodes/" + task.node + "/tasks/" + me.upid + "/log",
});
me.mon(statstore, 'load', function() {
items: [{
xtype: 'tabpanel',
region: 'center',
- items: [ logView, statgrid ]
- }]
+ items: [logView, statgrid],
+ }],
});
me.callParent();
logView.fireEvent('show', logView);
- }
+ },
});
projects / proxmox-widget-toolkit.git / commitdiff