js/LDAPConfig.js

   1 /*global Proxmox*/
   2 /*jslint confusion: true*/
   3 /* reload is function and string,
   4  * height is number and string,
   5  * hidden is bool and string,
   6  * bind is function and object,
   7  * callback is function and string
   8  */
   9 Ext.define('pmg-ldap-config', {
  10     extend: 'Ext.data.Model',
  11     fields: [ 'profile', 'server1', 'server2', 'comment',
  12               'mode', 'binddn', 'bindpw', 'basedn', 'groupbasedn',
  13               'filter', 'accountattr', 'mailattr',
  14               { name: 'port',  type: 'integer' },
  15               { name: 'gcount',  type: 'integer' },
  16               { name: 'mcount',  type: 'integer' },
  17               { name: 'ucount',  type: 'integer' },
  18               { name: 'disable',  type: 'boolean' }
  19             ],
  20     proxy: {
  21         type: 'proxmox',
  22         url: "/api2/json/config/ldap"
  23     },
  24     idProperty: 'profile'
  25 });
  26
  27 Ext.define('PMG.LDAPInputPanel', {
  28     extend: 'Proxmox.panel.InputPanel',
  29     alias: 'widget.pmgLDAPInputPanel',
  30
  31     profileId: undefined,
  32
  33     onGetValues: function(values) {
  34         var me = this;
  35
  36         values.disable = values.enable ? 0 : 1;
  37         delete values.enable;
  38
  39         return values;
  40     },
  41
  42     initComponent : function() {
  43         var me = this;
  44
  45         me.column1 = [
  46             {
  47                 xtype: me.profileId ? 'displayfield' : 'textfield',
  48                 fieldLabel: gettext('Profile Name'),
  49                 value: me.profileId || '',
  50                 name: 'profile',
  51                 vtype: 'StorageId',
  52                 allowBlank: false
  53             },
  54             {
  55                 xtype: 'proxmoxKVComboBox',
  56                 name: 'mode',
  57                 comboItems: [
  58                     ['ldap', PMG.Utils.format_ldap_protocol('ldap')],
  59                     ['ldaps', PMG.Utils.format_ldap_protocol('ldaps')]
  60                 ],
  61                 value: 'ldap',
  62                 fieldLabel: gettext('Protocol')
  63             },
  64             {
  65                 xtype: 'textfield',
  66                 fieldLabel: gettext('Server'),
  67                 allowBlank: false,
  68                 vtype: 'IP64Address',
  69                 name: 'server1'
  70             },
  71             {
  72                 xtype: 'proxmoxtextfield',
  73                 fieldLabel: gettext('Server'),
  74                 allowBlank: true,
  75                 deleteEmpty: me.isCreate ? false : true,
  76                 vtype: 'IP64Address',
  77                 name: 'server2'
  78             },
  79             {
  80                 xtype: 'proxmoxintegerfield',
  81                 name: 'port',
  82                 emptyText: gettext('Default'),
  83                 deleteEmpty: me.isCreate ? false : true,
  84                 minValue: 1,
  85                 maxValue: 65535,
  86                 fieldLabel: gettext('Port')
  87             },
  88             {
  89                 xtype: 'textfield',
  90                 name: 'binddn',
  91                 allowBlank: true,
  92                 fieldLabel: gettext('User name')
  93             },
  94             {
  95                 xtype: 'textfield',
  96                 inputType: 'password',
  97                 allowBlank: true,
  98                 name: 'bindpw',
  99                 fieldLabel: gettext('Password')
 100             }
 101         ];
 102
 103         me.column2 = [
 104             {
 105                 xtype: 'proxmoxcheckbox',
 106                 name: 'enable',
 107                 checked: true,
 108                 uncheckedValue: 0,
 109                 fieldLabel: gettext('Enable')
 110             },
 111             {
 112                 xtype: 'proxmoxtextfield',
 113                 allowBlank: true,
 114                 deleteEmpty: me.isCreate ? false : true,
 115                 name: 'basedn',
 116                 fieldLabel: gettext('Base DN')
 117             },
 118             {
 119                 xtype: 'proxmoxtextfield',
 120                 allowBlank: true,
 121                 deleteEmpty: me.isCreate ? false : true,
 122                 name: 'groupbasedn',
 123                 fieldLabel: gettext('Base DN for Groups')
 124             },
 125             {
 126                 xtype: 'proxmoxtextfield',
 127                 allowBlank: true,
 128                 deleteEmpty: me.isCreate ? false : true,
 129                 name: 'mailattr',
 130                 fieldLabel: gettext('EMail attribute name(s)')
 131             },
 132             {
 133                 xtype: 'proxmoxtextfield',
 134                 allowBlank: true,
 135                 deleteEmpty: me.isCreate ? false : true,
 136                 name: 'accountattr',
 137                 fieldLabel: gettext('Account attribute name')
 138             },
 139             {
 140                 xtype: 'proxmoxtextfield',
 141                 allowBlank: true,
 142                 deleteEmpty: me.isCreate ? false : true,
 143                 name: 'filter',
 144                 fieldLabel: gettext('LDAP filter')
 145             },
 146             {
 147                 xtype: 'proxmoxtextfield',
 148                 allowBlank: true,
 149                 deleteEmpty: me.isCreate ? false : true,
 150                 name: 'groupclass',
 151                 fieldLabel: gettext('Group objectclass')
 152             }
 153         ];
 154
 155         me.columnB = [
 156             {
 157                 xtype: 'textfield',
 158                 fieldLabel: gettext('Comment'),
 159                 allowBlank: true,
 160                 name: 'comment'
 161             }
 162         ];
 163
 164         me.callParent();
 165     }
 166 });
 167
 168 Ext.define('PMG.LDAPEdit', {
 169     extend: 'Proxmox.window.Edit',
 170     alias: 'widget.pmgLDAPEdit',
 171     onlineHelp: 'pmgconfig_ldap',
 172
 173     subject: 'LDAP Profile',
 174     isAdd: true,
 175
 176     initComponent : function() {
 177         var me = this;
 178
 179         me.isCreate = me.profileId ? false : true;
 180
 181         if (me.isCreate) {
 182             me.url = '/api2/extjs/config/ldap';
 183             me.method = 'POST';
 184         } else {
 185             me.url = '/api2/extjs/config/ldap/' + me.profileId + '/config';
 186             me.method = 'PUT';
 187         }
 188
 189         var ipanel = Ext.create('PMG.LDAPInputPanel', {
 190             isCreate: me.isCreate,
 191             profileId: me.profileId
 192         });
 193
 194         me.items = [ ipanel ];
 195
 196         me.fieldDefaults = {
 197             labelWidth: 150
 198         };
 199
 200         me.callParent();
 201
 202         if (!me.isCreate) {
 203             me.load({
 204                 success:  function(response, options) {
 205                     var values = response.result.data;
 206
 207                     values.enable = values.disable ? 0 : 1;
 208                     ipanel.setValues(values);
 209                 }
 210             });
 211         }
 212     }
 213 });
 214
 215 Ext.define('PMG.LDAPUserGrid', {
 216     extend: 'Ext.grid.Panel',
 217     xtype: 'pmgLDAPUserGrid',
 218
 219     emptyText: gettext('No data in database'),
 220     store: {
 221         autoDestroy: true,
 222         fields: [ 'dn', 'account', 'pmail' ],
 223         proxy: { type: 'proxmox' },
 224         sorters: [ 'dn' ]
 225     },
 226     columns: [
 227         {
 228             text: 'DN',
 229             dataIndex: 'dn',
 230             flex: 1
 231         },
 232         {
 233             text: gettext('Account'),
 234             dataIndex: 'account',
 235             flex: 1
 236         },
 237         {
 238             text: gettext('Primary E-Mail'),
 239             dataIndex: 'pmail',
 240             flex: 1
 241         }
 242     ],
 243
 244     initComponent: function() {
 245         var me = this;
 246         me.callParent();
 247         if (me.url) {
 248             me.getStore().getProxy().setUrl(me.url);
 249             me.getStore().load();
 250         }
 251     }
 252 });
 253
 254 Ext.define('PMG.LDAPConfig', {
 255     extend: 'Ext.panel.Panel',
 256     xtype: 'pmgLDAPConfig',
 257
 258     controller: {
 259         xclass: 'Ext.app.ViewController',
 260
 261         openUserList: function(grid, record) {
 262             var name = this.getViewModel().get('name');
 263             Ext.create('Ext.window.Window', {
 264                 title: Ext.String.format(gettext("Users of '{0}'"), record.data.dn),
 265                 modal: true,
 266                 width: 600,
 267                 height: 400,
 268                 layout: 'fit',
 269                 items: [{
 270                     xtype: 'pmgLDAPUserGrid',
 271                     border: false,
 272                     url: '/api2/json/config/ldap/' + name + '/groups/' +  record.data.gid
 273                 }]
 274             }).show();
 275         },
 276
 277         showUsers: function(button) {
 278             var me = this;
 279             var view = me.lookup('groupgrid');
 280             var record = view.getSelection()[0];
 281             me.openUserList(view, record);
 282         },
 283
 284         openUserMails: function(grid, record) {
 285             var name = this.getViewModel().get('name');
 286             Ext.create('Ext.window.Window', {
 287                 title: Ext.String.format(gettext("E-Mail addresses of '{0}'"), record.data.dn),
 288                 modal: true,
 289                 width: 600,
 290                 height: 400,
 291                 layout: 'fit',
 292                 items: [{
 293                     xtype: 'grid',
 294                     border: false,
 295                     store: {
 296                         autoLoad: true,
 297                         field: ['email', 'primary'],
 298                         proxy: {
 299                             type: 'proxmox',
 300                             url: '/api2/json/config/ldap/' + name + '/users/' +  record.data.pmail
 301                         }
 302                     },
 303                     columns: [
 304                         { dataIndex: 'email', text: gettext('E-Mail address'), flex: 1 }
 305                     ]
 306                 }]
 307             }).show();
 308         },
 309
 310         showEmails: function(button) {
 311             var me = this;
 312             var view = me.lookup('usergrid');
 313             var record = view.getSelection()[0];
 314             me.openUserMails(view, record);
 315         },
 316
 317         reload: function(grid) {
 318             var me = this;
 319             var selection = grid.getSelection();
 320             me.showInfo(grid, selection);
 321         },
 322
 323         showInfo: function(grid, selected) {
 324             var me = this;
 325             var viewModel = me.getViewModel();
 326             if (selected[0]) {
 327                 var name = selected[0].data.profile;
 328                 viewModel.set('selected', true);
 329                 viewModel.set('name', name);
 330
 331                 // set grid stores and load them
 332                 var gstore = me.lookup('groupgrid').getStore();
 333                 var ustore = me.lookup('usergrid').getStore();
 334                 gstore.getProxy().setUrl('/api2/json/config/ldap/' + name + '/groups');
 335                 ustore.getProxy().setUrl('/api2/json/config/ldap/' + name + '/users');
 336                 gstore.load();
 337                 ustore.load();
 338             } else {
 339                 viewModel.set('selected', false);
 340             }
 341         },
 342
 343         init: function(view) {
 344             var me = this;
 345             me.lookup('grid').relayEvents(view, ['activate']);
 346             var groupgrid = me.lookup('groupgrid');
 347             var usergrid = me.lookup('usergrid');
 348
 349             Proxmox.Utils.monStoreErrors(groupgrid, groupgrid.getStore(), true);
 350             Proxmox.Utils.monStoreErrors(usergrid, usergrid.getStore(), true);
 351         },
 352
 353         control: {
 354             'grid[reference=grid]': {
 355                 selectionchange: 'showInfo',
 356                 load: 'reload'
 357             },
 358             'grid[reference=groupgrid]': {
 359                 itemdblclick: 'openUserList'
 360             },
 361             'grid[reference=usergrid]': {
 362                 itemdblclick: 'openUserMails'
 363             }
 364         }
 365     },
 366
 367     viewModel: {
 368         data: {
 369             name: '',
 370             selected: false
 371         }
 372     },
 373
 374     layout: 'border',
 375
 376     items: [
 377         {
 378             region: 'center',
 379             reference: 'grid',
 380             xtype: 'pmgLDAPConfigGrid',
 381             border: false
 382         },
 383         {
 384             xtype: 'tabpanel',
 385             reference: 'data',
 386             hidden: true,
 387             height: '50%',
 388             border: false,
 389             split: true,
 390             region: 'south',
 391             bind: {
 392                 hidden: '{!selected}'
 393             },
 394             items: [
 395                 {
 396                     xtype: 'grid',
 397                     reference: 'groupgrid',
 398                     border: false,
 399                     emptyText: gettext('No data in database'),
 400                     tbar: [{
 401                         xtype: 'proxmoxButton',
 402                         text: gettext('Show Users'),
 403                         handler: 'showUsers',
 404                         disabled: true
 405                     }],
 406                     store: {
 407                         fields: ['dn', 'gid'],
 408                         proxy: { type: 'proxmox' },
 409                         sorters: [ 'dn' ]
 410                     },
 411                     bind: {
 412                         title: Ext.String.format(gettext("Groups of '{0}'"), '{name}')
 413                     },
 414                     columns: [
 415                         {
 416                             text: 'DN',
 417                             dataIndex: 'dn',
 418                             flex: 1
 419                         }
 420                     ]
 421                 },
 422                 {
 423                     xtype: 'pmgLDAPUserGrid',
 424                     reference: 'usergrid',
 425                     border: false,
 426                     tbar: [{
 427                         xtype: 'proxmoxButton',
 428                         text: gettext('Show E-Mail addresses'),
 429                         handler: 'showEmails',
 430                         disabled: true
 431                     }],
 432                     bind: {
 433                         title: Ext.String.format(gettext("Users of '{0}'"), '{name}')
 434                     }
 435                 }
 436             ]
 437         }
 438     ]
 439
 440 });
 441
 442 Ext.define('PMG.LDAPConfigGrid', {
 443     extend: 'Ext.grid.GridPanel',
 444     alias: 'widget.pmgLDAPConfigGrid',
 445
 446     controller: {
 447         xclass: 'Ext.app.ViewController',
 448
 449         run_editor: function() {
 450             var me = this;
 451             var view = me.getView();
 452             var rec = view.getSelection()[0];
 453             if (!rec) {
 454                 return;
 455             }
 456
 457             var win = Ext.createWidget('pmgLDAPEdit', {
 458                 profileId: rec.data.profile
 459             });
 460             win.on('destroy', me.reload, me);
 461             win.load();
 462             win.show();
 463         },
 464
 465         newProfile: function() {
 466             var me = this;
 467             var win = Ext.createWidget('pmgLDAPEdit', {});
 468             win.on('destroy', me.reload, me);
 469             win.show();
 470         },
 471
 472
 473         reload: function() {
 474             var me = this.getView();
 475             me.getStore().load();
 476             me.fireEvent('load', me);
 477         },
 478
 479         sync: function() {
 480             var me = this;
 481             var view = me.getView();
 482             var rec = view.getSelection()[0];
 483             Proxmox.Utils.API2Request({
 484                 url: '/config/ldap/' + rec.data.profile + '/sync',
 485                 method: 'POST',
 486                 waitMsgTarget: view,
 487                 callback: function() {
 488                     me.reload();
 489                 },
 490                 failure: function (response, opts) {
 491                     Ext.Msg.alert(gettext('Error'), response.htmlStatus);
 492                 }
 493             });
 494         },
 495
 496         init: function(view) {
 497             var me = this;
 498             Proxmox.Utils.monStoreErrors(view, view.getStore(), true);
 499         }
 500     },
 501
 502     store: {
 503         model: 'pmg-ldap-config',
 504         sorters: [{
 505             property: 'profile',
 506             order: 'DESC'
 507         }]
 508     },
 509
 510     tbar: [
 511         {
 512             xtype: 'proxmoxButton',
 513             text: gettext('Edit'),
 514             disabled: true,
 515             handler: 'run_editor'
 516         },
 517         {
 518             text: gettext('Create'),
 519             handler: 'newProfile'
 520         },
 521         {
 522             xtype: 'proxmoxStdRemoveButton',
 523             baseurl: '/config/ldap',
 524             callback: 'reload'
 525         },
 526         {
 527             xtype: 'proxmoxButton',
 528             text: gettext('Synchronize'),
 529             enableFn: function(rec) {
 530                 return !rec.data.disable;
 531             },
 532             disabled: true,
 533             handler: 'sync'
 534         }
 535     ],
 536
 537     listeners: {
 538         itemdblclick: 'run_editor',
 539         activate: 'reload'
 540     },
 541
 542     columns: [
 543         {
 544             header: gettext('Profile Name'),
 545             sortable: true,
 546             width: 120,
 547             dataIndex: 'profile'
 548         },
 549         {
 550             header: gettext('Protocol'),
 551             sortable: true,
 552             dataIndex: 'mode',
 553             renderer: PMG.Utils.format_ldap_protocol
 554         },
 555         {
 556             header: gettext('Server'),
 557             sortable: true,
 558             dataIndex: 'server1',
 559             renderer: function(value, metaData, rec) {
 560                 if (rec.data.server2) {
 561                     return value + '<br>' + rec.data.server2;
 562                 }
 563                 return value;
 564             }
 565         },
 566         {
 567             header: gettext('Enabled'),
 568             width: 80,
 569             sortable: true,
 570             dataIndex: 'disable',
 571             renderer: Proxmox.Utils.format_neg_boolean
 572         },
 573         {
 574             header: gettext('Comment'),
 575             sortable: false,
 576             renderer: Ext.String.htmlEncode,
 577             dataIndex: 'comment',
 578             flex: 1
 579         },
 580         {
 581             header: gettext('Accounts'),
 582             width: 80,
 583             sortable: true,
 584             dataIndex: 'ucount'
 585         },
 586         {
 587             header: gettext('Addresses'),
 588             width: 80,
 589             sortable: true,
 590             dataIndex: 'mcount'
 591         },
 592         {
 593             header: gettext('Groups'),
 594             width: 80,
 595             sortable: true,
 596             dataIndex: 'gcount'
 597         }
 598     ]
 599
 600 });