[pve-manager.git] / www / manager6 / node / Certificates.js

Ext.define('PVE.node.CertificateView', {
    extend: 'Ext.container.Container',
    xtype: 'pveCertificatesView',

    onlineHelp: 'sysadmin_certificate_management',

    mixins: ['Proxmox.Mixin.CBind' ],

    items: [
	{
	    xtype: 'pveCertView',
	    border: 0,
	    cbind: {
		nodename: '{nodename}'
	    }
	},
	{
	    xtype: 'pveACMEView',
	    border: 0,
	    cbind: {
		nodename: '{nodename}'
	    }
	}
    ]

});

Ext.define('PVE.node.CertificateViewer', {
    extend: 'Proxmox.window.Edit',

    title: gettext('Certificate'),

    fieldDefaults: {
	labelWidth: 120
    },
    width: 800,
    resizable: true,

    items: [
	{
	    xtype: 'displayfield',
	    fieldLabel: gettext('Name'),
	    name: 'filename'
	},
	{
	    xtype: 'displayfield',
	    fieldLabel: gettext('Fingerprint'),
	    name: 'fingerprint'
	},
	{
	    xtype: 'displayfield',
	    fieldLabel: gettext('Issuer'),
	    name: 'issuer'
	},
	{
	    xtype: 'displayfield',
	    fieldLabel: gettext('Subject'),
	    name: 'subject'
	},
	{
	    xtype: 'displayfield',
	    fieldLabel: gettext('Public Key Type'),
	    name: 'public-key-type'
	},
	{
	    xtype: 'displayfield',
	    fieldLabel: gettext('Public Key Size'),
	    name: 'public-key-bits'
	},
	{
	    xtype: 'displayfield',
	    fieldLabel: gettext('Valid Since'),
	    renderer: Proxmox.Utils.render_timestamp,
	    name: 'notbefore'
	},
	{
	    xtype: 'displayfield',
	    fieldLabel: gettext('Expires'),
	    renderer: Proxmox.Utils.render_timestamp,
	    name: 'notafter'
	},
	{
	    xtype: 'displayfield',
	    fieldLabel: gettext('Subject Alternative Names'),
	    name: 'san',
	    renderer: PVE.Utils.render_san
	},
	{
	    xtype: 'textarea',
	    editable: false,
	    grow: true,
	    growMax: 200,
	    fieldLabel: gettext('Certificate'),
	    name: 'pem'
	}
    ],

    initComponent: function() {
	var me = this;

	if (!me.cert) {
	    throw "no cert given";
	}

	if (!me.nodename) {
	    throw "no nodename given";
	}

	me.url = '/nodes/' + me.nodename + '/certificates/info';
	me.callParent();

	// hide OK/Reset button, because we just want to show data
	me.down('toolbar[dock=bottom]').setVisible(false);

	me.load({
	    success: function(response) {
		if (Ext.isArray(response.result.data)) {
		    Ext.Array.each(response.result.data, function(item) {
			if (item.filename === me.cert) {
			    me.setValues(item);
			    return false;
			}
		    });
		}
	    }
	});
    }
});

Ext.define('PVE.node.CertUpload', {
    extend: 'Proxmox.window.Edit',
    xtype: 'pveCertUpload',

    title: gettext('Upload Custom Certificate'),
    resizable: false,
    isCreate: true,
    submitText: gettext('Upload'),
    method: 'POST',
    width: 600,

    apiCallDone: function(success, response, options) {
	if (!success) {
	    return;
	}

	var txt = gettext('pveproxy will be restarted with new certificates, please reload the GUI!');
	Ext.getBody().mask(txt, ['pve-static-mask']);
	// reload after 10 seconds automatically
	Ext.defer(function() {
	    window.location.reload(true);
	}, 10000);
    },

    items: [
	{
	    fieldLabel: gettext('Private Key (Optional)'),
	    labelAlign: 'top',
	    emptyText: gettext('No change'),
	    name: 'key',
	    xtype: 'textarea'
	},
	{
	    xtype: 'filebutton',
	    text: gettext('From File'),
	    listeners: {
		change: function(btn, e, value) {
		    var me = this.up('form');
		    e = e.event;
		    Ext.Array.each(e.target.files, function(file) {
			PVE.Utils.loadSSHKeyFromFile(file, function(res) {
			    me.down('field[name=key]').setValue(res);
			});
		    });
		    btn.reset();
		}
	    }
	},
	{
	    xtype: 'box',
	    autoEl: 'hr'
	},
	{
	    fieldLabel: gettext('Certificate Chain'),
	    labelAlign: 'top',
	    allowBlank: false,
	    name: 'certificates',
	    xtype: 'textarea'
	},
	{
	    xtype: 'filebutton',
	    text: gettext('From File'),
	    listeners: {
		change: function(btn, e, value) {
		    var me = this.up('form');
		    e = e.event;
		    Ext.Array.each(e.target.files, function(file) {
			PVE.Utils.loadSSHKeyFromFile(file, function(res) {
			    me.down('field[name=certificates]').setValue(res);
			});
		    });
		    btn.reset();
		}
	    }
	},
	{
	    xtype: 'hidden',
	    name: 'restart',
	    value: '1'
	},
	{
	    xtype: 'hidden',
	    name: 'force',
	    value: '1'
	}
    ],

    initComponent: function() {
	var me = this;

	if (!me.nodename) {
	    throw "no nodename given";
	}

	me.url = '/nodes/' + me.nodename + '/certificates/custom';

	me.callParent();
    }
});

Ext.define('pve-certificate', {
    extend: 'Ext.data.Model',

    fields: [ 'filename', 'fingerprint', 'issuer', 'notafter', 'notbefore', 'subject', 'san', 'public-key-bits', 'public-key-type' ],
    idProperty: 'filename'
});

Ext.define('PVE.node.Certificates', {
    extend: 'Ext.grid.Panel',
    xtype: 'pveCertView',

    tbar: [
	{
	    xtype: 'button',
	    text: gettext('Upload Custom Certificate'),
	    handler: function() {
		var me = this.up('grid');
		var win = Ext.create('PVE.node.CertUpload', {
		    nodename: me.nodename
		});
		win.show();
		win.on('destroy', me.reload, me);
	    }
	},
	{
	    xtype: 'button',
	    itemId: 'deletebtn',
	    text: gettext('Delete Custom Certificate'),
	    handler: function() {
		var me = this.up('grid');
		Proxmox.Utils.API2Request({
		    url: '/nodes/' + me.nodename + '/certificates/custom?restart=1',
		    method: 'DELETE',
		    success: function(response, opt) {
			var txt = gettext('pveproxy will be restarted with new certificates, please reload the GUI!');
			Ext.getBody().mask(txt, ['pve-static-mask']);
			// reload after 10 seconds automatically
			Ext.defer(function() {
			    window.location.reload(true);
			}, 10000);
		    },
		    failure: function(response, opt) {
			Ext.Msg.alert(gettext('Error'), response.htmlStatus);
		    }
		});
	    }
	},
	'-',
	{
	    xtype: 'proxmoxButton',
	    itemId: 'viewbtn',
	    disabled: true,
	    text: gettext('View Certificate'),
	    handler: function() {
		var me = this.up('grid');
		me.view_certificate();
	    }
	}
    ],

    columns: [
	{
	    header: gettext('File'),
	    width: 150,
	    dataIndex: 'filename'
	},
	{
	    header: gettext('Issuer'),
	    flex: 1,
	    dataIndex: 'issuer'
	},
	{
	    header: gettext('Subject'),
	    flex: 1,
	    dataIndex: 'subject'
	},
	{
	    header: gettext('Public Key Alogrithm'),
	    flex: 1,
	    dataIndex: 'public-key-type',
	    hidden: true
	},
	{
	    header: gettext('Public Key Size'),
	    flex: 1,
	    dataIndex: 'public-key-bits',
	    hidden: true
	},
	{
	    header: gettext('Valid Since'),
	    width: 150,
	    dataIndex: 'notbefore',
	    renderer: Proxmox.Utils.render_timestamp
	},
	{
	    header: gettext('Expires'),
	    width: 150,
	    dataIndex: 'notafter',
	    renderer: Proxmox.Utils.render_timestamp
	},
	{
	    header: gettext('Subject Alternative Names'),
	    flex: 1,
	    dataIndex: 'san',
	    renderer: PVE.Utils.render_san
	},
	{
	    header: gettext('Fingerprint'),
	    dataIndex: 'fingerprint',
	    hidden: true
	},
	{
	    header: gettext('PEM'),
	    dataIndex: 'pem',
	    hidden: true
	}
    ],

    reload: function() {
	var me = this;
	me.rstore.load();
    },

    set_button_status: function() {
	var me = this;
	var rec = me.rstore.getById('pveproxy-ssl.pem');

	me.down('#deletebtn').setDisabled(!rec);
    },

    view_certificate: function() {
	var me = this;
	var selection = me.getSelection();
	if (!selection || selection.length < 1) {
	    return;
	}
	var win = Ext.create('PVE.node.CertificateViewer', {
	    cert: selection[0].data.filename,
	    nodename : me.nodename
	});
	win.show();
    },

    listeners: {
	itemdblclick: 'view_certificate'
    },

    initComponent: function() {
	var me = this;

	if (!me.nodename) {
	    throw "no nodename given";
	}

	me.rstore = Ext.create('Proxmox.data.UpdateStore', {
	    storeid: 'certs-' + me.nodename,
	    model: 'pve-certificate',
	    proxy: {
		type: 'proxmox',
		    url: '/api2/json/nodes/' + me.nodename + '/certificates/info'
	    }
	});

	me.store = {
	    type: 'diff',
	    rstore: me.rstore
	};

	me.callParent();

	me.mon(me.rstore, 'load', me.set_button_status, me);
	me.rstore.startUpdate();
    }
});
Commit	Line	Data
c287e233 DC	1	Ext.define('PVE.node.CertificateView', {
	2	extend: 'Ext.container.Container',
	3	xtype: 'pveCertificatesView',
	4
16dedd0f DC	5	onlineHelp: 'sysadmin_certificate_management',
16dedd0f DC	6
c287e233 DC	7	mixins: ['Proxmox.Mixin.CBind' ],
	8
	9	items: [
	10	{
	11	xtype: 'pveCertView',
	12	border: 0,
	13	cbind: {
	14	nodename: '{nodename}'
	15	}
	16	},
	17	{
	18	xtype: 'pveACMEView',
	19	border: 0,
	20	cbind: {
	21	nodename: '{nodename}'
	22	}
	23	}
	24	]
	25
	26	});
	27
	28	Ext.define('PVE.node.CertificateViewer', {
	29	extend: 'Proxmox.window.Edit',
	30
	31	title: gettext('Certificate'),
	32
	33	fieldDefaults: {
	34	labelWidth: 120
	35	},
	36	width: 800,
	37	resizable: true,
	38
	39	items: [
	40	{
	41	xtype: 'displayfield',
	42	fieldLabel: gettext('Name'),
	43	name: 'filename'
	44	},
	45	{
	46	xtype: 'displayfield',
	47	fieldLabel: gettext('Fingerprint'),
	48	name: 'fingerprint'
	49	},
	50	{
	51	xtype: 'displayfield',
	52	fieldLabel: gettext('Issuer'),
	53	name: 'issuer'
	54	},
	55	{
	56	xtype: 'displayfield',
	57	fieldLabel: gettext('Subject'),
	58	name: 'subject'
	59	},
e81645f5 AA	60	{
	61	xtype: 'displayfield',
	62	fieldLabel: gettext('Public Key Type'),
	63	name: 'public-key-type'
	64	},
	65	{
	66	xtype: 'displayfield',
	67	fieldLabel: gettext('Public Key Size'),
	68	name: 'public-key-bits'
	69	},
c287e233 DC	70	{
	71	xtype: 'displayfield',
	72	fieldLabel: gettext('Valid Since'),
	73	renderer: Proxmox.Utils.render_timestamp,
	74	name: 'notbefore'
	75	},
	76	{
	77	xtype: 'displayfield',
	78	fieldLabel: gettext('Expires'),
	79	renderer: Proxmox.Utils.render_timestamp,
	80	name: 'notafter'
	81	},
	82	{
	83	xtype: 'displayfield',
	84	fieldLabel: gettext('Subject Alternative Names'),
	85	name: 'san',
	86	renderer: PVE.Utils.render_san
	87	},
	88	{
	89	xtype: 'textarea',
	90	editable: false,
	91	grow: true,
	92	growMax: 200,
	93	fieldLabel: gettext('Certificate'),
	94	name: 'pem'
	95	}
	96	],
	97
	98	initComponent: function() {
	99	var me = this;
	100
	101	if (!me.cert) {
	102	throw "no cert given";
	103	}
	104
	105	if (!me.nodename) {
	106	throw "no nodename given";
	107	}
	108
	109	me.url = '/nodes/' + me.nodename + '/certificates/info';
	110	me.callParent();
	111
	112	// hide OK/Reset button, because we just want to show data
	113	me.down('toolbar[dock=bottom]').setVisible(false);
	114
	115	me.load({
	116	success: function(response) {
	117	if (Ext.isArray(response.result.data)) {
	118	Ext.Array.each(response.result.data, function(item) {
	119	if (item.filename === me.cert) {
	120	me.setValues(item);
	121	return false;
	122	}
	123	});
	124	}
	125	}
	126	});
	127	}
	128	});
	129
	130	Ext.define('PVE.node.CertUpload', {
	131	extend: 'Proxmox.window.Edit',
	132	xtype: 'pveCertUpload',
	133
134	title: gettext('Upload Custom Certificate'),
135	resizable: false,
136	isCreate: true,
137	submitText: gettext('Upload'),
138	method: 'POST',
139	width: 600,
140
141	apiCallDone: function(success, response, options) {
142	if (!success) {
143	return;
144	}
145
146	var txt = gettext('pveproxy will be restarted with new certificates, please reload the GUI!');
147	Ext.getBody().mask(txt, ['pve-static-mask']);
148	// reload after 10 seconds automatically
149	Ext.defer(function() {
150	window.location.reload(true);
151	}, 10000);
152	},
153
154	items: [
155	{
156	fieldLabel: gettext('Private Key (Optional)'),
157	labelAlign: 'top',
158	emptyText: gettext('No change'),
159	name: 'key',
160	xtype: 'textarea'
161	},
162	{
163	xtype: 'filebutton',
164	text: gettext('From File'),
165	listeners: {
166	change: function(btn, e, value) {
167	var me = this.up('form');
168	e = e.event;
169	Ext.Array.each(e.target.files, function(file) {
170	PVE.Utils.loadSSHKeyFromFile(file, function(res) {
171	me.down('field[name=key]').setValue(res);
172	});
173	});
174	btn.reset();
175	}
176	}
177	},
178	{
179	xtype: 'box',
180	autoEl: 'hr'
181	},
182	{
183	fieldLabel: gettext('Certificate Chain'),
184	labelAlign: 'top',
185	allowBlank: false,
186	name: 'certificates',
187	xtype: 'textarea'
188	},
189	{
190	xtype: 'filebutton',
191	text: gettext('From File'),
192	listeners: {
193	change: function(btn, e, value) {
194	var me = this.up('form');
195	e = e.event;
196	Ext.Array.each(e.target.files, function(file) {
197	PVE.Utils.loadSSHKeyFromFile(file, function(res) {
198	me.down('field[name=certificates]').setValue(res);
199	});
200	});
201	btn.reset();
202	}
203	}
204	},
205	{
206	xtype: 'hidden',
207	name: 'restart',
208	value: '1'
209	},
210	{
211	xtype: 'hidden',
212	name: 'force',
213	value: '1'
214	}
215	],
216
217	initComponent: function() {
218	var me = this;
219
220	if (!me.nodename) {
221	throw "no nodename given";
222	}
223
224	me.url = '/nodes/' + me.nodename + '/certificates/custom';
225
226	me.callParent();
227	}
228	});
229
230	Ext.define('pve-certificate', {
231	extend: 'Ext.data.Model',
232
e81645f5	233	fields: [ 'filename', 'fingerprint', 'issuer', 'notafter', 'notbefore', 'subject', 'san', 'public-key-bits', 'public-key-type' ],
c287e233 DC	234	idProperty: 'filename'
	235	});
	236
	237	Ext.define('PVE.node.Certificates', {
	238	extend: 'Ext.grid.Panel',
	239	xtype: 'pveCertView',
	240
	241	tbar: [
	242	{
	243	xtype: 'button',
	244	text: gettext('Upload Custom Certificate'),
	245	handler: function() {
	246	var me = this.up('grid');
	247	var win = Ext.create('PVE.node.CertUpload', {
	248	nodename: me.nodename
	249	});
	250	win.show();
	251	win.on('destroy', me.reload, me);
	252	}
	253	},
	254	{
	255	xtype: 'button',
	256	itemId: 'deletebtn',
	257	text: gettext('Delete Custom Certificate'),
	258	handler: function() {
	259	var me = this.up('grid');
	260	Proxmox.Utils.API2Request({
	261	url: '/nodes/' + me.nodename + '/certificates/custom?restart=1',
	262	method: 'DELETE',
	263	success: function(response, opt) {
	264	var txt = gettext('pveproxy will be restarted with new certificates, please reload the GUI!');
	265	Ext.getBody().mask(txt, ['pve-static-mask']);
	266	// reload after 10 seconds automatically
	267	Ext.defer(function() {
	268	window.location.reload(true);
	269	}, 10000);
	270	},
	271	failure: function(response, opt) {
	272	Ext.Msg.alert(gettext('Error'), response.htmlStatus);
	273	}
	274	});
	275	}
	276	},
	277	'-',
	278	{
	279	xtype: 'proxmoxButton',
	280	itemId: 'viewbtn',
	281	disabled: true,
	282	text: gettext('View Certificate'),
	283	handler: function() {
	284	var me = this.up('grid');
	285	me.view_certificate();
	286	}
	287	}
	288	],
	289
	290	columns: [
	291	{
	292	header: gettext('File'),
	293	width: 150,
	294	dataIndex: 'filename'
	295	},
	296	{
	297	header: gettext('Issuer'),
298	flex: 1,
299	dataIndex: 'issuer'
300	},
301	{
302	header: gettext('Subject'),
303	flex: 1,
304	dataIndex: 'subject'
305	},
e81645f5 AA	306	{
	307	header: gettext('Public Key Alogrithm'),
	308	flex: 1,
	309	dataIndex: 'public-key-type',
	310	hidden: true
	311	},
	312	{
	313	header: gettext('Public Key Size'),
	314	flex: 1,
	315	dataIndex: 'public-key-bits',
	316	hidden: true
	317	},
c287e233 DC	318	{
	319	header: gettext('Valid Since'),
	320	width: 150,
	321	dataIndex: 'notbefore',
	322	renderer: Proxmox.Utils.render_timestamp
	323	},
	324	{
	325	header: gettext('Expires'),
	326	width: 150,
	327	dataIndex: 'notafter',
	328	renderer: Proxmox.Utils.render_timestamp
	329	},
	330	{
	331	header: gettext('Subject Alternative Names'),
	332	flex: 1,
	333	dataIndex: 'san',
	334	renderer: PVE.Utils.render_san
	335	},
	336	{
	337	header: gettext('Fingerprint'),
	338	dataIndex: 'fingerprint',
	339	hidden: true
	340	},
	341	{
	342	header: gettext('PEM'),
	343	dataIndex: 'pem',
	344	hidden: true
	345	}
	346	],
	347
	348	reload: function() {
	349	var me = this;
	350	me.rstore.load();
	351	},
	352
	353	set_button_status: function() {
	354	var me = this;
	355	var rec = me.rstore.getById('pveproxy-ssl.pem');
	356
	357	me.down('#deletebtn').setDisabled(!rec);
	358	},
	359
	360	view_certificate: function() {
	361	var me = this;
	362	var selection = me.getSelection();
	363	if (!selection \|\| selection.length < 1) {
	364	return;
	365	}
	366	var win = Ext.create('PVE.node.CertificateViewer', {
	367	cert: selection[0].data.filename,
	368	nodename : me.nodename
	369	});
	370	win.show();
	371	},
	372
	373	listeners: {
	374	itemdblclick: 'view_certificate'
	375	},
	376
	377	initComponent: function() {
	378	var me = this;
	379
	380	if (!me.nodename) {
	381	throw "no nodename given";
382	}
383
384	me.rstore = Ext.create('Proxmox.data.UpdateStore', {
385	storeid: 'certs-' + me.nodename,
386	model: 'pve-certificate',
387	proxy: {
388	type: 'proxmox',
389	url: '/api2/json/nodes/' + me.nodename + '/certificates/info'
390	}
391	});
392
393	me.store = {
394	type: 'diff',
395	rstore: me.rstore
396	};
397
398	me.callParent();
399
400	me.mon(me.rstore, 'load', me.set_button_status, me);
401	me.rstore.startUpdate();
402	}
403	});