js/ObjectGroup.js

   1 Ext.define('PMG.ObjectGroup', {
   2     extend: 'Ext.grid.GridPanel',
   3     alias: 'widget.pmgObjectGroup',
   4
   5     baseurl: undefined,
   6
   7     otype_list: [],
   8
   9     hideGroupInfo: false,
  10     showDirection: false, // only important for SMTP Whitelist
  11
  12     ogdata: undefined,
  13
  14     emptyText: gettext('Please select an object.'),
  15
  16     setBaseUrl: function(baseurl) {
  17         let me = this;
  18
  19         me.baseurl = baseurl;
  20
  21         if (me.baseurl === undefined) {
  22             me.store.proxy.setUrl(undefined);
  23             me.store.setData([]);
  24             me.setButtonState(me.store, [], false);
  25         } else {
  26             let url = '/api2/json' + me.baseurl + '/objects';
  27             me.store.proxy.setUrl(url);
  28             me.store.load();
  29         }
  30     },
  31
  32     setObjectInfo: function(ogdata) {
  33         let me = this;
  34
  35         me.ogdata = ogdata;
  36
  37         if (me.ogdata === undefined) {
  38             me.down('#oginfo').update(me.emptyText);
  39         } else {
  40             let html = '<b>' + Ext.String.htmlEncode(me.ogdata.name) + '</b>';
  41             html += "<br><br>";
  42             html += Ext.String.htmlEncode(Ext.String.trim(me.ogdata.info));
  43
  44             me.down('#oginfo').update(html);
  45             me.down('#ogdata').setHidden(false);
  46         }
  47     },
  48
  49     setButtonState: function(store, records, success) {
  50         let me = this;
  51         if (!success || !me.baseurl) {
  52             me.down('#addMenuButton').setDisabled(true);
  53             return;
  54         }
  55         me.down('#addMenuButton').setDisabled(false);
  56     },
  57
  58     initComponent: function() {
  59         let me = this;
  60
  61         me.store = new Ext.data.Store({
  62             model: 'pmg-object-list',
  63             proxy: {
  64                 type: 'proxmox',
  65             },
  66             sorters: [
  67                 {
  68                     property: 'receivertest',
  69                 },
  70                 {
  71                     property: 'otype',
  72                     direction: 'ASC',
  73                 },
  74             ],
  75         });
  76
  77         me.columns = [{
  78             header: gettext('Type'),
  79             dataIndex: 'otype',
  80             renderer: PMG.Utils.format_otype,
  81             width: 200,
  82         }];
  83
  84         if (me.showDirection) {
  85             me.columns.push({
  86                 header: gettext('Direction'),
  87                 dataIndex: 'receivertest',
  88                 renderer: function(value) {
  89                     return value ? PMG.Utils.receiverText : PMG.Utils.senderText;
  90                 },
  91             });
  92         }
  93
  94         me.columns.push({
  95             header: gettext('Value'),
  96             dataIndex: 'descr',
  97             renderer: Ext.String.htmlEncode,
  98             flex: 1,
  99         });
 100
 101         let reload = function() {
 102             me.store.load();
 103         };
 104
 105         me.selModel = Ext.create('Ext.selection.RowModel', {});
 106
 107         let remove_btn = Ext.createWidget('proxmoxStdRemoveButton', {
 108             selModel: me.selModel,
 109             getUrl: function(rec) {
 110                 return me.baseurl + '/objects/' + rec.data.id;
 111             },
 112             callback: reload,
 113             getRecordName: function(rec) {
 114                 return PMG.Utils.format_otype(rec.data.otype) +
 115                     ': ' + rec.data.descr;
 116             },
 117             waitMsgTarget: me,
 118         });
 119
 120         let full_subject = function(subject, receivertest) {
 121             if (me.showDirection) {
 122                 let direction = receivertest
 123                     ? PMG.Utils.receiverText : PMG.Utils.senderText;
 124
 125                 return subject + ' (' + direction + ')';
 126             } else {
 127                 return subject;
 128             }
 129         };
 130
 131         let run_editor = function() {
 132             let rec = me.selModel.getSelection()[0];
 133             if (!rec) {
 134                 return;
 135             }
 136
 137             let editor = PMG.Utils.object_editors[rec.data.otype];
 138             if (!editor || editor.uneditable) {
 139                 return;
 140             }
 141
 142             let config = Ext.apply({ method: 'PUT' }, editor);
 143             config.subject = full_subject(editor.subject, rec.data.receivertest);
 144             config.url = me.baseurl + '/' + editor.subdir + '/' + rec.data.id;
 145
 146             let win = Ext.createWidget(config);
 147
 148             win.load();
 149             win.on('destroy', reload);
 150             win.show();
 151         };
 152
 153         let menu_items = [];
 154
 155         Ext.Array.each(me.otype_list, function(otype) {
 156             let editor = PMG.Utils.object_editors[otype];
 157
 158             let config = Ext.apply({ method: 'POST' }, editor);
 159             config.subject = full_subject(editor.subject, editor.receivertest);
 160
 161             menu_items.push({
 162                 text: config.subject,
 163                 iconCls: config.iconCls || 'fa fa-question-circle',
 164                 handler: function() {
 165                     if (me.baseurl === undefined) {
 166                         return;
 167                     }
 168                     config.url = me.baseurl + '/' + editor.subdir;
 169                     let win = Ext.create(config);
 170                     win.on('destroy', reload);
 171                     win.show();
 172                 },
 173             });
 174         });
 175
 176         me.dockedItems = [];
 177
 178         me.dockedItems.push({
 179             xtype: 'toolbar',
 180             dock: 'top',
 181             items: [
 182                 {
 183                     text: gettext('Add'),
 184                     disabled: true,
 185                     itemId: 'addMenuButton',
 186                     menu: {
 187                         items: menu_items,
 188                     },
 189                 },
 190                 {
 191                     xtype: 'proxmoxButton',
 192                     text: gettext('Edit'),
 193                     disabled: true,
 194                     selModel: me.selModel,
 195                     enableFn: function(rec) {
 196                         let editor = PMG.Utils.object_editors[rec.data.otype];
 197                         return editor && !editor.uneditable;
 198                     },
 199                     handler: run_editor,
 200                 },
 201                 remove_btn,
 202             ],
 203         });
 204
 205         me.dockedItems.push({
 206             dock: 'top',
 207             border: 1,
 208             layout: 'anchor',
 209             hidden: !!me.hideGroupInfo,
 210             itemId: 'ogdata',
 211             items: [
 212                 {
 213                     xtype: 'component',
 214                     anchor: '100%',
 215                     itemId: 'oginfo',
 216                     style: { 'white-space': 'pre' },
 217                     padding: 10,
 218                     html: me.emptyText,
 219                     listeners: {
 220                         dblclick: {
 221                             fn: function(e, t) {
 222                                 if (me.ogdata === undefined) { return; }
 223                                 me.fireEvent('dblclickOGInfo', me, e, t, me.ogdata);
 224                             },
 225                             element: 'el',
 226                             scope: this,
 227                         },
 228                     },
 229                 },
 230             ],
 231         });
 232
 233         Proxmox.Utils.monStoreErrors(me, me.store, true);
 234
 235         Ext.apply(me, {
 236             run_editor: run_editor,
 237             listeners: {
 238                 itemdblclick: run_editor,
 239                 activate: reload,
 240             },
 241         });
 242
 243         me.callParent();
 244
 245         me.mon(me.store, 'load', me.setButtonState, me);
 246
 247         if (me.baseurl) {
 248             me.setBaseUrl(me.baseurl); // configure store, load()
 249         }
 250     },
 251 });