// avoid errors when running without development tools
-if (!Ext.isDefined(Ext.global.console)) {
- var console = {
- dir: function() {},
- log: function() {}
+if (!Ext.isDefined(Ext.global.console)) {
+ var console = {
+ dir: function() {},
+ log: function() {}
};
}
Ext.define('pve-param-schema', {
extend: 'Ext.data.Model',
- fields: [
- 'name', 'type', 'typetext', 'description', 'enum',
- 'minimum', 'maximum', 'minLength', 'maxLength',
+ fields: [
+ 'name', 'type', 'typetext', 'description', 'verbose_description',
+ 'enum', 'minimum', 'maximum', 'minLength', 'maxLength',
'pattern', 'title', 'requires', 'format', 'default',
'disallow', 'extends', 'links',
{
]
});
- var store = Ext.create('Ext.data.TreeStore', {
+ var store = Ext.define('pve-updated-treestore', {
+ extend: 'Ext.data.TreeStore',
model: Ext.define('pve-api-doc', {
extend: 'Ext.data.Model',
- fields: [
+ fields: [
'path', 'info', 'text',
]
}),
}, {
property: 'text',
direction: 'ASC'
- }]
- });
-
- var render_text = function(value, metaData, record) {
+ }],
+ filterer: 'bottomup',
+ doFilter: function(node) {
+ this.filterNodes(node, this.getFilters().getFilterFn(), true);
+ },
+
+ filterNodes: function(node, filterFn, parentVisible) {
+ var me = this,
+ bottomUpFiltering = me.filterer === 'bottomup',
+ match = filterFn(node) && parentVisible || (node.isRoot() && !me.getRootVisible()),
+ childNodes = node.childNodes,
+ len = childNodes && childNodes.length, i, matchingChildren;
+
+ if (len) {
+ for (i = 0; i < len; ++i) {
+ matchingChildren = me.filterNodes(childNodes[i], filterFn, match || bottomUpFiltering) || matchingChildren;
+ }
+ if (bottomUpFiltering) {
+ match = matchingChildren || match;
+ }
+ }
+
+ node.set("visible", match, me._silentOptions);
+ return match;
+ },
+
+ }).create();
+
+ var render_description = function(value, metaData, record) {
var pdef = record.data;
+ value = pdef.verbose_description || value;
+
+ // TODO: try to render asciidoc correctly
+
metaData.style = 'white-space:pre-wrap;'
return Ext.htmlEncode(value);
if (pdef['enum'])
return pdef['enum'].join(' | ');
- if (pdef.format)
+ if (pdef.format)
return pdef.format;
- if (pdef.pattern)
+ if (pdef.pattern)
return Ext.htmlEncode(pdef.pattern);
return '';
stripeRows: true
},
columns: [
- {
+ {
header: 'Name',
- dataIndex: 'name'
+ dataIndex: 'name',
+ flex: 1
},
- {
+ {
header: 'Type',
dataIndex: 'type',
renderer: render_type,
+ flex: 1
+ },
+ {
+ header: 'Default',
+ dataIndex: 'default',
+ flex: 1
},
- {
+ {
header: 'Format',
dataIndex: 'type',
renderer: render_format,
- flex: 1
+ flex: 2
},
- {
+ {
header: 'Description',
dataIndex: 'description',
- renderer: render_text,
- flex: 2
+ renderer: render_description,
+ flex: 6
}
]
});
if (info.returns) {
- var rtype = info.returns.type;
- if (!rtype && info.returns.items)
+ var retinf = info.returns;
+ var rtype = retinf.type;
+ if (!rtype && retinf.items)
rtype = 'array';
if (!rtype)
rtype = 'object';
- sections.push({
- title: 'Returns: ' + rtype
+ var rpstore = Ext.create('Ext.data.Store', {
+ model: 'pve-param-schema',
+ proxy: {
+ type: 'memory'
+ },
+ groupField: 'optional',
+ sorters: [
+ {
+ property: 'name',
+ direction: 'ASC'
+ }
+ ]
+ });
+
+ var properties;
+ if (rtype === 'array' && retinf.items.properties) {
+ properties = retinf.items.properties;
+ }
+
+ if (rtype === 'object' && retinf.properties) {
+ properties = retinf.properties;
+ }
+
+ Ext.Object.each(properties, function(name, pdef) {
+ pdef.name = name;
+ rpstore.add(pdef);
+ });
+
+ rpstore.sort();
+
+ var groupingFeature = Ext.create('Ext.grid.feature.Grouping',{
+ enableGroupingMenu: false,
+ groupHeaderTpl: '<tpl if="groupValue">Optional</tpl><tpl if="!groupValue">Obligatory</tpl>'
});
+ var returnhtml;
+ if (retinf.items) {
+ returnhtml = '<pre>items: ' + Ext.htmlEncode(JSON.stringify(retinf.items, null, 4)) + '</pre>';
+ }
+
+ if (retinf.properties) {
+ returnhtml = returnhtml || '';
+ returnhtml += '<pre>properties:' + Ext.htmlEncode(JSON.stringify(retinf.properties, null, 4)) + '</pre>';
+ }
+
+ var rawSection = Ext.create('Ext.panel.Panel', {
+ bodyPadding: '0px 10px 10px 10px',
+ html: returnhtml,
+ hidden: true
+ });
+
+ sections.push({
+ xtype: 'gridpanel',
+ title: 'Returns: ' + rtype,
+ features: [groupingFeature],
+ store: rpstore,
+ viewConfig: {
+ trackOver: false,
+ stripeRows: true
+ },
+ columns: [
+ {
+ header: 'Name',
+ dataIndex: 'name',
+ flex: 1
+ },
+ {
+ header: 'Type',
+ dataIndex: 'type',
+ renderer: render_type,
+ flex: 1
+ },
+ {
+ header: 'Default',
+ dataIndex: 'default',
+ flex: 1
+ },
+ {
+ header: 'Format',
+ dataIndex: 'type',
+ renderer: render_format,
+ flex: 2
+ },
+ {
+ header: 'Description',
+ dataIndex: 'description',
+ renderer: render_description,
+ flex: 6
+ }
+ ],
+ bbar: [
+ {
+ xtype: 'button',
+ text: 'Show RAW',
+ handler: function(btn) {
+ rawSection.setVisible(!rawSection.isVisible());
+ btn.setText(rawSection.isVisible() ? 'Hide RAW' : 'Show RAW');
+ }}
+ ]
+ });
+
+ sections.push(rawSection);
+
+
}
var permhtml = '';
if (info.permissions.user) {
if (!info.permissions.description) {
if (info.permissions.user === 'world') {
- permhtml += "Accessible without any authententification.";
+ permhtml += "Accessible without any authentication.";
} else if (info.permissions.user === 'all') {
- permhtml += "Accessible by all authententicated users.";
+ permhtml += "Accessible by all authenticated users.";
} else {
- permhtml += 'Onyl accessible by user "' +
+ permhtml += 'Onyl accessible by user "' +
info.permissions.user + '"';
}
}
} else if (info.permissions.check) {
- permhtml += "<pre>Check: " +
+ permhtml += "<pre>Check: " +
Ext.htmlEncode(Ext.JSON.encode(info.permissions.check)) + "</pre>";
} else {
permhtml += "Unknown systax!";
}
}
+ if (!info.allowtoken) {
+ permhtml += "<br />This API endpoint is not available for API tokens."
+ }
sections.push({
title: 'Required permissions',
bodyPadding: 10,
html: permhtml
});
-
-
+
+
items.push({
title: method,
autoScroll: true,
ct.setActiveTab(0);
};
+ Ext.define('Ext.form.SearchField', {
+ extend: 'Ext.form.field.Text',
+ alias: 'widget.searchfield',
+
+ emptyText: 'Search...',
+
+ flex: 1,
+
+ inputType: 'search',
+ listeners: {
+ 'change': function(){
+
+ var value = this.getValue();
+ if (!Ext.isEmpty(value)) {
+ store.filter({
+ property: 'path',
+ value: value,
+ anyMatch: true
+ });
+ } else {
+ store.clearFilter();
+ }
+ }
+ }
+ });
+
var tree = Ext.create('Ext.tree.Panel', {
- title: 'Resource Tree',
+ title: 'Resource Tree',
+ tbar: [
+ {
+ xtype: 'searchfield',
+ }
+ ],
+ tools: [
+ {
+ type: 'expand',
+ tooltip: 'Expand all',
+ tooltipType: 'title',
+ callback: (tree) => tree.expandAll(),
+ },
+ {
+ type: 'collapse',
+ tooltip: 'Collapse all',
+ tooltipType: 'title',
+ callback: (tree) => tree.collapseAll(),
+ },
+ ],
store: store,
width: 200,
region: 'west',
return;
var rec = selections[0];
render_docu(rec.data);
+ location.hash = '#' + rec.data.path;
}
}
});
]
});
+ var deepLink = function() {
+ var path = window.location.hash.substring(1).replace(/\/\s*$/, '')
+ var endpoint = store.findNode('path', path);
+
+ if (endpoint) {
+ tree.getSelectionModel().select(endpoint);
+ tree.expandPath(endpoint.getPath());
+ render_docu(endpoint.data);
+ }
+ }
+ window.onhashchange = deepLink;
+
+ deepLink();
+
});
projects / pve-docs.git / blobdiff