js/ObjectGroup.js

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