js/LDAPConfig.js

   1 Ext.define('pmg-ldap-config', {
   2     extend: 'Ext.data.Model',
   3     fields: [ 'profile', 'server1', 'server2', 'comment',
   4               'mode', 'binddn', 'bindpw', 'basedn', 'groupbasedn',
   5               'filter', 'accountattr', 'mailattr',
   6               { name: 'port',  type: 'integer' },
   7               { name: 'gcount',  type: 'integer' },
   8               { name: 'mcount',  type: 'integer' },
   9               { name: 'ucount',  type: 'integer' },
  10               { name: 'disable',  type: 'boolean' }
  11             ],
  12     proxy: {
  13         type: 'proxmox',
  14         url: "/api2/json/config/ldap"
  15     },
  16     idProperty: 'profile'
  17 });
  18
  19 Ext.define('PMG.LDAPInputPanel', {
  20     extend: 'Proxmox.panel.InputPanel',
  21     alias: 'widget.pmgLDAPInputPanel',
  22
  23     profileId: undefined,
  24
  25     onGetValues: function(values) {
  26         var me = this;
  27
  28         values.disable = values.enable ? 0 : 1;
  29         delete values.enable;
  30
  31         return values;
  32     },
  33
  34     initComponent : function() {
  35         var me = this;
  36
  37         me.column1 = [
  38             {
  39                 xtype: me.profileId ? 'displayfield' : 'textfield',
  40                 fieldLabel: gettext('Profile Name'),
  41                 value: me.profileId || '',
  42                 name: 'profile',
  43                 vtype: 'StorageId',
  44                 allowBlank: false
  45             },
  46             {
  47                 xtype: 'proxmoxKVComboBox',
  48                 name: 'mode',
  49                 comboItems: [
  50                     ['ldap', PMG.Utils.format_ldap_protocol('ldap')],
  51                     ['ldaps', PMG.Utils.format_ldap_protocol('ldaps')]
  52                 ],
  53                 value: 'ldap',
  54                 fieldLabel: gettext('Protocol')
  55             },
  56             {
  57                 xtype: 'textfield',
  58                 fieldLabel: gettext('Server'),
  59                 allowBlank: false,
  60                 vtype: 'IP64Address',
  61                 name: 'server1'
  62             },
  63             {
  64                 xtype: 'proxmoxtextfield',
  65                 fieldLabel: gettext('Server'),
  66                 allowBlank: true,
  67                 deleteEmpty: me.create ? false : true,
  68                 vtype: 'IP64Address',
  69                 name: 'server2'
  70             },
  71             {
  72                 xtype: 'proxmoxintegerfield',
  73                 name: 'port',
  74                 emptyText: gettext('Default'),
  75                 deleteEmpty: me.create ? false : true,
  76                 minValue: 1,
  77                 maxValue: 65535,
  78                 fieldLabel: gettext('Port'),
  79             },
  80             {
  81                 xtype: 'textfield',
  82                 name: 'binddn',
  83                 allowBlank: true,
  84                 fieldLabel: gettext('User name')
  85             },
  86             {
  87                 xtype: 'textfield',
  88                 inputType: 'password',
  89                 allowBlank: true,
  90                 name: 'bindpw',
  91                 fieldLabel: gettext('Password')
  92             }
  93         ];
  94
  95         me.column2 = [
  96             {
  97                 xtype: 'proxmoxcheckbox',
  98                 name: 'enable',
  99                 checked: true,
 100                 uncheckedValue: 0,
 101                 fieldLabel: gettext('Enable')
 102             },
 103             {
 104                 xtype: 'proxmoxtextfield',
 105                 allowBlank: true,
 106                 deleteEmpty: me.create ? false : true,
 107                 name: 'basedn',
 108                 fieldLabel: gettext('Base DN')
 109             },
 110             {
 111                 xtype: 'proxmoxtextfield',
 112                 allowBlank: true,
 113                 deleteEmpty: me.create ? false : true,
 114                 name: 'groupbasedn',
 115                 fieldLabel: gettext('Base DN for Groups')
 116             },
 117             {
 118                 xtype: 'proxmoxtextfield',
 119                 allowBlank: true,
 120                 deleteEmpty: me.create ? false : true,
 121                 name: 'mailattr',
 122                 fieldLabel: gettext('EMail attribute name(s)')
 123             },
 124             {
 125                 xtype: 'proxmoxtextfield',
 126                 allowBlank: true,
 127                 deleteEmpty: me.create ? false : true,
 128                 name: 'accountattr',
 129                 fieldLabel: gettext('Account attribute name')
 130             },
 131             {
 132                 xtype: 'proxmoxtextfield',
 133                 allowBlank: true,
 134                 deleteEmpty: me.create ? false : true,
 135                 name: 'filter',
 136                 fieldLabel: gettext('LDAP filter')
 137             }
 138         ];
 139
 140         me.columnB = [
 141             {
 142                 xtype: 'textfield',
 143                 fieldLabel: gettext('Comment'),
 144                 allowBlank: true,
 145                 name: 'comment'
 146             }
 147         ];
 148
 149         me.callParent();
 150     }
 151 });
 152
 153 Ext.define('PMG.LDAPEdit', {
 154     extend: 'Proxmox.window.Edit',
 155     alias: 'widget.pmgLDAPEdit',
 156
 157     subject: 'LDAP Profile',
 158     isAdd: true,
 159
 160     initComponent : function() {
 161         var me = this;
 162
 163         me.create = me.profileId ? false : true;
 164
 165         if (me.create) {
 166             me.url = '/api2/extjs/config/ldap';
 167             me.method = 'POST';
 168         } else {
 169             me.url = '/api2/extjs/config/ldap/' + me.profileId + '/config';
 170             me.method = 'PUT';
 171         }
 172
 173         var ipanel = Ext.create('PMG.LDAPInputPanel', {
 174             create: me.create,
 175             profileId: me.profileId
 176         });
 177
 178         me.items = [ ipanel ];
 179
 180         me.fieldDefaults = {
 181             labelWidth: 150
 182         };
 183
 184         me.callParent();
 185
 186         if (!me.create) {
 187             me.load({
 188                 success:  function(response, options) {
 189                     var values = response.result.data;
 190
 191                     values.enable = values.disable ? 0 : 1;
 192                     ipanel.setValues(values);
 193                 }
 194             });
 195         }
 196     }
 197 });
 198
 199 Ext.define('PMG.LDAPConfig', {
 200     extend: 'Ext.grid.GridPanel',
 201     alias: ['widget.pmgLDAPConfig'],
 202
 203     initComponent : function() {
 204         var me = this;
 205
 206         me.store = new Ext.data.Store({
 207             model: 'pmg-ldap-config',
 208             sorters: {
 209                 property: 'profile',
 210                 order: 'DESC'
 211             }
 212         });
 213
 214         var reload = function() {
 215             me.store.load();
 216         };
 217
 218         me.selModel = Ext.create('Ext.selection.RowModel', {});
 219
 220         var remove_btn =  Ext.createWidget('proxmoxStdRemoveButton', {
 221             selModel: me.selModel,
 222             baseurl: '/config/ldap',
 223             callback: reload,
 224             waitMsgTarget: me
 225         });
 226
 227         var sync_btn =  Ext.createWidget('proxmoxButton', {
 228             text: gettext('Synchronize'),
 229             selModel: me.selModel,
 230             enableFn: function(rec) {
 231                 return !rec.data.disable;
 232             },
 233             disabled: true,
 234             handler: function(btn, event, rec) {
 235                 Proxmox.Utils.API2Request({
 236                     url: '/config/ldap/' + rec.data.profile + '/sync',
 237                     method: 'POST',
 238                     waitMsgTarget: me,
 239                     callback: reload,
 240                     failure: function (response, opts) {
 241                         Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 242                     }
 243                 });
 244             }
 245         });
 246
 247         var run_editor = function() {
 248             var rec = me.selModel.getSelection()[0];
 249             if (!rec) {
 250                 return;
 251             }
 252
 253             var win = Ext.createWidget('pmgLDAPEdit', {
 254                 profileId: rec.data.profile
 255             });
 256             win.load();
 257             win.on('destroy', reload);
 258             win.show();
 259         };
 260
 261         me.tbar = [
 262             {
 263                 xtype: 'proxmoxButton',
 264                 text: gettext('Edit'),
 265                 disabled: true,
 266                 selModel: me.selModel,
 267                 handler: run_editor
 268             },
 269             {
 270                 text: gettext('Create'),
 271                 handler: function() {
 272                     var win = Ext.createWidget('pmgLDAPEdit', {});
 273                     win.on('destroy', reload);
 274                     win.show();
 275                 }
 276             },
 277             remove_btn, sync_btn
 278         ];
 279
 280         Proxmox.Utils.monStoreErrors(me, me.store);
 281
 282         Ext.apply(me, {
 283
 284             columns: [
 285                 {
 286                     header: gettext('Profile Name'),
 287                     sortable: true,
 288                     width: 120,
 289                     dataIndex: 'profile'
 290                 },
 291                 {
 292                     header: gettext('Protocol'),
 293                     sortable: true,
 294                     dataIndex: 'mode',
 295                     renderer: PMG.Utils.format_ldap_protocol
 296                 },
 297                 {
 298                     header: gettext('Server'),
 299                     sortable: true,
 300                     dataIndex: 'server1',
 301                     renderer: function(value, metaData, rec) {
 302                         if (rec.data.server2) {
 303                             return value + '<br>' + rec.data.server2;
 304                         }
 305                         return value;
 306                     }
 307                 },
 308                 {
 309                     header: gettext('Enabled'),
 310                     width: 80,
 311                     sortable: true,
 312                     dataIndex: 'disable',
 313                     renderer: Proxmox.Utils.format_neg_boolean
 314                 },
 315                 {
 316                     header: gettext('Comment'),
 317                     sortable: false,
 318                     renderer: Ext.String.htmlEncode,
 319                     dataIndex: 'comment',
 320                     flex: 1
 321                 },
 322                 {
 323                     header: gettext('Accounts'),
 324                     width: 80,
 325                     sortable: true,
 326                     dataIndex: 'ucount'
 327                 },
 328                 {
 329                     header: gettext('Addresses'),
 330                     width: 80,
 331                     sortable: true,
 332                     dataIndex: 'mcount'
 333                 },
 334                 {
 335                     header: gettext('Groups'),
 336                     width: 80,
 337                     sortable: true,
 338                     dataIndex: 'gcount'
 339                 },
 340             ],
 341             listeners: {
 342                 itemdblclick: run_editor,
 343                 activate: reload
 344             }
 345         });
 346
 347         me.callParent();
 348     }
 349 });