[pve-manager.git] / www / manager6 / dc / RealmSyncJob.js

Ext.define('PVE.dc.RealmSyncJobView', {
    extend: 'Ext.grid.Panel',
    alias: 'widget.pveRealmSyncJobView',

    stateful: true,
    stateId: 'grid-realmsyncjobs',

    emptyText: Ext.String.format(gettext('No {0} configured'), gettext('Realm Sync Job')),

    controller: {
	xclass: 'Ext.app.ViewController',

	addRealmSyncJob: function(button) {
	    let me = this;
	    Ext.create(`PVE.dc.RealmSyncJobEdit`, {
		autoShow: true,
		listeners: {
		    destroy: () => me.reload(),
		},
	    });
	},

	editRealmSyncJob: function() {
	    let me = this;
	    let view = me.getView();
	    let selection = view.getSelection();
	    if (!selection || selection.length < 1) {
		return;
	    }

	    Ext.create(`PVE.dc.RealmSyncJobEdit`, {
		jobid: selection[0].data.id,
		autoShow: true,
		listeners: {
		    destroy: () => me.reload(),
		},
	    });
	},

	runNow: function() {
	    let me = this;
	    let view = me.getView();
	    let selection = view.getSelection();
	    if (!selection || selection.length < 1) {
		return;
	    }

	    let params = selection[0].data;
	    let realm = params.realm;

	    let propertiesToDelete = ['comment', 'realm', 'id', 'type', 'schedule', 'last-run', 'next-run', 'enabled'];
	    for (const prop of propertiesToDelete) {
		delete params[prop];
	    }

	    Proxmox.Utils.API2Request({
		url: `/access/domains/${realm}/sync`,
		params,
		waitMsgTarget: view,
		method: 'POST',
		failure: response => Ext.Msg.alert(gettext('Error'), response.htmlStatus),
		success: function(response, options) {
		    Ext.create('Proxmox.window.TaskProgress', {
			autoShow: true,
			upid: response.result.data,
			taskDone: () => { me.reload(); },
		    });
		},
	    });
	},

	reload: function() {
	    this.getView().getStore().load();
	},
    },

    store: {
	autoLoad: true,
	id: 'realm-syncs',
	proxy: {
	    type: 'proxmox',
	    url: '/api2/json/cluster/jobs/realm-sync',
	},
    },

    viewConfig: {
	getRowClass: (record, _index) => record.get('enabled') ? '' : 'proxmox-disabled-row',
    },

    columns: [
	{
	    header: gettext('Enabled'),
	    width: 80,
	    dataIndex: 'enabled',
	    sortable: true,
	    align: 'center',
	    stopSelection: false,
	    renderer: Proxmox.Utils.renderEnabledIcon,
	},
	{
	    text: gettext('Name'),
	    flex: 1,
	    dataIndex: 'id',
	    hidden: true,
	},
	{
	    text: gettext('Realm'),
	    width: 200,
	    dataIndex: 'realm',
	},
	{
	    header: gettext('Schedule'),
	    width: 150,
	    dataIndex: 'schedule',
	},
	{
	    text: gettext('Next Run'),
	    dataIndex: 'next-run',
	    width: 150,
	    renderer: PVE.Utils.render_next_event,
	},
	{
	    header: gettext('Comment'),
	    dataIndex: 'comment',
	    renderer: Ext.htmlEncode,
	    sorter: (a, b) => (a.data.comment || '').localeCompare(b.data.comment || ''),
	    flex: 1,
	},
    ],

    tbar: [
	{
	    text: gettext('Add'),
	    handler: 'addRealmSyncJob',
	},
	{
	    text: gettext('Edit'),
	    xtype: 'proxmoxButton',
	    handler: 'editRealmSyncJob',
	    disabled: true,
	},
	{
	    xtype: 'proxmoxStdRemoveButton',
	    baseurl: `/api2/extjs/cluster/jobs/realm-sync`,
	    callback: 'reload',
	},
	{
	    xtype: 'proxmoxButton',
	    handler: 'runNow',
	    disabled: true,
	    text: gettext('Run Now'),
	},
    ],

    listeners: {
	itemdblclick: 'editRealmSyncJob',
    },

    initComponent: function() {
	var me = this;

	me.callParent();

	Proxmox.Utils.monStoreErrors(me, me.getStore());
    },
});

Ext.define('PVE.dc.RealmSyncJobEdit', {
    extend: 'Proxmox.window.Edit',
    mixins: ['Proxmox.Mixin.CBind'],

    subject: gettext('Realm Sync Job'),
    onlineHelp: 'pveum_ldap_sync',

    // don't focus the schedule field on edit
    defaultFocus: 'field[name=id]',

    cbindData: function() {
	let me = this;
	me.isCreate = !me.jobid;
	me.jobid = me.jobid || "";
	let url = '/api2/extjs/cluster/jobs/realm-sync';
	me.url = me.jobid ? `${url}/${me.jobid}` : url;
	me.method = me.isCreate ? 'POST' : 'PUT';
	if (!me.isCreate) {
	    me.subject = `${me.subject}: ${me.jobid}`;
	}
	return {};
    },

    submitUrl: function(url, values) {
	return this.isCreate ? `${url}/${values.id}` : url;
    },

    controller: {
	xclass: 'Ext.app.ViewController',

	updateDefaults: function(_field, newValue) {
	    let me = this;

	    ['scope', 'enable-new', 'schedule'].forEach((reference) => {
		me.lookup(reference)?.setDisabled(false);
	    });

	    // only update on create
	    if (!me.getView().isCreate) {
		return;
	    }
	    Proxmox.Utils.API2Request({
		url: `/access/domains/${newValue}`,
		success: function(response) {
		    // first reset the fields to their default
		    ['acl', 'entry', 'properties'].forEach(opt => {
			me.lookup(`remove-vanished-${opt}`)?.setValue(false);
		    });
		    me.lookup('enable-new')?.setValue('1');
		    me.lookup('scope')?.setValue(undefined);

		    let options = response?.result?.data?.['sync-defaults-options'];
		    if (options) {
			let parsed = PVE.Parser.parsePropertyString(options);
			if (parsed['remove-vanished']) {
			    let opts = parsed['remove-vanished'].split(';');
			    for (const opt of opts) {
				me.lookup(`remove-vanished-${opt}`)?.setValue(true);
			    }
			    delete parsed['remove-vanished'];
			}
			for (const [name, value] of Object.entries(parsed)) {
			    me.lookup(name)?.setValue(value);
			}
		    }
		},
	    });
	},
    },

    items: [
	{
	    xtype: 'inputpanel',

	    cbind: {
		isCreate: '{isCreate}',
	    },

	    onGetValues: function(values) {
		let me = this;

		let vanished_opts = [];
		['acl', 'entry', 'properties'].forEach((prop) => {
		    if (values[`remove-vanished-${prop}`]) {
			vanished_opts.push(prop);
		    }
		    delete values[`remove-vanished-${prop}`];
		});

		if (!values.id && me.isCreate) {
		    values.id = 'realmsync-' + Ext.data.identifier.Uuid.Global.generate().slice(0, 13);
		}

		if (vanished_opts.length > 0) {
		    values['remove-vanished'] = vanished_opts.join(';');
		} else {
		    values['remove-vanished'] = 'none';
		}

		PVE.Utils.delete_if_default(values, 'node', '');

		if (me.isCreate) {
		    delete values.delete; // on create we cannot delete values
		}

		return values;
	    },

	    column1: [
		{
		    xtype: 'pmxDisplayEditField',
		    editConfig: {
			xtype: 'pmxRealmComboBox',
			storeFilter: rec => rec.data.type === 'ldap' || rec.data.type === 'ad',
		    },
		    listConfig: {
			emptyText: `<div class="x-grid-empty">${gettext('No LDAP/AD Realm found')}</div>`,
		    },
		    cbind: {
			editable: '{isCreate}',
		    },
		    listeners: {
			change: 'updateDefaults',
		    },
		    fieldLabel: gettext('Realm'),
		    name: 'realm',
		    reference: 'realm',
		},
		{
		    xtype: 'pveCalendarEvent',
		    fieldLabel: gettext('Schedule'),
		    disabled: true,
		    allowBlank: false,
		    name: 'schedule',
		    reference: 'schedule',
		},
		{
		    xtype: 'proxmoxcheckbox',
		    fieldLabel: gettext('Enable Job'),
		    name: 'enabled',
		    reference: 'enabled',
		    uncheckedValue: 0,
		    defaultValue: 1,
		    checked: true,
		},
	    ],

	    column2: [
		{
		    xtype: 'proxmoxKVComboBox',
		    name: 'scope',
		    reference: 'scope',
		    disabled: true,
		    fieldLabel: gettext('Scope'),
		    value: '',
		    emptyText: gettext('No default available'),
		    deleteEmpty: false,
		    allowBlank: false,
		    comboItems: [
			['users', gettext('Users')],
			['groups', gettext('Groups')],
			['both', gettext('Users and Groups')],
		    ],
		},
		{
		    xtype: 'proxmoxKVComboBox',
		    value: '1',
		    deleteEmpty: false,
		    disabled: true,
		    allowBlank: false,
		    comboItems: [
			['1', Proxmox.Utils.yesText],
			['0', Proxmox.Utils.noText],
		    ],
		    name: 'enable-new',
		    reference: 'enable-new',
		    fieldLabel: gettext('Enable New'),
		},
	    ],

	    columnB: [
		{
		    xtype: 'fieldset',
		    title: gettext('Remove Vanished Options'),
		    items: [
			{
			    xtype: 'proxmoxcheckbox',
			    fieldLabel: gettext('ACL'),
			    name: 'remove-vanished-acl',
			    reference: 'remove-vanished-acl',
			    boxLabel: gettext('Remove ACLs of vanished users and groups.'),
			},
			{
			    xtype: 'proxmoxcheckbox',
			    fieldLabel: gettext('Entry'),
			    name: 'remove-vanished-entry',
			    reference: 'remove-vanished-entry',
			    boxLabel: gettext('Remove vanished user and group entries.'),
			},
			{
			    xtype: 'proxmoxcheckbox',
			    fieldLabel: gettext('Properties'),
			    name: 'remove-vanished-properties',
			    reference: 'remove-vanished-properties',
			    boxLabel: gettext('Remove vanished properties from synced users.'),
			},
		    ],
		},
		{
		    xtype: 'proxmoxtextfield',
		    name: 'comment',
		    fieldLabel: gettext('Job Comment'),
		    cbind: {
			deleteEmpty: '{!isCreate}',
		    },
		    autoEl: {
			tag: 'div',
			'data-qtip': gettext('Description of the job'),
		    },
		},
		{
		    xtype: 'displayfield',
		    reference: 'defaulthint',
		    value: gettext('Default sync options can be set by editing the realm.'),
		    userCls: 'pmx-hint',
		    hidden: true,
		},
	    ],
	},
    ],

    initComponent: function() {
	let me = this;
	me.callParent();
	if (me.jobid) {
	    me.load({
		success: function(response, options) {
		    let values = response.result.data;

		    if (values['remove-vanished']) {
			let opts = values['remove-vanished'].split(';');
			for (const opt of opts) {
			    values[`remove-vanished-${opt}`] = 1;
			}
		    }
		    me.down('inputpanel').setValues(values);
		},
	    });
	}
    },
});
Commit	Line	Data
f44ce595 DC	1	Ext.define('PVE.dc.RealmSyncJobView', {
	2	extend: 'Ext.grid.Panel',
	3	alias: 'widget.pveRealmSyncJobView',
	4
	5	stateful: true,
	6	stateId: 'grid-realmsyncjobs',
	7
fc8f37ee TL	8	emptyText: Ext.String.format(gettext('No {0} configured'), gettext('Realm Sync Job')),
fc8f37ee TL	9
f44ce595 DC	10	controller: {
	11	xclass: 'Ext.app.ViewController',
	12
	13	addRealmSyncJob: function(button) {
	14	let me = this;
	15	Ext.create(`PVE.dc.RealmSyncJobEdit`, {
	16	autoShow: true,
	17	listeners: {
	18	destroy: () => me.reload(),
	19	},
	20	});
	21	},
	22
	23	editRealmSyncJob: function() {
	24	let me = this;
	25	let view = me.getView();
	26	let selection = view.getSelection();
	27	if (!selection \|\| selection.length < 1) {
	28	return;
	29	}
	30
	31	Ext.create(`PVE.dc.RealmSyncJobEdit`, {
	32	jobid: selection[0].data.id,
	33	autoShow: true,
	34	listeners: {
	35	destroy: () => me.reload(),
	36	},
	37	});
	38	},
	39
ed65c1ca DC	40	runNow: function() {
	41	let me = this;
	42	let view = me.getView();
	43	let selection = view.getSelection();
	44	if (!selection \|\| selection.length < 1) {
	45	return;
	46	}
	47
	48	let params = selection[0].data;
	49	let realm = params.realm;
	50
	51	let propertiesToDelete = ['comment', 'realm', 'id', 'type', 'schedule', 'last-run', 'next-run', 'enabled'];
	52	for (const prop of propertiesToDelete) {
	53	delete params[prop];
	54	}
	55
	56	Proxmox.Utils.API2Request({
	57	url: `/access/domains/${realm}/sync`,
	58	params,
	59	waitMsgTarget: view,
	60	method: 'POST',
1e7c70f5	61	failure: response => Ext.Msg.alert(gettext('Error'), response.htmlStatus),
ed65c1ca	62	success: function(response, options) {
1e7c70f5 TL	63	Ext.create('Proxmox.window.TaskProgress', {
	64	autoShow: true,
	65	upid: response.result.data,
ed65c1ca DC	66	taskDone: () => { me.reload(); },
ed65c1ca DC	67	});
ed65c1ca DC	68	},
	69	});
	70	},
	71
f44ce595 DC	72	reload: function() {
	73	this.getView().getStore().load();
	74	},
	75	},
	76
	77	store: {
	78	autoLoad: true,
	79	id: 'realm-syncs',
	80	proxy: {
	81	type: 'proxmox',
	82	url: '/api2/json/cluster/jobs/realm-sync',
	83	},
	84	},
	85
059abb7a DC	86	viewConfig: {
	87	getRowClass: (record, _index) => record.get('enabled') ? '' : 'proxmox-disabled-row',
	88	},
	89
f44ce595 DC	90	columns: [
	91	{
	92	header: gettext('Enabled'),
	93	width: 80,
	94	dataIndex: 'enabled',
f44ce595	95	sortable: true,
059abb7a	96	align: 'center',
f44ce595	97	stopSelection: false,
059abb7a	98	renderer: Proxmox.Utils.renderEnabledIcon,
f44ce595 DC	99	},
	100	{
	101	text: gettext('Name'),
	102	flex: 1,
	103	dataIndex: 'id',
	104	hidden: true,
	105	},
	106	{
	107	text: gettext('Realm'),
	108	width: 200,
	109	dataIndex: 'realm',
	110	},
	111	{
	112	header: gettext('Schedule'),
	113	width: 150,
	114	dataIndex: 'schedule',
	115	},
	116	{
	117	text: gettext('Next Run'),
	118	dataIndex: 'next-run',
	119	width: 150,
	120	renderer: PVE.Utils.render_next_event,
	121	},
	122	{
	123	header: gettext('Comment'),
	124	dataIndex: 'comment',
	125	renderer: Ext.htmlEncode,
	126	sorter: (a, b) => (a.data.comment \|\| '').localeCompare(b.data.comment \|\| ''),
	127	flex: 1,
	128	},
	129	],
	130
	131	tbar: [
	132	{
	133	text: gettext('Add'),
	134	handler: 'addRealmSyncJob',
	135	},
	136	{
	137	text: gettext('Edit'),
	138	xtype: 'proxmoxButton',
	139	handler: 'editRealmSyncJob',
	140	disabled: true,
	141	},
	142	{
	143	xtype: 'proxmoxStdRemoveButton',
	144	baseurl: `/api2/extjs/cluster/jobs/realm-sync`,
	145	callback: 'reload',
	146	},
ed65c1ca DC	147	{
	148	xtype: 'proxmoxButton',
	149	handler: 'runNow',
	150	disabled: true,
	151	text: gettext('Run Now'),
	152	},
f44ce595 DC	153	],
	154
	155	listeners: {
	156	itemdblclick: 'editRealmSyncJob',
	157	},
	158
	159	initComponent: function() {
	160	var me = this;
	161
	162	me.callParent();
	163
	164	Proxmox.Utils.monStoreErrors(me, me.getStore());
	165	},
	166	});
	167
	168	Ext.define('PVE.dc.RealmSyncJobEdit', {
	169	extend: 'Proxmox.window.Edit',
	170	mixins: ['Proxmox.Mixin.CBind'],
	171
	172	subject: gettext('Realm Sync Job'),
	173	onlineHelp: 'pveum_ldap_sync',
	174
	175	// don't focus the schedule field on edit
	176	defaultFocus: 'field[name=id]',
	177
	178	cbindData: function() {
	179	let me = this;
	180	me.isCreate = !me.jobid;
	181	me.jobid = me.jobid \|\| "";
	182	let url = '/api2/extjs/cluster/jobs/realm-sync';
	183	me.url = me.jobid ? `${url}/${me.jobid}` : url;
	184	me.method = me.isCreate ? 'POST' : 'PUT';
	185	if (!me.isCreate) {
	186	me.subject = `${me.subject}: ${me.jobid}`;
	187	}
	188	return {};
	189	},
	190
	191	submitUrl: function(url, values) {
	192	return this.isCreate ? `${url}/${values.id}` : url;
	193	},
	194
	195	controller: {
	196	xclass: 'Ext.app.ViewController',
	197
	198	updateDefaults: function(_field, newValue) {
	199	let me = this;
99e276c3 DC	200
	201	['scope', 'enable-new', 'schedule'].forEach((reference) => {
	202	me.lookup(reference)?.setDisabled(false);
	203	});
	204
f44ce595 DC	205	// only update on create
	206	if (!me.getView().isCreate) {
	207	return;
	208	}
	209	Proxmox.Utils.API2Request({
	210	url: `/access/domains/${newValue}`,
	211	success: function(response) {
	212	// first reset the fields to their default
	213	['acl', 'entry', 'properties'].forEach(opt => {
	214	me.lookup(`remove-vanished-${opt}`)?.setValue(false);
	215	});
	216	me.lookup('enable-new')?.setValue('1');
	217	me.lookup('scope')?.setValue(undefined);
	218
	219	let options = response?.result?.data?.['sync-defaults-options'];
	220	if (options) {
	221	let parsed = PVE.Parser.parsePropertyString(options);
	222	if (parsed['remove-vanished']) {
	223	let opts = parsed['remove-vanished'].split(';');
	224	for (const opt of opts) {
	225	me.lookup(`remove-vanished-${opt}`)?.setValue(true);
	226	}
	227	delete parsed['remove-vanished'];
	228	}
	229	for (const [name, value] of Object.entries(parsed)) {
	230	me.lookup(name)?.setValue(value);
	231	}
	232	}
	233	},
	234	});
	235	},
	236	},
	237
	238	items: [
	239	{
	240	xtype: 'inputpanel',
	241
	242	cbind: {
	243	isCreate: '{isCreate}',
	244	},
	245
	246	onGetValues: function(values) {
	247	let me = this;
	248
	249	let vanished_opts = [];
	250	['acl', 'entry', 'properties'].forEach((prop) => {
	251	if (values[`remove-vanished-${prop}`]) {
	252	vanished_opts.push(prop);
	253	}
	254	delete values[`remove-vanished-${prop}`];
	255	});
	256
	257	if (!values.id && me.isCreate) {
	258	values.id = 'realmsync-' + Ext.data.identifier.Uuid.Global.generate().slice(0, 13);
	259	}
	260
	261	if (vanished_opts.length > 0) {
	262	values['remove-vanished'] = vanished_opts.join(';');
	263	} else {
	264	values['remove-vanished'] = 'none';
	265	}
	266
	267	PVE.Utils.delete_if_default(values, 'node', '');
	268
269	if (me.isCreate) {
270	delete values.delete; // on create we cannot delete values
271	}
272
273	return values;
274	},
275
276	column1: [
277	{
278	xtype: 'pmxDisplayEditField',
279	editConfig: {
280	xtype: 'pmxRealmComboBox',
281	storeFilter: rec => rec.data.type === 'ldap' \|\| rec.data.type === 'ad',
282	},
99e276c3 DC	283	listConfig: {
	284	emptyText: `<div class="x-grid-empty">${gettext('No LDAP/AD Realm found')}</div>`,
	285	},
f44ce595 DC	286	cbind: {
	287	editable: '{isCreate}',
	288	},
	289	listeners: {
	290	change: 'updateDefaults',
	291	},
	292	fieldLabel: gettext('Realm'),
	293	name: 'realm',
	294	reference: 'realm',
	295	},
	296	{
	297	xtype: 'pveCalendarEvent',
	298	fieldLabel: gettext('Schedule'),
99e276c3	299	disabled: true,
f44ce595 DC	300	allowBlank: false,
	301	name: 'schedule',
	302	reference: 'schedule',
	303	},
	304	{
	305	xtype: 'proxmoxcheckbox',
fc3fe9af	306	fieldLabel: gettext('Enable Job'),
f44ce595 DC	307	name: 'enabled',
	308	reference: 'enabled',
	309	uncheckedValue: 0,
	310	defaultValue: 1,
	311	checked: true,
	312	},
	313	],
	314
	315	column2: [
	316	{
	317	xtype: 'proxmoxKVComboBox',
	318	name: 'scope',
	319	reference: 'scope',
99e276c3	320	disabled: true,
f44ce595 DC	321	fieldLabel: gettext('Scope'),
	322	value: '',
	323	emptyText: gettext('No default available'),
	324	deleteEmpty: false,
	325	allowBlank: false,
	326	comboItems: [
	327	['users', gettext('Users')],
	328	['groups', gettext('Groups')],
	329	['both', gettext('Users and Groups')],
	330	],
	331	},
	332	{
	333	xtype: 'proxmoxKVComboBox',
	334	value: '1',
	335	deleteEmpty: false,
99e276c3	336	disabled: true,
f44ce595 DC	337	allowBlank: false,
	338	comboItems: [
	339	['1', Proxmox.Utils.yesText],
	340	['0', Proxmox.Utils.noText],
	341	],
	342	name: 'enable-new',
	343	reference: 'enable-new',
fc3fe9af	344	fieldLabel: gettext('Enable New'),
f44ce595 DC	345	},
	346	],
	347
	348	columnB: [
	349	{
	350	xtype: 'fieldset',
	351	title: gettext('Remove Vanished Options'),
	352	items: [
	353	{
	354	xtype: 'proxmoxcheckbox',
	355	fieldLabel: gettext('ACL'),
	356	name: 'remove-vanished-acl',
	357	reference: 'remove-vanished-acl',
	358	boxLabel: gettext('Remove ACLs of vanished users and groups.'),
	359	},
	360	{
	361	xtype: 'proxmoxcheckbox',
	362	fieldLabel: gettext('Entry'),
	363	name: 'remove-vanished-entry',
	364	reference: 'remove-vanished-entry',
	365	boxLabel: gettext('Remove vanished user and group entries.'),
	366	},
	367	{
	368	xtype: 'proxmoxcheckbox',
	369	fieldLabel: gettext('Properties'),
	370	name: 'remove-vanished-properties',
	371	reference: 'remove-vanished-properties',
	372	boxLabel: gettext('Remove vanished properties from synced users.'),
	373	},
	374	],
	375	},
	376	{
	377	xtype: 'proxmoxtextfield',
	378	name: 'comment',
	379	fieldLabel: gettext('Job Comment'),
	380	cbind: {
	381	deleteEmpty: '{!isCreate}',
	382	},
	383	autoEl: {
	384	tag: 'div',
	385	'data-qtip': gettext('Description of the job'),
	386	},
	387	},
	388	{
	389	xtype: 'displayfield',
	390	reference: 'defaulthint',
	391	value: gettext('Default sync options can be set by editing the realm.'),
	392	userCls: 'pmx-hint',
	393	hidden: true,
	394	},
	395	],
	396	},
	397	],
	398
	399	initComponent: function() {
	400	let me = this;
	401	me.callParent();
	402	if (me.jobid) {
	403	me.load({
	404	success: function(response, options) {
	405	let values = response.result.data;
	406
	407	if (values['remove-vanished']) {
	408	let opts = values['remove-vanished'].split(';');
409	for (const opt of opts) {
410	values[`remove-vanished-${opt}`] = 1;
411	}
412	}
413	me.down('inputpanel').setValues(values);
414	},
415	});
416	}
417	},
418	});