extend: 'Ext.data.Model',
fields: [
'id', 'name', 'info', 'descr', 'editable',
- { name: 'otype', type: 'integer' }
+ { name: 'otype', type: 'integer' },
],
- idProperty: 'id'
+ idProperty: 'id',
});
Ext.define('PMG.ActionList', {
enableButtons: true,
- initComponent : function() {
+ initComponent: function() {
var me = this;
me.store = new Ext.data.Store({
model: 'pmg-action-list',
proxy: {
type: 'proxmox',
- url: "/api2/json" + me.baseurl + '/objects'
+ url: "/api2/json" + me.baseurl + '/objects',
},
sorters: {
property: 'name',
- order: 'DESC'
- }
+ order: 'DESC',
+ },
});
me.selModel = Ext.create('Ext.selection.RowModel', {});
enableFn: rec => !!rec.data.editable,
callback: reload,
getRecordName: function(rec) { return rec.data.descr; },
- waitMsgTarget: me
+ waitMsgTarget: me,
});
var menu_items = [];
Ext.Array.each(me.otype_list, function(otype) {
-
var editor = PMG.Utils.object_editors[otype];
var config = Ext.apply({ method: 'POST' }, editor);
var win = Ext.createWidget('proxmoxWindowEdit', config);
win.on('destroy', reload);
win.show();
- }
+ },
});
});
{
text: gettext('Add'),
menu: new Ext.menu.Menu({
- items: menu_items
- })
+ items: menu_items,
+ }),
},
{
xtype: 'proxmoxButton',
disabled: true,
selModel: me.selModel,
enableFn: rec => !!rec.data.editable,
- handler: run_editor
+ handler: run_editor,
},
- remove_btn
+ remove_btn,
];
Proxmox.Utils.monStoreErrors(me, me.store, true);
sortable: true,
width: 200,
dataIndex: 'name',
- renderer: Ext.String.htmlEncode
+ renderer: Ext.String.htmlEncode,
},
{
header: gettext('Description'),
sortable: true,
width: 300,
dataIndex: 'descr',
- renderer: Ext.String.htmlEncode
+ renderer: Ext.String.htmlEncode,
},
{
header: gettext('Comment'),
sortable: false,
flex: 1,
dataIndex: 'info',
- renderer: Ext.String.htmlEncode
+ renderer: Ext.String.htmlEncode,
},
{
header: gettext('Editable'),
dataIndex: 'editable',
renderer: Proxmox.Utils.format_boolean,
- }
+ },
],
listeners: {
itemdblclick: function() {
run_editor();
}
},
- activate: reload
- }
+ activate: reload,
+ },
});
me.callParent();
reload(); // initial load
- }
+ },
});
appProperty: 'app',
stores: [
- 'NavigationStore'
+ 'NavigationStore',
],
layout: 'fit',
me.currentView.destroy();
me.currentView = Ext.create({
xtype: view,
- targetview: me.targetview
+ targetview: me.targetview,
});
if (skipCheck !== true) {
Proxmox.Utils.checked_command(function() {}); // display subscription status
PMG.view = me.view;
me.currentView = Ext.create({
xtype: me.view,
- targetview: me.targetview
+ targetview: me.targetview,
});
- }
+ },
});
Ext.application('PMG.Application');
-Ext.define('PMG.grid.AttachmentGrid',{
+Ext.define('PMG.grid.AttachmentGrid', {
extend: 'Ext.grid.GridPanel',
xtype: 'pmgAttachmentGrid',
store: {
autoDestroy: true,
- fields: [ 'name', 'content-type', 'size' ],
+ fields: ['name', 'content-type', 'size'],
proxy: {
type: 'proxmox',
- }
+ },
},
setID: function(rec) {
return "<a target='_blank' class='download' download='"+ rec.data.name +"' href='" +
url + "'><i class='fa fa-fw fa-download'</i></a>";
},
- }
- ]
+ },
+ ],
});
/*format is a string and a function*/
Ext.define('pmg-attachment-list', {
extend: 'Ext.data.Model',
- fields: [ 'id', 'envelope_sender', 'from', 'sender', 'receiver', 'subject',
+ fields: ['id', 'envelope_sender', 'from', 'sender', 'receiver', 'subject',
{ type: 'integer', name: 'bytes' },
{ type: 'date', dateFormat: 'timestamp', name: 'time' },
{
name: 'day',
convert: function(v, rec) {
return Ext.Date.format(rec.get('time'), 'Y-m-d');
- }, depends: ['time']
- }
+ }, depends: ['time'],
+ },
],
proxy: {
type: 'proxmox',
- url: "/api2/json/quarantine/attachment"
+ url: "/api2/json/quarantine/attachment",
},
- idProperty: 'id'
+ idProperty: 'id',
});
Ext.define('PMG.AttachmentQuarantine', {
updatePreview: function(raw, rec) {
var preview = this.lookupReference('preview');
- if (!rec || !rec.data || !rec.data.id) {
+ if (!rec || !rec.data || !rec.data.id) {
preview.update('');
preview.setDisabled(true);
return;
}
- var url = '/api2/htmlmail/quarantine/content?id=' + rec.data.id + ((raw)?'&raw=1':'');
+ var url = '/api2/htmlmail/quarantine/content?id=' + rec.data.id + (raw?'&raw=1':'');
preview.setDisabled(false);
preview.update("<iframe frameborder=0 width=100% height=100% sandbox='allow-same-origin' src='" + url +"'></iframe>");
},
control: {
'button[reference=raw]': {
- click: 'toggleRaw'
+ click: 'toggleRaw',
},
'pmgQuarantineList': {
- selectionChange: 'onSelectMail'
- }
- }
+ selectionChange: 'onSelectMail',
+ },
+ },
},
groupDir: 'DESC',
sorters: [{
property: 'time',
- direction: 'DESC'
- }]
+ direction: 'DESC',
+ }],
},
columns: [
header: gettext('Sender/Subject'),
dataIndex: 'subject',
renderer: PMG.Utils.sender_renderer,
- flex: 1
+ flex: 1,
},
{
header: gettext('Size') + ' (KB)',
renderer: function(v) { return Ext.Number.toFixed(v/1024, 0); },
dataIndex: 'bytes',
align: 'right',
- width: 90
+ width: 90,
},
{
header: gettext('Date'),
dataIndex: 'day',
- hidden: true
+ hidden: true,
},
{
xtype: 'datecolumn',
header: gettext('Time'),
dataIndex: 'time',
- format: 'H:i:s'
- }
- ]
+ format: 'H:i:s',
+ },
+ ],
},
{
title: gettext('Selected Mail'),
reference: 'raw',
text: gettext('Toggle Raw'),
enableToggle: true,
- iconCls: 'fa fa-file-code-o'
+ iconCls: 'fa fa-file-code-o',
},
'->',
{
reference: 'deliver',
text: gettext('Deliver'),
iconCls: 'fa fa-paper-plane-o',
- handler: 'btnHandler'
+ handler: 'btnHandler',
},
{
reference: 'delete',
text: gettext('Delete'),
iconCls: 'fa fa-trash-o',
- handler: 'btnHandler'
- }
- ]
+ handler: 'btnHandler',
+ },
+ ],
},
{
xtype: 'pmgAttachmentGrid',
hidden: true,
reference: 'mailinfo',
},
- ]
- }
- ]
+ ],
+ },
+ ],
});
fields: [
'filename',
{ type: 'integer', name: 'size' },
- { type: 'date', dateFormat: 'timestamp', name: 'timestamp' }
+ { type: 'date', dateFormat: 'timestamp', name: 'timestamp' },
],
proxy: {
type: 'proxmox',
- url: "/api2/json/nodes/" + Proxmox.NodeName + "/backup"
+ url: "/api2/json/nodes/" + Proxmox.NodeName + "/backup",
},
- idProperty: 'filename'
+ idProperty: 'filename',
});
Ext.define('PMG.RestoreWindow', {
method: 'POST',
submitText: gettext('Restore'),
fieldDefaults: {
- labelWidth: 150
+ labelWidth: 150,
},
items: [
{
xtype: 'proxmoxcheckbox',
name: 'config',
- fieldLabel: gettext('System Configuration')
+ fieldLabel: gettext('System Configuration'),
},
{
xtype: 'proxmoxcheckbox',
change: function(cb, value) {
var me = this;
me.up().down('field[name=statistic]').setDisabled(!value);
- }
- }
+ },
+ },
},
{
xtype: 'proxmoxcheckbox',
name: 'statistic',
- fieldLabel: gettext('Statistic')
- }
+ fieldLabel: gettext('Statistic'),
+ },
],
initComponent: function() {
me.url = "/nodes/" + Proxmox.NodeName + "/backup/" + encodeURIComponent(me.filename);
me.callParent();
- }
+ },
});
Ext.define('PMG.BackupRestore', {
url: "/nodes/" + Proxmox.NodeName + "/backup",
method: 'POST',
waitMsgTarget: me,
- failure: function (response, opts) {
+ failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
success: function(response, opts) {
var upid = response.result.data;
var win = Ext.create('Proxmox.window.TaskViewer', {
- upid: upid
+ upid: upid,
});
win.show();
me.mon(win, 'close', function() { me.store.load(); });
- }
+ },
});
},
}
Ext.create('PMG.RestoreWindow', {
- filename: rec.data.filename
+ filename: rec.data.filename,
}).show();
},
onAfterRemove: function(btn, res) {
var me = this.getView();
me.store.load();
- }
+ },
},
tbar: [
{
text: gettext('Backup'),
- handler: 'createBackup'
+ handler: 'createBackup',
},
'-',
{
xtype: 'proxmoxButton',
text: gettext('Restore'),
handler: 'onRestore',
- disabled: true
+ disabled: true,
},
{
xtype: 'proxmoxStdRemoveButton',
baseurl: '/nodes/' + Proxmox.NodeName + '/backup',
reference: 'removeBtn',
callback: 'onAfterRemove',
- waitMsgTarget: true
- }
+ waitMsgTarget: true,
+ },
],
store: {
sorters: [
{
property: 'timestamp',
- direction: 'DESC'
- }
- ]
+ direction: 'DESC',
+ },
+ ],
},
columns: [
width: 300,
sortable: true,
renderer: Ext.htmlEncode,
- dataIndex: 'filename'
+ dataIndex: 'filename',
},
{
xtype: 'datecolumn',
width: 150,
format: 'Y-m-d H:i',
sortable: true,
- dataIndex: 'timestamp'
+ dataIndex: 'timestamp',
},
{
header: gettext('Size'),
width: 100,
sortable: true,
renderer: Proxmox.Utils.format_size,
- dataIndex: 'size'
+ dataIndex: 'size',
},
{
header: gettext('Download'),
"/api2/json/nodes/" + Proxmox.NodeName + "/backup/" + encodeURIComponent(filename) +
"'><i class='fa fa-fw fa-download'</i></a>";
},
- dataIndex: 'filename'
- }
- ]
+ dataIndex: 'filename',
+ },
+ ],
});
monStoreErrors: true,
- initComponent : function() {
+ initComponent: function() {
var me = this;
me.add_text_row('dbmirror', gettext('Database Mirror'),
url: '/api2/json' + baseurl,
editorConfig: {
url: '/api2/extjs' + baseurl,
- onlineHelp: 'pmgconfig_clamav'
+ onlineHelp: 'pmgconfig_clamav',
},
interval: 5000,
cwidth1: 200,
listeners: {
- itemdblclick: me.run_editor
- }
+ itemdblclick: me.run_editor,
+ },
});
me.callParent();
me.on('activate', me.rstore.startUpdate);
me.on('destroy', me.rstore.stopUpdate);
me.on('deactivate', me.rstore.stopUpdate);
- }
+ },
});
Ext.define('pmg-clamav-database', {
extend: 'Ext.data.Model',
- fields: [ 'name', 'type', 'build_time', 'version',
+ fields: ['name', 'type', 'build_time', 'version',
{ name: 'nsigs', type: 'integer' }],
- idProperty: 'name'
+ idProperty: 'name',
});
Ext.define('PMG.ClamAVDatabaseStatus', {
me.store.load();
},
- initComponent : function() {
+ initComponent: function() {
var me = this;
me.store = new Ext.data.Store({
model: 'pmg-clamav-database',
proxy: {
type: 'proxmox',
- url: "/api2/json/nodes/" + Proxmox.NodeName + "/clamav/database"
+ url: "/api2/json/nodes/" + Proxmox.NodeName + "/clamav/database",
},
sorters: {
property: 'name',
- order: 'DESC'
- }
+ order: 'DESC',
+ },
});
Ext.apply(me, {
viewConfig: {
- trackOver: false
+ trackOver: false,
},
columns: [
{
header: gettext('Name'),
sortable: true,
flex: 1,
- dataIndex: 'name'
+ dataIndex: 'name',
},
{
header: gettext('Build time'),
sortable: true,
flex: 2,
- dataIndex: 'build_time'
+ dataIndex: 'build_time',
},
{
header: gettext('Version'),
flex: 1,
sortable: true,
- dataIndex: 'version'
+ dataIndex: 'version',
},
{
header: gettext('Signatures'),
flex: 1,
sortable: true,
- dataIndex: 'nsigs'
- }
+ dataIndex: 'nsigs',
+ },
],
listeners: {
- activate: me.reload
- }
+ activate: me.reload,
+ },
});
me.callParent();
/*monStoreErrors is a bool above*/
Proxmox.Utils.monStoreErrors(me.getView(), me.store, true);
/*jslint confusion: false*/
- }
+ },
});
Ext.define('PMG.ClamAVDatabase', {
layout: { type: 'vbox', align: 'stretch' },
- initComponent : function() {
+ initComponent: function() {
var me = this;
var selModel = Ext.create('Ext.selection.RowModel', {});
var editPanel = Ext.create('PMG.ClamAVDatabaseConfig', {
border: false,
xtype: 'pmgClamAVDatabaseConfig',
- selModel: selModel
+ selModel: selModel,
});
var statusPanel = Ext.create('PMG.ClamAVDatabaseStatus', {
border: false,
- flex: 1
+ flex: 1,
});
- var update_command = function(){
+ var update_command = function() {
Proxmox.Utils.API2Request({
url: '/nodes/' + Proxmox.NodeName + '/clamav/database',
method: 'POST',
var upid = response.result.data;
var win = Ext.create('Proxmox.window.TaskViewer', {
- upid: upid
+ upid: upid,
});
win.show();
me.mon(win, 'close', function() { statusPanel.reload(); });
- }
+ },
});
};
xtype: 'proxmoxButton',
disabled: true,
handler: function() { editPanel.run_editor(); },
- selModel: selModel
+ selModel: selModel,
},
{
text: gettext('Update now'),
- handler: update_command
- }
+ handler: update_command,
+ },
];
- me.items = [ editPanel, statusPanel ];
+ me.items = [editPanel, statusPanel];
me.callParent();
editPanel.relayEvents(me, ['activate', 'deactivate', 'destroy']);
statusPanel.relayEvents(me, ['activate', 'deactivate', 'destroy']);
-
- }
+ },
});
'fingerprint', { type: 'integer', name: 'cid' },
{ type: 'boolean', name: 'insync' },
'memory', 'loadavg', 'uptime', 'rootfs', 'conn_error', 'level',
- { type: 'number', name: 'memory_per',
+ {
+ type: 'number', name: 'memory_per',
calculate: function(data) {
var mem = data.memory;
return Ext.isObject(mem) ? mem.used/mem.total : 0;
- }
+ },
},
- { type: 'number', name: 'rootfs_per',
+ {
+ type: 'number', name: 'rootfs_per',
calculate: function(data) {
var du = data.rootfs;
return Ext.isObject(du) ? du.used/du.total : 0;
- }
- }
+ },
+ },
],
proxy: {
type: 'proxmox',
- url: "/api2/json/config/cluster/status"
+ url: "/api2/json/config/cluster/status",
},
- idProperty: 'cid'
+ idProperty: 'cid',
});
Ext.define('PMG.ClusterJoinNodeWindow', {
{
xtype: 'textfield',
fieldLabel: 'IP Address',
- name: 'master_ip'
+ name: 'master_ip',
},
{
xtype: 'textfield',
inputType: 'password',
fieldLabel: gettext('Password'),
- name: 'password'
+ name: 'password',
},
{
xtype: 'textfield',
fieldLabel: gettext('Fingerprint'),
- name: 'fingerprint'
- }
- ]
+ name: 'fingerprint',
+ },
+ ],
});
Ext.define('PMG.ClusterAddNodeWindow', {
xtype: 'component',
border: false,
padding: '10 10 10 10',
- html: gettext("Please use the 'Join' button on the node you want to add, using the following IP address and fingerprint.")
+ html: gettext("Please use the 'Join' button on the node you want to add, using the following IP address and fingerprint."),
},
{
xtype: 'container',
xtype: 'textfield',
fieldLabel: gettext('IP Address'),
cbind: { value: '{ipAddress}' },
- editable: false
+ editable: false,
},
{
xtype: 'textfield',
fieldLabel: gettext('Fingerprint'),
cbind: { value: '{fingerprint}' },
- editable: false
- }
- ]
- }
- ]
+ editable: false,
+ },
+ ],
+ },
+ ],
});
/*jslint confusion: true*/
parent: null,
data: {
nodecount: 0,
- master: null
- }
+ master: null,
+ },
},
items: [
url: '/config/cluster/create',
method: 'POST',
waitMsgTarget: view,
- failure: function (response, opts) {
+ failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
success: function(response, options) {
var win = Ext.create('Proxmox.window.TaskProgress', { upid: upid });
win.show();
win.on('destroy', function() { view.store.load(); });
- }
+ },
});
},
var win = Ext.create('PMG.ClusterAddNodeWindow', {
ipAddress: vm.get('master').get('ip'),
- fingerprint: vm.get('master').get('fingerprint')
+ fingerprint: vm.get('master').get('fingerprint'),
});
win.show();
- }
+ },
},
store: {
autoLoad: true,
model: 'pmg-cluster',
- sorters: [ 'cid' ]
+ sorters: ['cid'],
},
tbar: [
{
reference: 'createButton',
handler: 'onCreate',
bind: {
- disabled: '{nodecount}'
- }
+ disabled: '{nodecount}',
+ },
},
{
text: gettext('Add'),
reference: 'addButton',
handler: 'onAdd',
bind: {
- disabled: '{!master}'
- }
+ disabled: '{!master}',
+ },
},
{
text: gettext('Join'),
reference: 'joinButton',
handler: 'onJoin',
bind: {
- disabled: '{nodecount}'
- }
- }
+ disabled: '{nodecount}',
+ },
+ },
],
columns: [
{
header: gettext('Node'),
width: 150,
- dataIndex: 'name'
+ dataIndex: 'name',
},
{
header: gettext('Role'),
width: 100,
- dataIndex: 'type'
+ dataIndex: 'type',
},
{
header: gettext('ID'),
width: 80,
- dataIndex: 'cid'
+ dataIndex: 'cid',
},
{
header: gettext('IP'),
width: 150,
- dataIndex: 'ip'
+ dataIndex: 'ip',
},
{
header: gettext('State'),
}
if (d.conn_error) {
metaData.tdCls = 'x-form-invalid-field';
- var html = '<p>' + Ext.htmlEncode(d.conn_error) + '</p>';
+ var html = '<p>' + Ext.htmlEncode(d.conn_error) + '</p>';
html = html.replace(/\n/g, '<br>');
metaData.tdAttr = 'data-qwidth=600 data-qtitle="ERROR" data-qtip="' +
- html.replace(/\"/g,'"') + '"';
+ html.replace(/\"/g, '"') + '"';
state = 'error';
}
return state;
},
- dataIndex: 'insync'
+ dataIndex: 'insync',
},
{
header: gettext('Subscription'),
width: 120,
renderer: Proxmox.Utils.format_subscription_level,
- dataIndex: 'level'
+ dataIndex: 'level',
},
{
header: gettext('Uptime'),
width: 150,
renderer: Proxmox.Utils.render_uptime,
- dataIndex: 'uptime'
+ dataIndex: 'uptime',
},
{
header: gettext('Load average'),
}
return '';
},
- dataIndex: 'loadavg'
+ dataIndex: 'loadavg',
},
{
xtype: 'widgetcolumn',
widget: {
xtype: 'progressbarwidget',
- textTpl: '{value:percent}'
+ textTpl: '{value:percent}',
},
header: gettext('RAM usage'),
- dataIndex: 'memory_per'
+ dataIndex: 'memory_per',
},
{
xtype: 'widgetcolumn',
widget: {
xtype: 'progressbarwidget',
- textTpl: '{value:percent}'
+ textTpl: '{value:percent}',
},
header: gettext('HD space'),
- dataIndex: 'rootfs_per'
- }
- ]
- }
- ]
+ dataIndex: 'rootfs_per',
+ },
+ ],
+ },
+ ],
});
style: {
backgroundColor: '#f5f5f5',
padding: 0,
- margin: 0
+ margin: 0,
},
items: {
xtype: 'treelist',
} else {
info.toggle = true;
}
- }
- }
- }
+ },
+ },
+ },
}],
firstItem: '',
me.store = Ext.create('Ext.data.TreeStore', {
root: {
- expanded: true
- }
+ expanded: true,
+ },
});
var root = me.store.getRoot();
- me.items.forEach(function(item){
- var treeitem = Ext.create('Ext.data.TreeModel',{
+ me.items.forEach(function(item) {
+ var treeitem = Ext.create('Ext.data.TreeModel', {
id: item.itemId,
text: item.title,
iconCls: item.iconCls,
leaf: true,
- expanded: item.expandedOnInit
+ expanded: item.expandedOnInit,
});
item.header = false;
if (me.savedItems[item.itemId] !== undefined) {
me.defaults = me.defaults || {};
Ext.apply(me.defaults, {
viewFilter: me.viewFilter,
- border: 0
+ border: 0,
});
me.callParent();
if (stateid) {
me.mon(me.sp, 'statechange', statechange);
}
- }
+ },
});
xtype: 'panel',
itemId: 'info',
bodyPadding: 10,
- html: gettext('Please select a contact')
- }
+ html: gettext('Please select a contact'),
+ },
],
disableSelection: true,
{ type: 'integer', name: 'bytes' },
{ type: 'boolean', name: 'blocked' },
{ type: 'integer', name: 'spamlevel' },
- { type: 'date', dateFormat: 'timestamp', name: 'time' }
+ { type: 'date', dateFormat: 'timestamp', name: 'time' },
],
proxy: {
type: 'pmgfilterproxy',
filterId: 'x-gridfilter-sender',
- sortParam: 'orderby'
+ sortParam: 'orderby',
},
sorters: [
{
property: 'time',
- direction: 'ASC'
- }
- ]
+ direction: 'ASC',
+ },
+ ],
},
columns: [
renderer: Ext.htmlEncode,
flex: 1,
filter: { type: 'string' },
- dataIndex: 'sender'
+ dataIndex: 'sender',
},
{
header: gettext('Size') + ' (KB)',
renderer: function(v) { return Ext.Number.toFixed(v/1024, 0); },
- dataIndex: 'bytes'
+ dataIndex: 'bytes',
},
{
xtype: 'datecolumn',
header: gettext('Date'),
format: 'Y-m-d',
- dataIndex: 'time'
+ dataIndex: 'time',
},
{
xtype: 'datecolumn',
header: gettext('Time'),
format: 'H:i:s',
- dataIndex: 'time'
- }
+ dataIndex: 'time',
+ },
],
initComponent: function() {
me.callParent();
Proxmox.Utils.monStoreErrors(me, me.store, true);
- }
+ },
});
Ext.define('PMG.ContactList', {
emptyText: gettext('No data in database'),
viewConfig: {
- deferEmptyText: false
+ deferEmptyText: false,
},
- tbar: [ { xtype: 'pmgStatTimeSelector' } ],
+ tbar: [{ xtype: 'pmgStatTimeSelector' }],
store: {
type: 'pmgStatStore',
'contact',
{ type: 'integer', name: 'count' },
{ type: 'integer', name: 'viruscount' },
- { type: 'integer', name: 'bytes' }
+ { type: 'integer', name: 'bytes' },
],
proxy: {
type: 'pmgfilterproxy',
sortParam: 'orderby',
- filterId: 'x-gridfilter-contact'
+ filterId: 'x-gridfilter-contact',
},
sorters: [
{
property: 'count',
- direction: 'DESC'
+ direction: 'DESC',
},
{
property: 'bytes',
- direction: 'DESC'
+ direction: 'DESC',
},
{
property: 'contact',
- direction: 'ASC'
- }
- ]
+ direction: 'ASC',
+ },
+ ],
},
columns: [
type: 'string',
itemDefaults: {
// any Ext.form.field.Text configs accepted
- }
- }
+ },
+ },
},
{
text: gettext('Count'),
columns: [
{
text: gettext('Mail'),
- dataIndex: 'count'
+ dataIndex: 'count',
},
{
header: gettext('Virus'),
- dataIndex: 'viruscount'
- }
- ]
+ dataIndex: 'viruscount',
+ },
+ ],
},
{
text: gettext('Size') + ' (KB)',
dataIndex: 'bytes',
renderer: function(v) {
return Ext.Number.toFixed(v/1024, 0);
- }
- }
+ },
+ },
],
initComponent: function() {
me.callParent();
Proxmox.Utils.monStoreErrors(me, me.store, true);
- }
+ },
});
Ext.define('PMG.ContactStatistics', {
layout: 'border',
border: false,
defaults: {
- border: false
+ border: false,
},
controller: {
xclass: 'Ext.app.ViewController',
selectionChange: function(grid, selected, eOpts) {
- var details = this.lookupReference('details');
+ var details = this.lookupReference('details');
if (selected.length > 0) {
var contact = selected[0].data.contact;
var url = "/api2/json/statistics/contact/" +
} else {
details.setUrl();
}
- }
+ },
},
items: [
layout: 'fit',
flex: 1,
- listeners: { selectionchange: 'selectionChange' }
+ listeners: { selectionchange: 'selectionChange' },
},
{
xtype: 'pmgContactDetails',
region: 'east',
reference: 'details',
split: true,
- flex: 1
- }
- ]
+ flex: 1,
+ },
+ ],
});
xtype: 'displayfield',
userCls: 'pmx-hint',
value: gettext('You need to create a Selector before enabling DKIM Signing'),
- hidden: true
+ hidden: true,
},
{
xtype: 'proxmoxcheckbox',
checked: false,
deleteDefaultValue: false,
fieldLabel: gettext('Sign Outgoing Mails'),
- }
+ },
],
listeners: {
'show': function() {
var me = this;
- var disablefn = function(errormsg){
+ var disablefn = function(errormsg) {
Ext.Msg.alert(gettext('Error'), errormsg);
me.down('displayfield').setVisible(true);
me.down('proxmoxcheckbox').setDisabled(true);
};
Proxmox.Utils.API2Request({
- url : '/config/dkim/selector',
- method : 'GET',
- failure : function(response, opts) {
- disablefn(response.htmlStatus)
+ url: '/config/dkim/selector',
+ method: 'GET',
+ failure: function(response, opts) {
+ disablefn(response.htmlStatus);
},
- success : function(response, opts) {
+ success: function(response, opts) {
if (!Ext.isDefined(response.result.data.record)) {
disablefn('Could not read private key - please create a selector first!');
}
- }
+ },
});
- }
- }
+ },
+ },
});
Ext.define('PMG.SelectorViewer', {
{
xtype: 'displayfield',
fieldLabel: gettext('Selector'),
- name: 'selector'
+ name: 'selector',
},
{
xtype: 'displayfield',
fieldLabel: gettext('Key Size'),
- name: 'keysize'
+ name: 'keysize',
},
{
xtype: 'textarea',
growMax: 400,
fieldLabel: gettext('DNS TXT Record'),
name: 'record',
- value: 'Could not read private key!'
- }
+ value: 'Could not read private key!',
+ },
],
initComponent: function() {
// hide OK/Reset button, because we just want to show data
me.down('toolbar[dock=bottom]').setVisible(false);
- }
+ },
});
Ext.define('PMG.SelectorList', {
queryMode: 'local',
store: {
- fields: [ 'selector' ],
+ fields: ['selector'],
filterOnLoad: true,
proxy: {
type: 'proxmox',
- url: '/api2/json/config/dkim/selectors'
+ url: '/api2/json/config/dkim/selectors',
},
autoLoad: true,
sorters: [
{
- property : 'selector',
- direction: 'ASC'
- }
- ]
+ property: 'selector',
+ direction: 'ASC',
+ },
+ ],
},
valueField: 'selector',
monStoreErrors: true,
- initComponent : function() {
+ initComponent: function() {
var me = this;
me.rows = {};
editor: {
xtype: 'pmgDKIMEnableEdit',
subject: enable_sign_text,
- }
+ },
};
var selector_text = gettext('Selector');
['1024', '1024'],
['2048', '2048'],
['4096', '4096'],
- ['8192', '8192']
- ]
+ ['8192', '8192'],
+ ],
},
{
xtype: 'proxmoxcheckbox',
name: 'force',
fieldLabel: gettext('Overwrite existing file'),
- }
- ]
- }
+ },
+ ],
+ },
};
me.add_boolean_row('dkim_sign_all_mail', gettext('Sign all Outgoing Mail'));
xtype: 'proxmoxButton',
disabled: true,
handler: function() { me.run_editor(); },
- selModel: me.selModel
+ selModel: me.selModel,
}],
url: '/api2/json' + baseurl,
editorConfig: {
url: '/api2/extjs' + baseurl,
- onlineHelp: 'pmgconfig_mailproxy_dkim'
+ onlineHelp: 'pmgconfig_mailproxy_dkim',
},
interval: 5000,
cwidth1: 200,
listeners: {
- itemdblclick: me.run_editor
- }
+ itemdblclick: me.run_editor,
+ },
});
me.callParent();
me.on('activate', me.rstore.startUpdate);
me.on('destroy', me.rstore.stopUpdate);
me.on('deactivate', me.rstore.stopUpdate);
- }
+ },
});
width: 300,
title: gettext('Dashboard Options'),
layout: {
- type: 'auto'
+ type: 'auto',
},
items: [{
xtype: 'form',
minValue: 1,
maxValue: 24,
value: viewModel.get('hours'),
- fieldLabel: gettext('Hours to show')
+ fieldLabel: gettext('Hours to show'),
}],
buttons: [{
text: gettext('Save'),
var hours = win.down('#hours').getValue();
me.setHours(hours, true);
win.close();
- }
- }]
- }]
+ },
+ }],
+ }],
}).show();
},
cpu += item.data.cpu || 0;
var memory = item.data.memory || { used: 0, total: 1 };
- mem += (memory.used/memory.total);
+ mem += memory.used/memory.total;
var rootfs = item.data.rootfs || { used: 0, total: 1 };
- hd += (rootfs.used/rootfs.total);
+ hd += rootfs.used/rootfs.total;
if (item.data.conn_error && count > 1) {
count--;
errors.push({
name: item.data.name,
- msg: item.data.conn_error
+ msg: item.data.conn_error,
});
}
});
var sp = Ext.state.Manager.getProvider();
var hours = sp.get('dashboard-hours') || 12;
me.setHours(hours, false);
- }
+ },
},
viewModel: {
error_shown: false,
'bytes_in': 0,
'bytes_out': 0,
- 'avg_ptime': 0.0
+ 'avg_ptime': 0.0,
},
stores: {
proxy: {
extraParams: { list_single_node: 1 },
type: 'proxmox',
- url: '/api2/json/config/cluster/status'
+ url: '/api2/json/config/cluster/status',
},
listeners: {
- load: 'updateClusterStats'
- }
+ load: 'updateClusterStats',
+ },
},
recentmails: {
storeid: 'dash-recent',
url: '/api2/json/statistics/recent',
extraParams: {
hours: '{hours}',
- timespan: '{timespan}'
- }
+ timespan: '{timespan}',
+ },
},
fields: [
{
type: 'number', name: 'count',
- convert: PMG.Utils.convert_field_to_per_min
+ convert: PMG.Utils.convert_field_to_per_min,
},
{
type: 'number', name: 'count_in',
- convert: PMG.Utils.convert_field_to_per_min
+ convert: PMG.Utils.convert_field_to_per_min,
},
{
type: 'number', name: 'count_out',
- convert: PMG.Utils.convert_field_to_per_min
+ convert: PMG.Utils.convert_field_to_per_min,
},
{
type: 'number', name: 'spam',
- convert: PMG.Utils.convert_field_to_per_min
+ convert: PMG.Utils.convert_field_to_per_min,
},
{
type: 'number', name: 'spam_in',
- convert: PMG.Utils.convert_field_to_per_min
+ convert: PMG.Utils.convert_field_to_per_min,
},
{
type: 'number', name: 'spam_out',
- convert: PMG.Utils.convert_field_to_per_min
+ convert: PMG.Utils.convert_field_to_per_min,
},
{
type: 'number', name: 'virus',
- convert: PMG.Utils.convert_field_to_per_min
+ convert: PMG.Utils.convert_field_to_per_min,
},
{
type: 'number', name: 'virus_in',
- convert: PMG.Utils.convert_field_to_per_min
+ convert: PMG.Utils.convert_field_to_per_min,
},
{ type: 'integer', name: 'virus_out' },
{ type: 'integer', name: 'bytes_in' },
{ type: 'integer', name: 'bytes_out' },
{ type: 'number', name: 'ptimesum' },
- { type: 'date', dateFormat: 'timestamp', name: 'time' }
+ { type: 'date', dateFormat: 'timestamp', name: 'time' },
],
listeners: {
- load: 'updateMailStats'
- }
+ load: 'updateMailStats',
+ },
},
receivers: {
storeid: 'dash-receivers',
type: 'proxmox',
url: '/api2/json/statistics/recentreceivers',
extraParams: {
- hours: '{hours}'
- }
+ hours: '{hours}',
+ },
},
fields: [
{ type: 'integer', name: 'count' },
- { type: 'string', name: 'receiver' }
- ]
- }
- }
+ { type: 'string', name: 'receiver' },
+ ],
+ },
+ },
},
bind: {
title: gettext('Dashboard') + ' (' +
- Ext.String.format(gettext('{0} hours'), '{hours}') + ')'
+ Ext.String.format(gettext('{0} hours'), '{hours}') + ')',
},
layout: {
- type: 'column'
+ type: 'column',
},
border: false,
defaults: {
columnWidth: 0.5,
xtype: 'panel',
- margin: '0 20 20 0'
+ margin: '0 20 20 0',
},
tools: [
{
type: 'gear',
- handler: 'openDashboardOptions'
- }
+ handler: 'openDashboardOptions',
+ },
],
scrollable: true,
title: gettext('E-Mail Volume'),
layout: {
type: 'vbox',
- align: 'stretch'
+ align: 'stretch',
},
defaults: {
xtype: 'pmgMiniGraph',
bind: {
- store: '{recentmails}'
- }
+ store: '{recentmails}',
+ },
},
items: [
{
fields: ['count'],
- fieldTitles: [ gettext('Mails / min') ],
+ fieldTitles: [gettext('Mails / min')],
seriesConfig: {
- colors: [ '#00617F' ],
+ colors: ['#00617F'],
style: {
opacity: 0.60,
- lineWidth: 1
+ lineWidth: 1,
},
highlightCfg: {
opacity: 1,
- scaling: 1
- }
- }
+ scaling: 1,
+ },
+ },
},
{
fields: ['spam'],
- fieldTitles: [ gettext('Spam / min') ],
+ fieldTitles: [gettext('Spam / min')],
seriesConfig: {
- colors: [ '#E67300' ],
+ colors: ['#E67300'],
style: {
opacity: 0.60,
- lineWidth: 1
+ lineWidth: 1,
},
highlightCfg: {
opacity: 1,
- scaling: 1
- }
- }
- }
- ]
+ scaling: 1,
+ },
+ },
+ },
+ ],
},
{
xtype: 'container',
height: 300,
layout: {
type: 'vbox',
- align: 'stretch'
+ align: 'stretch',
},
items: [
{
data: {
'bytes_in': '{bytes_in}',
'bytes_out': '{bytes_out}',
- 'avg_ptime': '{avg_ptime}'
- }
- }
+ 'avg_ptime': '{avg_ptime}',
+ },
+ },
},
{
iconCls: 'fa fa-ticket',
reference: 'subscription',
xtype: 'pmgSubscriptionInfo',
margin: '10 0 0 0',
- height: 110
- }
- ]
+ height: 110,
+ },
+ ],
},
{
height: 250,
bodyPadding: '0 20 0 20',
layout: {
type: 'hbox',
- align: 'center'
+ align: 'center',
},
defaults: {
xtype: 'proxmoxGauge',
spriteFontSize: '20px',
- flex: 1
+ flex: 1,
},
items: [
{
title: gettext('CPU'),
- reference: 'cpu'
+ reference: 'cpu',
},
{
title: gettext('Memory'),
- reference: 'mem'
+ reference: 'mem',
},
{
title: gettext('Storage'),
- reference: 'hd'
- }
- ]
+ reference: 'hd',
+ },
+ ],
},
{
height: 250,
layout: {
type: 'vbox',
pack: 'center',
- align: 'stretch'
+ align: 'stretch',
},
items: [{
xtype: 'grid',
bind: {
- store: '{receivers}'
+ store: '{receivers}',
},
emptyText: gettext('No data in database'),
columnLines: false,
rowLines: false,
viewConfig: {
- stripeRows: false
+ stripeRows: false,
},
columns: [
{
dataIndex: 'receiver',
flex: 1,
- text: gettext('Receiver')
+ text: gettext('Receiver'),
},
{
dataIndex: 'count',
align: 'right',
- text: gettext('Count')
- }
- ]
- }]
- }
- ]
+ text: gettext('Count'),
+ },
+ ],
+ }],
+ },
+ ],
});
title: gettext('Statistics') + ': ' + gettext('Domain'),
- tbar: [ { xtype: 'pmgStatTimeSelector' } ],
+ tbar: [{ xtype: 'pmgStatTimeSelector' }],
layout: 'fit',
border: false,
{ type: 'integer', name: 'viruscount_in' },
{ type: 'integer', name: 'viruscount_out' },
{ type: 'number', name: 'bytes_in' },
- { type: 'number', name: 'bytes_out' }
+ { type: 'number', name: 'bytes_out' },
];
var store = Ext.create('PMG.data.StatStore', {
staturl: '/api2/json/statistics/domains',
- fields: fields
+ fields: fields,
});
var store_in = Ext.create('Ext.data.ArrayStore', {
fields: fields,
- filters: [ function(item) { return item.data.count_in > 0; } ]
+ filters: [function(item) { return item.data.count_in > 0; }],
});
var store_out = Ext.create('Ext.data.ArrayStore', {
fields: fields,
- filters: [ function(item) { return item.data.count_out > 0; } ]
+ filters: [function(item) { return item.data.count_out > 0; }],
});
store.on('load', function(s, records, successful) {
store: store_in,
emptyText: gettext('No data in database'),
viewConfig: {
- deferEmptyText: false
+ deferEmptyText: false,
},
columns: [
{
gettext('Receiver') + ')',
flex: 1,
renderer: render_domain,
- dataIndex: 'domain'
+ dataIndex: 'domain',
},
{
text: gettext('Traffic') + ' (MB)',
dataIndex: 'bytes_in',
renderer: function(v) {
return Ext.Number.toFixed(v/(1024*1024), 2);
- }
+ },
},
{
text: gettext('Count'),
columns: [
{
text: gettext('Mail'),
- dataIndex: 'count_in'
+ dataIndex: 'count_in',
},
{
header: gettext('Virus'),
- dataIndex: 'viruscount_in'
+ dataIndex: 'viruscount_in',
},
{
header: gettext('Spam'),
- dataIndex: 'spamcount_in'
- }
- ]
- }
- ]
+ dataIndex: 'spamcount_in',
+ },
+ ],
+ },
+ ],
},
{
xtype: 'grid',
store: store_out,
emptyText: gettext('No data in database'),
viewConfig: {
- deferEmptyText: false
+ deferEmptyText: false,
},
columns: [
{
gettext('Receiver') + ')',
flex: 1,
renderer: render_domain,
- dataIndex: 'domain'
+ dataIndex: 'domain',
},
{
text: gettext('Traffic') + ' (MB)',
dataIndex: 'bytes_out',
renderer: function(v) {
return Ext.Number.toFixed(v/(1024*1024), 2);
- }
+ },
},
{
text: gettext('Count'),
columns: [
{
text: gettext('Mail'),
- dataIndex: 'count_out'
+ dataIndex: 'count_out',
},
{
header: gettext('Virus'),
- dataIndex: 'viruscount_out'
- }
- ]
- }
- ]
- }
- ]
+ dataIndex: 'viruscount_out',
+ },
+ ],
+ },
+ ],
+ },
+ ],
}];
me.callParent();
Proxmox.Utils.monStoreErrors(me, store);
me.on('destroy', store.destroy, store);
- }
+ },
});
var protocol = this.lookupReference('protocol').getValue();
var ssl = this.lookupReference('ssl').getValue();
- var port_field = this.lookupReference('port');
+ var port_field = this.lookupReference('port');
if (protocol === 'pop3') {
port_field.setValue(ssl ? 995 : 110);
} else if (protocol === 'imap') {
port_field.setValue(ssl ? 993 : 143);
}
- }
+ },
},
items: {
xtype: 'textfield',
name: 'server',
fieldLabel: gettext('Server'),
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'proxmoxKVComboBox',
reference: 'protocol',
value: 'pop3',
listeners: { change: 'onProtocolChange' },
- comboItems: [['pop3', 'pop3'], ['imap', 'imap']]
+ comboItems: [['pop3', 'pop3'], ['imap', 'imap']],
},
{
xtype: 'proxmoxintegerfield',
value: 110,
minValue: 1,
maxValue: 65535,
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'textfield',
name: 'user',
fieldLabel: gettext('Username'),
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'textfield',
name: 'pass',
inputType: 'password',
fieldLabel: gettext('Password'),
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'textfield',
name: 'target',
fieldLabel: gettext('Deliver to'),
- allowBlank: false
- }
+ allowBlank: false,
+ },
],
column2: [
fieldLabel: gettext('Enabled'),
name: 'enable',
uncheckedValue: 0,
- checked: true
+ checked: true,
},
{
xtype: 'proxmoxintegerfield',
value: 1,
minValue: 1,
maxValue: 24*12*7,
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'proxmoxcheckbox',
name: 'ssl',
reference: 'ssl',
uncheckedValue: 0,
- checked: false
+ checked: false,
},
{
xtype: 'proxmoxcheckbox',
fieldLabel: gettext('Keep old mails'),
name: 'keep',
uncheckedValue: 0,
- checked: false
- }
- ]
- }
+ checked: false,
+ },
+ ],
+ },
});
'id', 'protocol', 'port', 'server', 'user', 'pass', 'target',
'ssl', 'keep',
{ type: 'integer', name: 'interval' },
- { type: 'boolean', name: 'enable' }
+ { type: 'boolean', name: 'enable' },
],
proxy: {
type: 'proxmox',
- url: "/api2/json/config/fetchmail"
+ url: "/api2/json/config/fetchmail",
},
- idProperty: 'id'
+ idProperty: 'id',
});
Ext.define('PMG.FetchmailView', {
store: {
autoDestroy: true,
autoLoad: true,
- model: 'pmg-fetchmail-users'
+ model: 'pmg-fetchmail-users',
},
controller: {
var win = Ext.create('PMG.FetchmailEdit', {
url: view.baseurl,
- method: 'POST'
+ method: 'POST',
});
win.on('destroy', function() { view.store.load(); });
win.show();
userid: rec.data.id,
url: view.baseurl + '/' + rec.data.id,
method: 'PUT',
- autoLoad: true
+ autoLoad: true,
});
win.on('destroy', function() { view.store.load(); });
win.show();
onAfterRemove: function(btn, res) {
var view = this.getView();
view.store.load();
- }
+ },
},
tbar: [
{
text: gettext('Add'),
reference: 'addBtn',
- handler: 'onAdd'
+ handler: 'onAdd',
},
{
xtype: 'proxmoxButton',
text: gettext('Edit'),
disabled: true,
- handler: 'onEdit'
+ handler: 'onEdit',
},
{
xtype: 'proxmoxStdRemoveButton',
baseurl: '/config/fetchmail',
reference: 'removeBtn',
callback: 'onAfterRemove',
- waitMsgTarget: true
- }
+ waitMsgTarget: true,
+ },
],
listeners: {
//scope: 'controller',
- itemdblclick: 'onEdit'
+ itemdblclick: 'onEdit',
},
columns: [
header: gettext('Server'),
flex: 1,
renderer: Ext.String.htmlEncode,
- dataIndex: 'server'
+ dataIndex: 'server',
},
{
header: gettext('Protocol'),
- dataIndex: 'protocol'
+ dataIndex: 'protocol',
},
{
header: gettext('User name'),
flex: 1,
renderer: Ext.String.htmlEncode,
- dataIndex: 'user'
+ dataIndex: 'user',
},
{
header: gettext('Deliver to'),
flex: 1,
renderer: Ext.String.htmlEncode,
- dataIndex: 'target'
+ dataIndex: 'target',
},
{
header: gettext('Enabled'),
sortable: true,
renderer: Proxmox.Utils.format_boolean,
- dataIndex: 'enable'
+ dataIndex: 'enable',
},
{
header: gettext('Interval'),
- dataIndex: 'interval'
- }
- ]
+ dataIndex: 'interval',
+ },
+ ],
});
Ext.define('PMG.FilterProxy', {
extend: 'Proxmox.RestProxy',
- alias : 'proxy.pmgfilterproxy',
+ alias: 'proxy.pmgfilterproxy',
filterId: undefined, // 'x-gridfilter-XXXXX'
}
}
return params;
- }
+ },
});
xtype: 'pmgGeneralMailStatistics',
scrollable: true,
-
+
bodyPadding: '10 0 0 0',
border: false,
defaults: {
width: 700,
- padding: '0 0 10 10'
+ padding: '0 0 10 10',
},
layout: 'column',
title: gettext('Statistics') + ': ' + gettext('Mail'),
- tbar: [ { xtype: 'pmgStatTimeSelector' } ],
+ tbar: [{ xtype: 'pmgStatTimeSelector' }],
getInData: function(data) {
var res = [];
res.push({
name: gettext("Incoming Mails"),
value: data.count_in,
- percentage: 1
+ percentage: 1,
});
-
+
res.push({
name: gettext("Junk Mails"),
value: data.junk_in,
- percentage: data.junk_in/data.count_in
+ percentage: data.junk_in/data.count_in,
});
-
+
res.push({
name: gettext("Greylisted Mails"),
value: data.glcount,
- percentage: data.glcount/data.count_in
+ percentage: data.glcount/data.count_in,
});
res.push({
name: gettext("Spam Mails"),
value: data.spamcount_in,
- percentage: data.spamcount_in/data.count_in
+ percentage: data.spamcount_in/data.count_in,
});
-
+
res.push({
name: gettext("SPF rejects"),
value: data.spfcount,
- percentage: data.spfcount/data.count_in
+ percentage: data.spfcount/data.count_in,
});
res.push({
name: gettext("Bounces"),
value: data.bounces_in,
- percentage: data.bounces_in/data.count_in
+ percentage: data.bounces_in/data.count_in,
});
res.push({
name: gettext("Virus Mails"),
value: data.viruscount_in,
- percentage: data.viruscount_in/data.count_in
+ percentage: data.viruscount_in/data.count_in,
});
return res;
},
-
+
getOutData: function(data) {
var res = [];
res.push({
name: gettext("Outgoing Mails"),
value: data.count_out,
- percentage: 1
+ percentage: 1,
});
-
+
res.push({
name: gettext("Bounces"),
value: data.bounces_out,
- percentage: data.bounces_out/data.count_out
+ percentage: data.bounces_out/data.count_out,
});
res.push({
name: gettext("Virus Mails"),
value: data.viruscount_out,
- percentage: data.viruscount_out/data.count_out
+ percentage: data.viruscount_out/data.count_out,
});
return res;
getGeneralData: function(data) {
var res = [];
-
+
res.push({
name: gettext("Total Mails"),
value: data.count,
- percentage: 1
+ percentage: 1,
});
-
+
res.push({
name: gettext("Incoming Mails"),
value: data.count_in,
- percentage: data.count_in/data.count
+ percentage: data.count_in/data.count,
});
res.push({
name: gettext("Outgoing Mails"),
value: data.count_out,
- percentage: data.count_out/data.count
+ percentage: data.count_out/data.count,
});
-
+
res.push({
name: gettext("Virus Outbreaks"),
- value: data.viruscount_out
+ value: data.viruscount_out,
});
-
+
res.push({
name: gettext("Avg. Mail Processing Time"),
value: Ext.String.format(gettext("{0} seconds"),
- Ext.Number.toFixed(data.avptime, 2))
+ Ext.Number.toFixed(data.avptime, 2)),
});
res.push({
name: gettext("Incoming Mail Traffic"),
- value: Ext.Number.toFixed(data.bytes_in/(1024*1024), 2) + ' MiB'
+ value: Ext.Number.toFixed(data.bytes_in/(1024*1024), 2) + ' MiB',
});
res.push({
name: gettext("Outgoing Mail Traffic"),
- value: Ext.Number.toFixed(data.bytes_out/(1024*1024), 2) + ' MiB'
+ value: Ext.Number.toFixed(data.bytes_out/(1024*1024), 2) + ' MiB',
});
return res;
},
{ type: 'integer', name: 'viruscount_out' },
{ type: 'integer', name: 'bounces_in' },
{ type: 'integer', name: 'bounces_out' },
- { type: 'date', dateFormat: 'timestamp', name: 'time' }
- ]
+ { type: 'date', dateFormat: 'timestamp', name: 'time' },
+ ],
});
-
+
var totalgrid = Ext.createWidget('pmgMailStatGrid', {
dockedItems: [
{
fieldTitles: [
gettext('Total Mail Count'),
gettext('Incoming Mails'), gettext('Outgoing Mails')],
- store: countstore
- }
- ]
+ store: countstore,
+ },
+ ],
});
-
+
var ingrid = Ext.createWidget('pmgMailStatGrid', {
dockedItems: [
{
fieldTitles: [
gettext('Incoming Mails'), gettext('Junk Mails'),
gettext('Virus Mails'), gettext('Bounces')],
- store: countstore
- }
- ]
+ store: countstore,
+ },
+ ],
});
-
+
var outgrid = Ext.createWidget('pmgMailStatGrid', {
dockedItems: [
{
fieldTitles: [
gettext('Outgoing Mails'),
gettext('Virus Mails'), gettext('Bounces')],
- store: countstore
- }
- ]
+ store: countstore,
+ },
+ ],
});
var infostore = Ext.create('PMG.data.StatStore', {
staturl: "/api2/json/statistics/mail",
- fields: [ 'name', 'value', 'percentage' ],
+ fields: ['name', 'value', 'percentage'],
listeners: {
load: function(store, records, success) {
if (!success || records.length <= 0) {
ingrid.store.setData(data);
data = me.getOutData(records[0].data);
outgrid.store.setData(data);
- }
- }
+ },
+ },
});
- me.items = [ totalgrid, ingrid, outgrid ];
-
+ me.items = [totalgrid, ingrid, outgrid];
+
me.callParent();
me.on('destroy', infostore.destroy, infostore);
me.on('destroy', countstore.destroy, countstore);
- }
+ },
});
title: gettext('Count'),
position: 'left',
grid: true,
- minimum: 0
+ minimum: 0,
}, {
type: 'category',
position: 'bottom',
- fields: ['index']
+ fields: ['index'],
}],
initComponent: function() {
tooltip.setHtml('Time: ' + start.toString() +
' - ' + end.toString() + '<br>' +
'Count: ' + record.get(item.field));
- }
- }
+ },
+ },
});
- }
+ },
});
Ext.define('PMG.HourlyMailDistribution', {
bodyPadding: '10 0 0 0',
defaults: {
width: 700,
- padding: '0 0 10 10'
+ padding: '0 0 10 10',
},
layout: 'column',
title: gettext('Statistics') + ': ' + gettext('Hourly Distribution'),
- tbar: [ { xtype: 'pmgStatTimeSelector' } ],
+ tbar: [{ xtype: 'pmgStatTimeSelector' }],
initComponent: function() {
var me = this;
{ type: 'integer', name: 'viruscount_in' },
{ type: 'integer', name: 'viruscount_ou' },
{ type: 'integer', name: 'bounces_in' },
- { type: 'integer', name: 'bounces_out' }
- ]
+ { type: 'integer', name: 'bounces_out' },
+ ],
});
me.items = [
xtype: 'pmgMailDistChart',
title: gettext('Incoming Mails'),
field: 'count_in',
- store: store
+ store: store,
},
{
xtype: 'pmgMailDistChart',
title: gettext('Outgoing Mails'),
field: 'count_out',
- store: store
- }
+ store: store,
+ },
];
me.callParent();
me.on('destroy', store.destroy, store);
- }
+ },
});
*/
Ext.define('pmg-ldap-config', {
extend: 'Ext.data.Model',
- fields: [ 'profile', 'server1', 'server2', 'comment',
+ fields: ['profile', 'server1', 'server2', 'comment',
'mode', 'binddn', 'bindpw', 'basedn', 'groupbasedn',
'filter', 'accountattr', 'mailattr',
- { name: 'port', type: 'integer' },
- { name: 'gcount', type: 'integer' },
- { name: 'mcount', type: 'integer' },
- { name: 'ucount', type: 'integer' },
- { name: 'disable', type: 'boolean' }
+ { name: 'port', type: 'integer' },
+ { name: 'gcount', type: 'integer' },
+ { name: 'mcount', type: 'integer' },
+ { name: 'ucount', type: 'integer' },
+ { name: 'disable', type: 'boolean' },
],
proxy: {
type: 'proxmox',
- url: "/api2/json/config/ldap"
+ url: "/api2/json/config/ldap",
},
- idProperty: 'profile'
+ idProperty: 'profile',
});
Ext.define('PMG.LDAPInputPanel', {
return values;
},
- initComponent : function() {
+ initComponent: function() {
var me = this;
me.column1 = [
value: me.profileId || '',
name: 'profile',
vtype: 'StorageId',
- allowBlank: false
+ allowBlank: false,
},
{
xtype: 'proxmoxKVComboBox',
comboItems: [
['ldap', PMG.Utils.format_ldap_protocol('ldap')],
['ldaps', PMG.Utils.format_ldap_protocol('ldaps')],
- ['ldap+starttls', PMG.Utils.format_ldap_protocol('ldap+starttls')]
+ ['ldap+starttls', PMG.Utils.format_ldap_protocol('ldap+starttls')],
],
value: 'ldap',
fieldLabel: gettext('Protocol'),
listeners: {
change: function(cb, value) {
- var isldap = (value === 'ldap');
+ var isldap = value === 'ldap';
me.down('field[name=verify]').setVisible(!isldap);
- }
- }
+ },
+ },
},
{
xtype: 'proxmoxcheckbox',
hidden: true,
uncheckedValue: 0,
value: 1,
- checked: 1
+ checked: 1,
},
{
xtype: 'textfield',
fieldLabel: gettext('Server'),
allowBlank: false,
vtype: 'DnsOrIp',
- name: 'server1'
+ name: 'server1',
},
{
xtype: 'proxmoxtextfield',
fieldLabel: gettext('Server'),
allowBlank: true,
- deleteEmpty: me.isCreate ? false : true,
+ deleteEmpty: !me.isCreate,
vtype: 'DnsOrIp',
- name: 'server2'
+ name: 'server2',
},
{
xtype: 'proxmoxintegerfield',
name: 'port',
emptyText: gettext('Default'),
- deleteEmpty: me.isCreate ? false : true,
+ deleteEmpty: !me.isCreate,
minValue: 1,
maxValue: 65535,
- fieldLabel: gettext('Port')
+ fieldLabel: gettext('Port'),
},
{
xtype: 'textfield',
name: 'binddn',
allowBlank: true,
- fieldLabel: gettext('User name')
+ fieldLabel: gettext('User name'),
},
{
xtype: 'textfield',
inputType: 'password',
allowBlank: true,
name: 'bindpw',
- fieldLabel: gettext('Password')
- }
+ fieldLabel: gettext('Password'),
+ },
];
me.column2 = [
name: 'enable',
checked: true,
uncheckedValue: 0,
- fieldLabel: gettext('Enable')
+ fieldLabel: gettext('Enable'),
},
{
xtype: 'proxmoxtextfield',
allowBlank: true,
- deleteEmpty: me.isCreate ? false : true,
+ deleteEmpty: !me.isCreate,
name: 'basedn',
- fieldLabel: gettext('Base DN')
+ fieldLabel: gettext('Base DN'),
},
{
xtype: 'proxmoxtextfield',
allowBlank: true,
- deleteEmpty: me.isCreate ? false : true,
+ deleteEmpty: !me.isCreate,
name: 'groupbasedn',
- fieldLabel: gettext('Base DN for Groups')
+ fieldLabel: gettext('Base DN for Groups'),
},
{
xtype: 'proxmoxtextfield',
allowBlank: true,
- deleteEmpty: me.isCreate ? false : true,
+ deleteEmpty: !me.isCreate,
name: 'mailattr',
- fieldLabel: gettext('EMail attribute name(s)')
+ fieldLabel: gettext('EMail attribute name(s)'),
},
{
xtype: 'proxmoxtextfield',
allowBlank: true,
- deleteEmpty: me.isCreate ? false : true,
+ deleteEmpty: !me.isCreate,
name: 'accountattr',
- fieldLabel: gettext('Account attribute name')
+ fieldLabel: gettext('Account attribute name'),
},
{
xtype: 'proxmoxtextfield',
allowBlank: true,
- deleteEmpty: me.isCreate ? false : true,
+ deleteEmpty: !me.isCreate,
name: 'filter',
- fieldLabel: gettext('LDAP filter')
+ fieldLabel: gettext('LDAP filter'),
},
{
xtype: 'proxmoxtextfield',
allowBlank: true,
- deleteEmpty: me.isCreate ? false : true,
+ deleteEmpty: !me.isCreate,
name: 'groupclass',
- fieldLabel: gettext('Group objectclass')
- }
+ fieldLabel: gettext('Group objectclass'),
+ },
];
me.columnB = [
xtype: 'textfield',
fieldLabel: gettext('Comment'),
allowBlank: true,
- name: 'comment'
- }
+ name: 'comment',
+ },
];
me.callParent();
- }
+ },
});
Ext.define('PMG.LDAPEdit', {
subject: 'LDAP Profile',
isAdd: true,
- initComponent : function() {
+ initComponent: function() {
var me = this;
- me.isCreate = me.profileId ? false : true;
+ me.isCreate = !me.profileId;
if (me.isCreate) {
me.url = '/api2/extjs/config/ldap';
var ipanel = Ext.create('PMG.LDAPInputPanel', {
isCreate: me.isCreate,
- profileId: me.profileId
+ profileId: me.profileId,
});
- me.items = [ ipanel ];
+ me.items = [ipanel];
me.fieldDefaults = {
- labelWidth: 150
+ labelWidth: 150,
};
me.callParent();
if (!me.isCreate) {
me.load({
- success: function(response, options) {
+ success: function(response, options) {
var values = response.result.data;
values.enable = values.disable ? 0 : 1;
values.verify = !!values.verify;
ipanel.setValues(values);
- }
+ },
});
}
- }
+ },
});
Ext.define('PMG.LDAPUserGrid', {
emptyText: gettext('No data in database'),
store: {
autoDestroy: true,
- fields: [ 'dn', 'account', 'pmail' ],
+ fields: ['dn', 'account', 'pmail'],
proxy: { type: 'proxmox' },
- sorters: [ 'dn' ]
+ sorters: ['dn'],
},
columns: [
{
text: 'DN',
dataIndex: 'dn',
- flex: 1
+ flex: 1,
},
{
text: gettext('Account'),
dataIndex: 'account',
- flex: 1
+ flex: 1,
},
{
text: gettext('Primary E-Mail'),
dataIndex: 'pmail',
- flex: 1
- }
+ flex: 1,
+ },
],
initComponent: function() {
me.getStore().getProxy().setUrl(me.url);
me.getStore().load();
}
- }
+ },
});
Ext.define('PMG.LDAPConfig', {
items: [{
xtype: 'pmgLDAPUserGrid',
border: false,
- url: '/api2/json/config/ldap/' + name + '/groups/' + encodeURIComponent(record.data.gid)
- }]
+ url: '/api2/json/config/ldap/' + name + '/groups/' + encodeURIComponent(record.data.gid),
+ }],
}).show();
},
field: ['email', 'primary'],
proxy: {
type: 'proxmox',
- url: '/api2/json/config/ldap/' + name + '/users/' + encodeURIComponent(record.data.pmail)
- }
+ url: '/api2/json/config/ldap/' + name + '/users/' + encodeURIComponent(record.data.pmail),
+ },
},
columns: [
- { dataIndex: 'email', text: gettext('E-Mail address'), flex: 1 }
- ]
- }]
+ { dataIndex: 'email', text: gettext('E-Mail address'), flex: 1 },
+ ],
+ }],
}).show();
},
control: {
'grid[reference=grid]': {
selectionchange: 'showInfo',
- load: 'reload'
+ load: 'reload',
},
'grid[reference=groupgrid]': {
- itemdblclick: 'openUserList'
+ itemdblclick: 'openUserList',
},
'grid[reference=usergrid]': {
- itemdblclick: 'openUserMails'
- }
- }
+ itemdblclick: 'openUserMails',
+ },
+ },
},
viewModel: {
data: {
name: '',
- selected: false
- }
+ selected: false,
+ },
},
layout: 'border',
region: 'center',
reference: 'grid',
xtype: 'pmgLDAPConfigGrid',
- border: false
+ border: false,
},
{
xtype: 'tabpanel',
split: true,
region: 'south',
bind: {
- hidden: '{!selected}'
+ hidden: '{!selected}',
},
items: [
{
xtype: 'proxmoxButton',
text: gettext('Show Users'),
handler: 'showUsers',
- disabled: true
+ disabled: true,
}],
store: {
fields: ['dn', 'gid'],
proxy: { type: 'proxmox' },
- sorters: [ 'dn' ]
+ sorters: ['dn'],
},
bind: {
- title: Ext.String.format(gettext("Groups of '{0}'"), '{name}')
+ title: Ext.String.format(gettext("Groups of '{0}'"), '{name}'),
},
columns: [
{
text: 'DN',
dataIndex: 'dn',
- flex: 1
- }
- ]
+ flex: 1,
+ },
+ ],
},
{
xtype: 'pmgLDAPUserGrid',
xtype: 'proxmoxButton',
text: gettext('Show E-Mail addresses'),
handler: 'showEmails',
- disabled: true
+ disabled: true,
}],
bind: {
- title: Ext.String.format(gettext("Users of '{0}'"), '{name}')
- }
- }
- ]
- }
- ]
+ title: Ext.String.format(gettext("Users of '{0}'"), '{name}'),
+ },
+ },
+ ],
+ },
+ ],
});
}
var win = Ext.createWidget('pmgLDAPEdit', {
- profileId: rec.data.profile
+ profileId: rec.data.profile,
});
win.on('destroy', me.reload, me);
win.load();
callback: function() {
me.reload();
},
- failure: function (response, opts) {
+ failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
},
init: function(view) {
var me = this;
Proxmox.Utils.monStoreErrors(view, view.getStore(), true);
- }
+ },
},
store: {
model: 'pmg-ldap-config',
sorters: [{
property: 'profile',
- order: 'DESC'
- }]
+ order: 'DESC',
+ }],
},
tbar: [
xtype: 'proxmoxButton',
text: gettext('Edit'),
disabled: true,
- handler: 'run_editor'
+ handler: 'run_editor',
},
{
text: gettext('Create'),
- handler: 'newProfile'
+ handler: 'newProfile',
},
{
xtype: 'proxmoxStdRemoveButton',
baseurl: '/config/ldap',
- callback: 'reload'
+ callback: 'reload',
},
{
xtype: 'proxmoxButton',
return !rec.data.disable;
},
disabled: true,
- handler: 'sync'
- }
+ handler: 'sync',
+ },
],
listeners: {
itemdblclick: 'run_editor',
- activate: 'reload'
+ activate: 'reload',
},
columns: [
header: gettext('Profile Name'),
sortable: true,
width: 120,
- dataIndex: 'profile'
+ dataIndex: 'profile',
},
{
header: gettext('Protocol'),
sortable: true,
dataIndex: 'mode',
- renderer: PMG.Utils.format_ldap_protocol
+ renderer: PMG.Utils.format_ldap_protocol,
},
{
header: gettext('Server'),
return value + '<br>' + rec.data.server2;
}
return value;
- }
+ },
},
{
header: gettext('Enabled'),
width: 80,
sortable: true,
dataIndex: 'disable',
- renderer: Proxmox.Utils.format_neg_boolean
+ renderer: Proxmox.Utils.format_neg_boolean,
},
{
header: gettext('Comment'),
sortable: false,
renderer: Ext.String.htmlEncode,
dataIndex: 'comment',
- flex: 1
+ flex: 1,
},
{
header: gettext('Accounts'),
width: 80,
sortable: true,
- dataIndex: 'ucount'
+ dataIndex: 'ucount',
},
{
header: gettext('Addresses'),
width: 80,
sortable: true,
- dataIndex: 'mcount'
+ dataIndex: 'mcount',
},
{
header: gettext('Groups'),
width: 80,
sortable: true,
- dataIndex: 'gcount'
- }
- ]
+ dataIndex: 'gcount',
+ },
+ ],
});
groupField.setDisabled(value !== 'group');
groupField.setVisible(value === 'group');
var profileField = this.lookupReference('profileField');
- var enabled = ((value != 'any') && (value != 'none'));
+ var enabled = (value != 'any') && (value != 'none');
profileField.setDisabled(!enabled);
profileField.setVisible(enabled);
},
control: {
'field[name=mode]': {
- change: 'changeMode'
+ change: 'changeMode',
},
'field[name=profile]': {
- change: 'changeProfile'
- }
- }
+ change: 'changeProfile',
+ },
+ },
},
items: [
name: 'mode',
value: 'group',
comboItems: [
- [ 'group', gettext('Group member') ],
- [ 'profile-any', gettext('Existing LDAP address')],
- [ 'any', gettext('Existing LDAP address') +
- ', any profile' ],
- [ 'profile-none', gettext('Unknown LDAP address')],
- [ 'none', gettext('Unknown LDAP address') +
- ', any profile' ]
+ ['group', gettext('Group member')],
+ ['profile-any', gettext('Existing LDAP address')],
+ ['any', gettext('Existing LDAP address') +
+ ', any profile'],
+ ['profile-none', gettext('Unknown LDAP address')],
+ ['none', gettext('Unknown LDAP address') +
+ ', any profile'],
],
- fieldLabel: gettext("Match")
+ fieldLabel: gettext("Match"),
},
{
xtype: 'pmgLDAPProfileSelector',
name: 'profile',
reference: 'profileField',
- fieldLabel: gettext("Profile")
+ fieldLabel: gettext("Profile"),
},
{
xtype: 'pmgLDAPGroupSelector',
name: 'group',
reference: 'groupField',
- fieldLabel: gettext("Group")
- }
- ]
+ fieldLabel: gettext("Group"),
+ },
+ ],
});
Ext.define('PMG.LDAPGroupEditor', {
width: 500,
- items: [{ xtype: 'pmgLDAPGroupInputPanel' }]
+ items: [{ xtype: 'pmgLDAPGroupInputPanel' }],
});
alias: 'widget.pmgLDAPGroupSelector',
profile: undefined,
-
+
queryMode: 'local',
store: {
- fields: [ 'dn' ],
+ fields: ['dn'],
filterOnLoad: true,
sorters: [
{
- property : 'dn',
- direction: 'ASC'
- }
- ]
+ property: 'dn',
+ direction: 'ASC',
+ },
+ ],
},
valueField: 'dn',
me.store.setProxy({
type: 'proxmox',
- url: '/api2/json/config/ldap/' + me.profile + '/groups'
+ url: '/api2/json/config/ldap/' + me.profile + '/groups',
});
me.store.load();
},
-
+
initComponent: function() {
var me = this;
if (me.profile !== undefined) {
me.setProfile(me.profile, true);
}
- }
+ },
});
alias: 'widget.pmgLDAPProfileSelector',
store: {
- fields: [ 'profile', 'disable', 'comment' ],
+ fields: ['profile', 'disable', 'comment'],
proxy: {
type: 'proxmox',
- url: '/api2/json/config/ldap'
+ url: '/api2/json/config/ldap',
},
filterOnLoad: true,
sorters: [
{
- property : 'profile',
- direction: 'ASC'
- }
- ]
+ property: 'profile',
+ direction: 'ASC',
+ },
+ ],
},
valueField: 'profile',
header: gettext('Profile'),
dataIndex: 'profile',
hideable: false,
- width: 100
+ width: 100,
},
{
header: gettext('Enabled'),
width: 80,
sortable: true,
dataIndex: 'disable',
- renderer: Proxmox.Utils.format_neg_boolean
+ renderer: Proxmox.Utils.format_neg_boolean,
},
{
header: gettext('Comment'),
sortable: false,
renderer: Ext.String.htmlEncode,
dataIndex: 'comment',
- flex: 1
- }
- ]
+ flex: 1,
+ },
+ ],
},
initComponent: function() {
me.callParent();
me.store.load();
- }
+ },
});
me.callParent([values]);
},
-
+
controller: {
xclass: 'Ext.app.ViewController',
control: {
'field[name=profile]': {
- change: 'changeProfile'
- }
- }
+ change: 'changeProfile',
+ },
+ },
},
items: [
xtype: 'pmgLDAPProfileSelector',
name: 'profile',
reference: 'profileField',
- fieldLabel: gettext("Profile")
+ fieldLabel: gettext("Profile"),
},
{
xtype: 'pmgLDAPUserSelector',
name: 'account',
reference: 'accountField',
- fieldLabel: gettext("Account")
- }
- ]
+ fieldLabel: gettext("Account"),
+ },
+ ],
});
Ext.define('PMG.LDAPUserEditor', {
width: 500,
- items: [{ xtype: 'pmgLDAPUserInputPanel' }]
+ items: [{ xtype: 'pmgLDAPUserInputPanel' }],
});
alias: 'widget.pmgLDAPUserSelector',
profile: undefined,
-
+
store: {
- fields: [ 'account', 'pmail', 'dn' ],
+ fields: ['account', 'pmail', 'dn'],
filterOnLoad: true,
sorters: [
{
- property : 'account',
- direction: 'ASC'
- }
- ]
+ property: 'account',
+ direction: 'ASC',
+ },
+ ],
},
valueField: 'account',
header: gettext('Account'),
dataIndex: 'account',
hideable: false,
- width: 100
+ width: 100,
},
{
header: gettext('E-Mail'),
dataIndex: 'pmail',
- width: 150
+ width: 150,
},
{
header: 'DN',
dataIndex: 'dn',
- width: 200
- }
- ]
+ width: 200,
+ },
+ ],
},
-
+
setProfile: function(profile, force) {
var me = this;
me.store.setProxy({
type: 'proxmox',
- url: '/api2/json/config/ldap/' + me.profile + '/users'
+ url: '/api2/json/config/ldap/' + me.profile + '/users',
});
me.store.load();
},
-
+
initComponent: function() {
var me = this;
if (me.profile !== undefined) {
me.setProfile(me.profile, true);
}
- }
+ },
});
loginForm.unmask();
Ext.MessageBox.alert(
gettext('Error'),
- gettext('Login failed. Please try again')
+ gettext('Login failed. Please try again'),
);
- }
+ },
});
}
},
var loginwin = this.lookupReference('loginwindow');
loginwin.mask(gettext('Please wait...'), 'x-mask-loading');
window.location.reload();
- }
+ },
},
'button[reference=loginButton]': {
- click: 'submitForm'
- }
- }
+ click: 'submitForm',
+ },
+ },
},
plugins: 'viewport',
layout: {
- type: 'border'
+ type: 'border',
},
items: [
xtype: 'container',
layout: {
type: 'hbox',
- align: 'middle'
+ align: 'middle',
},
margin: '2 5 2 5',
height: 38,
items: [
{
- xtype: 'proxmoxlogo'
+ xtype: 'proxmoxlogo',
},
{
xtype: 'versioninfo',
- makeApiCall: false
- }
- ]
+ makeApiCall: false,
+ },
+ ],
},
{
- region: 'center'
+ region: 'center',
},
{
xtype: 'window',
defaultFocus: 'usernameField',
layout: {
- type: 'auto'
+ type: 'auto',
},
title: gettext('Proxmox Mail Gateway Login'),
{
xtype: 'form',
layout: {
- type: 'form'
+ type: 'form',
},
defaultButton: 'loginButton',
url: '/api2/extjs/access/ticket',
fieldDefaults: {
labelAlign: 'right',
- allowBlank: false
+ allowBlank: false,
},
items: [
fieldLabel: gettext('User name'),
name: 'username',
itemId: 'usernameField',
- reference: 'usernameField'
+ reference: 'usernameField',
},
{
xtype: 'textfield',
inputType: 'password',
fieldLabel: gettext('Password'),
name: 'password',
- reference: 'passwordField'
+ reference: 'passwordField',
},
{
xtype: 'proxmoxLanguageSelector',
fieldLabel: gettext('Language'),
value: Ext.util.Cookies.get('PMGLangCookie') || 'en',
name: 'lang',
- submitValue: false
+ submitValue: false,
},
{
xtype: 'hiddenfield',
reference: 'realmfield',
name: 'realm',
- value: 'pmg'
- }
+ value: 'pmg',
+ },
],
buttons: [
{
text: gettext('Login'),
reference: 'loginButton',
- formBind: true
- }
- ]
- }
- ]
- }
- ]
+ formBind: true,
+ },
+ ],
+ },
+ ],
+ },
+ ],
});
{
itemId: 'relaying',
title: gettext('Relaying'),
- xtype: 'pmgMailProxyRelaying'
+ xtype: 'pmgMailProxyRelaying',
},
{
itemId: 'relaydomains',
title: gettext('Relay Domains'),
- xtype: 'pmgRelayDomains'
+ xtype: 'pmgRelayDomains',
},
{
itemId: 'ports',
title: gettext('Ports'),
- xtype: 'pmgMailProxyPorts'
+ xtype: 'pmgMailProxyPorts',
},
{
itemId: 'options',
title: gettext('Options'),
- xtype: 'pmgMailProxyOptions'
+ xtype: 'pmgMailProxyOptions',
},
{
itemId: 'transports',
title: gettext('Transports'),
- xtype: 'pmgTransport'
+ xtype: 'pmgTransport',
},
{
itemId: 'networks',
title: gettext('Networks'),
- xtype: 'pmgMyNetworks'
+ xtype: 'pmgMyNetworks',
},
{
itemId: 'tls',
title: gettext('TLS'),
- xtype: 'pmgMailProxyTLSPanel'
+ xtype: 'pmgMailProxyTLSPanel',
},
{
itemId: 'dkim',
title: gettext('DKIM'),
- xtype: 'pmgMailProxyDKIMPanel'
+ xtype: 'pmgMailProxyDKIMPanel',
},
{
itemId: 'whitelist',
hideGroupInfo: true,
showDirection: true,
otype_list: [1000, 1009, 1001, 1007, 1002, 1008, 1003, 1004],
- baseurl: '/config/whitelist'
- }
- ]
+ baseurl: '/config/whitelist',
+ },
+ ],
});
baseurl: '/config/dkim/domains',
domain_desc: gettext('Sign Domain'),
- onlineHelp: 'pmgconfig_mailproxy_dkim'
+ onlineHelp: 'pmgconfig_mailproxy_dkim',
});
Ext.define('PMG.MailProxyDKIMPanel', {
layout: {
type: 'vbox',
- align: 'stretch'
+ align: 'stretch',
},
bodyPadding: '0 0 10 0',
defaults: {
collapsible: true,
animCollapse: false,
- margin: '10 10 0 10'
+ margin: '10 10 0 10',
},
initComponent: function() {
var me = this;
var DKIMSettings = Ext.create('PMG.DKIMSettings', {
- title: gettext('Settings')
+ title: gettext('Settings'),
});
var DKIMDomains = Ext.create('PMG.DKIMDomains', {
title: gettext('Sign Domains'),
- flex: 1
+ flex: 1,
});
- me.items = [ DKIMSettings, DKIMDomains ];
+ me.items = [DKIMSettings, DKIMDomains];
me.callParent();
DKIMSettings.relayEvents(me, ['activate', 'deactivate', 'destroy']);
DKIMDomains.relayEvents(me, ['activate', 'deactivate', 'destroy']);
- }
+ },
});
monStoreErrors: true,
- initComponent : function() {
+ initComponent: function() {
var me = this;
me.add_integer_row('maxsize', gettext('Message Size (bytes)'),
- { defaultValue: 1024*1024*10,
- minValue: 1024, deleteEmpty: true });
+ {
+ defaultValue: 1024*1024*10,
+ minValue: 1024, deleteEmpty: true,
+});
me.add_boolean_row('rejectunknown', gettext('Reject Unknown Clients'));
defaultValue: '__default__',
deleteEmpty: true,
comboItems: [
- ['__default__', render_verifyreceivers('__default__') ],
- ['450', render_verifyreceivers('450') ],
- ['550', render_verifyreceivers('550') ]]
+ ['__default__', render_verifyreceivers('__default__')],
+ ['450', render_verifyreceivers('450')],
+ ['550', render_verifyreceivers('550')]],
});
/*jslint confusion: false*/
xtype: 'proxmoxButton',
disabled: true,
handler: function() { me.run_editor(); },
- selModel: me.selModel
+ selModel: me.selModel,
}],
url: '/api2/json' + baseurl,
editorConfig: {
url: '/api2/extjs' + baseurl,
- onlineHelp: 'pmgconfig_mailproxy_options'
+ onlineHelp: 'pmgconfig_mailproxy_options',
},
interval: 5000,
cwidth1: 200,
listeners: {
- itemdblclick: me.run_editor
- }
+ itemdblclick: me.run_editor,
+ },
});
me.callParent();
me.on('activate', me.rstore.startUpdate);
me.on('destroy', me.rstore.stopUpdate);
me.on('deactivate', me.rstore.stopUpdate);
- }
+ },
});
editorConfig: {
url: '/api2/extjs/config/mail',
- onlineHelp: 'pmgconfig_mailproxy_ports'
+ onlineHelp: 'pmgconfig_mailproxy_ports',
},
interval: 5000,
onEdit: function() {
this.getView().run_editor();
- }
+ },
},
listeners: {
- itemdblclick: 'onEdit'
+ itemdblclick: 'onEdit',
},
tbar: [
text: gettext('Edit'),
xtype: 'proxmoxButton',
disabled: true,
- handler: 'onEdit'
- }
+ handler: 'onEdit',
+ },
],
- initComponent : function() {
+ initComponent: function() {
var me = this;
me.add_integer_row('ext_port', gettext('External SMTP Port'),
- { defaultValue: 25, deleteEmpty: true,
- minValue: 1, maxValue: 65535 });
+ {
+ defaultValue: 25, deleteEmpty: true,
+ minValue: 1, maxValue: 65535,
+});
me.add_integer_row('int_port', gettext('Internal SMTP Port'),
- { defaultValue: 26, deleteEmpty: true,
- minValue: 1, maxValue: 65535 });
+ {
+ defaultValue: 26, deleteEmpty: true,
+ minValue: 1, maxValue: 65535,
+});
me.callParent();
me.on('activate', me.rstore.startUpdate);
me.on('destroy', me.rstore.stopUpdate);
me.on('deactivate', me.rstore.stopUpdate);
- }
+ },
});
monStoreErrors: true,
- initComponent : function() {
+ initComponent: function() {
var me = this;
me.add_text_row('relay', gettext('Default Relay'),
defaultValue: 25,
deleteEmpty: true,
minValue: 1,
- maxValue: 65535
+ maxValue: 65535,
});
me.add_combobox_row('relayprotocol', gettext('Relay Protocol'), {
defaultValue: 'smtp',
comboItems: [
- ['smtp', 'SMTP' ],
- ['lmtp', 'LMTP' ]]
+ ['smtp', 'SMTP'],
+ ['lmtp', 'LMTP']],
});
onlineHelp: 'pmgconfig_mailproxy_relaying',
subject: gettext('Smarthost'),
fieldDefaults: {
- labelWidth: 100
+ labelWidth: 100,
},
items: [
{
name: 'smarthost',
deleteEmpty: true,
emptyText: Proxmox.Utils.noneText,
- fieldLabel: gettext('Smarthost')
+ fieldLabel: gettext('Smarthost'),
},
{
xtype: 'proxmoxintegerfield',
minValue: 1,
maxValue: 65535,
emptyText: Proxmox.Utils.defaultText,
- fieldLabel: gettext('Port')
- }
- ]
- }
+ fieldLabel: gettext('Port'),
+ },
+ ],
+ },
};
me.rows.smarthostport = { visible: false };
xtype: 'proxmoxButton',
disabled: true,
handler: function() { me.run_editor(); },
- selModel: me.selModel
+ selModel: me.selModel,
}],
url: '/api2/json' + baseurl,
editorConfig: {
url: '/api2/extjs' + baseurl,
- onlineHelp: 'pmgconfig_mailproxy_relaying'
+ onlineHelp: 'pmgconfig_mailproxy_relaying',
},
interval: 5000,
cwidth1: 200,
listeners: {
- itemdblclick: me.run_editor
- }
+ itemdblclick: me.run_editor,
+ },
});
me.callParent();
me.on('activate', me.rstore.startUpdate);
me.on('destroy', me.rstore.stopUpdate);
me.on('deactivate', me.rstore.stopUpdate);
- }
+ },
});
monStoreErrors: true,
- initComponent : function() {
+ initComponent: function() {
var me = this;
me.add_boolean_row('tls', gettext('Enable TLS'));
xtype: 'proxmoxButton',
disabled: true,
handler: function() { me.run_editor(); },
- selModel: me.selModel
+ selModel: me.selModel,
}],
url: '/api2/json' + baseurl,
editorConfig: {
url: '/api2/extjs' + baseurl,
- onlineHelp: 'pmgconfig_mailproxy_tls'
+ onlineHelp: 'pmgconfig_mailproxy_tls',
},
interval: 5000,
cwidth1: 200,
listeners: {
- itemdblclick: me.run_editor
- }
+ itemdblclick: me.run_editor,
+ },
});
me.callParent();
me.on('activate', me.rstore.startUpdate);
me.on('destroy', me.rstore.stopUpdate);
me.on('deactivate', me.rstore.stopUpdate);
- }
+ },
});
/*global Proxmox*/
Ext.define('pmg-tls-policy', {
extend: 'Ext.data.Model',
- fields: [ 'destination', 'policy' ],
+ fields: ['destination', 'policy'],
idProperty: 'destination',
proxy: {
type: 'proxmox',
- url: '/api2/json/config/tlspolicy'
+ url: '/api2/json/config/tlspolicy',
},
sorters: {
property: 'destination',
- order: 'DESC'
- }
+ order: 'DESC',
+ },
});
Ext.define('PMG.TLSDestinationEdit', {
onlineHelp: 'pmgconfig_mailproxy_tls',
subject: gettext('TLS Policy'),
- initComponent : function() {
+ initComponent: function() {
var me = this;
- var isCreate = ! Ext.isDefined(me.destination);
+ var isCreate = !Ext.isDefined(me.destination);
var url = '/api2/extjs/config/tlspolicy' + (isCreate ? '' : '/' + me.destination);
var method = isCreate ? 'POST' : 'PUT';
{
xtype: isCreate ? 'proxmoxtextfield' : 'displayfield',
name: 'destination',
- fieldLabel: gettext('Destination')
+ fieldLabel: gettext('Destination'),
},
{
xtype: 'proxmoxKVComboBox',
fieldLabel: gettext('Policy'),
deleteEmpty: false,
comboItems: [
- [ 'none', 'none' ],
- [ 'may', 'may' ],
- [ 'encrypt', 'encrypt' ],
- [ 'dane', 'dane' ],
- [ 'dane-only', 'dane-only' ],
- [ 'fingerprint', 'fingerprint' ],
- [ 'verify', 'verify' ],
- [ 'secure', 'secure' ]
+ ['none', 'none'],
+ ['may', 'may'],
+ ['encrypt', 'encrypt'],
+ ['dane', 'dane'],
+ ['dane-only', 'dane-only'],
+ ['fingerprint', 'fingerprint'],
+ ['verify', 'verify'],
+ ['secure', 'secure'],
],
allowBlank: true,
- value: 'encrypt'
- }
+ value: 'encrypt',
+ },
];
Ext.apply(me, {
url: url,
method: method,
items: items,
- text: text
+ text: text,
});
me.callParent();
- }
+ },
});
Ext.define('PMG.MailProxyTLSDestinations', {
alias: ['widget.pmgMailProxyTLSDestinations'],
viewConfig: {
- trackOver: false
+ trackOver: false,
},
columns: [
{
header: gettext('Destination'),
width: 200,
sortable: true,
- dataIndex: 'destination'
+ dataIndex: 'destination',
},
{
header: gettext('Policy'),
sortable: false,
dataIndex: 'policy',
- flex: 1
- }
+ flex: 1,
+ },
],
- initComponent : function() {
+ initComponent: function() {
var me = this;
var rstore = Ext.create('Proxmox.data.UpdateStore', {
model: 'pmg-tls-policy',
- storeid: 'pmg-mailproxy-tls-store-' + (++Ext.idSeed)
+ storeid: 'pmg-mailproxy-tls-store-' + ++Ext.idSeed,
});
- var store = Ext.create('Proxmox.data.DiffStore', { rstore: rstore});
+ var store = Ext.create('Proxmox.data.DiffStore', { rstore: rstore });
var reload = function() {
rstore.load();
}
var win = Ext.createWidget('pmgTLSDestinationEdit', {
- destination: rec.data.destination
+ destination: rec.data.destination,
});
win.load();
xtype: 'proxmoxButton',
disabled: true,
text: gettext('Edit'),
- handler: run_editor
+ handler: run_editor,
},
{
text: gettext('Create'),
win.load();
win.on('destroy', reload);
win.show();
- }
+ },
},
{
xtype: 'proxmoxStdRemoveButton',
baseurl: '/config/tlspolicy',
callback: reload,
- waitMsgTarget: me
- }
+ waitMsgTarget: me,
+ },
];
Proxmox.Utils.monStoreErrors(me, store, true);
run_editor: run_editor,
listeners: {
itemdblclick: run_editor,
- activate: reload
- }
+ activate: reload,
+ },
});
me.on('activate', rstore.startUpdate);
me.on('destroy', rstore.stopUpdate);
me.on('deactivate', rstore.stopUpdate);
me.callParent();
- }
+ },
});
layout: {
type: 'vbox',
- align: 'stretch'
+ align: 'stretch',
},
bodyPadding: '0 0 10 0',
defaults: {
collapsible: true,
animCollapse: false,
- margin: '10 10 0 10'
+ margin: '10 10 0 10',
},
initComponent: function() {
var me = this;
var tlsSettings = Ext.create('PMG.MailProxyTLS', {
- title: gettext('Settings')
+ title: gettext('Settings'),
});
var tlsDestinations = Ext.create('PMG.MailProxyTLSDestinations', {
title: gettext('TLS Destination Policy'),
- flex: 1
+ flex: 1,
});
- me.items = [ tlsSettings, tlsDestinations ];
+ me.items = [tlsSettings, tlsDestinations];
me.callParent();
tlsSettings.relayEvents(me, ['activate', 'deactivate', 'destroy']);
tlsDestinations.relayEvents(me, ['activate', 'deactivate', 'destroy']);
- }
+ },
});
Ext.define('PMG.MailStatGrid', {
extend: 'Ext.grid.GridPanel',
xtype: 'pmgMailStatGrid',
-
+
disableSelection: true,
hideHeaders: true,
store: {
- fields: [ 'name', 'value', 'percentage' ]
+ fields: ['name', 'value', 'percentage'],
},
columns: [
{
flex: 1,
- dataIndex: 'name'
+ dataIndex: 'name',
},
{
width: 150,
- dataIndex: 'value'
+ dataIndex: 'value',
},
{
width: 300,
-
+
xtype: 'widgetcolumn',
dataIndex: 'percentage',
widget: {
xtype: 'progressbarwidget',
- textTpl: ['{percent:number("0")}%' ]
+ textTpl: ['{percent:number("0")}%'],
},
- onWidgetAttach: function (column, widget, rec) {
+ onWidgetAttach: function(column, widget, rec) {
if (rec.data.percentage === undefined) {
widget.setStyle("visibility: hidden");
} else {
widget.setStyle("visibility: visible");
}
- }
- }
- ]
+ },
+ },
+ ],
});
Ext.define('pmg-mail-tracker', {
extend: 'Ext.data.Model',
fields: [
- 'id' , 'from', 'to', 'dstatus', 'rstatus', 'qid', 'msgid', 'client',
+ 'id', 'from', 'to', 'dstatus', 'rstatus', 'qid', 'msgid', 'client',
{ type: 'number', name: 'size' },
- { type: 'date', dateFormat: 'timestamp', name: 'time' }
+ { type: 'date', dateFormat: 'timestamp', name: 'time' },
],
proxy: {
- type: 'proxmox'
+ type: 'proxmox',
},
// do not use field 'id', because "id/to" is the unique Id
// this way we display an entry for each receiver
- idProperty: 'none'
+ idProperty: 'none',
});
xtype: 'pmgMailTrackerFilter',
layout: {
- type: 'hbox'
+ type: 'hbox',
},
controller: {
if (e.getKey() == e.ENTER) {
this.onFilterChange();
}
- }
+ },
},
getFilterParams: function() {
padding: 10,
layout: {
type: 'vbox',
- align: 'stretch'
+ align: 'stretch',
},
items: [
{
fieldLabel: gettext('Sender'),
xtype: 'textfield',
listeners: { specialkey: 'onSpecialKey' },
- reference: 'from'
+ reference: 'from',
},
{
fieldLabel: gettext('Receiver'),
xtype: 'textfield',
listeners: { specialkey: 'onSpecialKey' },
- reference: 'target'
+ reference: 'target',
},
{
fieldLabel: gettext('Filter'),
xtype: 'textfield',
listeners: { specialkey: 'onSpecialKey' },
- reference: 'xfilter'
- }
- ]
+ reference: 'xfilter',
+ },
+ ],
},
{
border: false,
padding: 10,
layout: {
type: 'vbox',
- align: 'stretch'
+ align: 'stretch',
},
items: [
{
var now = new Date();
return new Date(now.getTime() - 3600000);
}()),
- xtype: 'promxoxDateTimeField'
+ xtype: 'promxoxDateTimeField',
},
{
fieldLabel: gettext('End'),
tomorrow.setSeconds(0);
return tomorrow;
}()),
- xtype: 'promxoxDateTimeField'
+ xtype: 'promxoxDateTimeField',
},
{
layout: {
- type: 'hbox'
+ type: 'hbox',
},
border: false,
items: [
xtype: 'proxmoxcheckbox',
listeners: { change: 'onFilterChange' },
reference: 'ndr',
- name: 'ndrs'
+ name: 'ndrs',
},
{
boxLabel: gettext('Include Greylist'),
listeners: { change: 'onFilterChange' },
margin: { left: 20 },
reference: 'greylist',
- name: 'greylist'
- }
- ]
- }
- ]
- }
- ]
+ name: 'greylist',
+ },
+ ],
+ },
+ ],
+ },
+ ],
});
Ext.define('PMG.MaiLogWindow', {
scrollable: true,
layout: {
- type: 'auto'
+ type: 'auto',
},
modal: true,
bodyPadding: 5,
});
logs += "</pre>";
me.update(logs);
- }
+ },
});
},
- initComponent : function() {
+ initComponent: function() {
var me = this;
if (!me.logid) {
me.setHtml('Loading...');
me.load();
- }
+ },
});
Ext.define('PMG.MailTracker', {
getRowClass: function(record, index) {
var status = record.data.rstatus || record.data.dstatus;
return PMG.Utils.mail_status_map[status];
- }
+ },
},
plugins: [
{
ptype: 'rowexpander',
expandOnDblClick: false,
- rowBodyTpl: '<p class="logs">{logs}</p>'
- }
+ rowBodyTpl: '<p class="logs">{logs}</p>',
+ },
],
store: {
url: '/nodes/' + Proxmox.NodeName + '/tracker/' + record.data.id,
waitMsgTarget: view,
failure: function(response, opts) {
- record.set('logs',gettext('Error') + " " + response.htmlStatus);
+ record.set('logs', gettext('Error') + " " + response.htmlStatus);
},
success: function(response, opts) {
var data = response.result.data;
});
record.set('logs', logs);
- }
+ },
});
},
'gridview': {
expandbody: 'showDetails',
itemdblclick: 'expand',
- }
- }
+ },
+ },
},
// extjs has no method to dynamically change the emptytext on
{
xtype: 'pmgMailTrackerFilter',
reference: 'filter',
- listeners: { filterChanged: 'onSearch' },
+ listeners: { filterChanged: 'onSearch' },
border: false,
- dock: 'top'
+ dock: 'top',
},
{
xtype: 'toolbar',
items: [
{ text: 'Search', handler: 'onSearch' },
- { xtype: 'component', html: '', reference: 'status' }
- ]
- }
+ { xtype: 'component', html: '', reference: 'status' },
+ ],
+ },
],
columns: [
header: gettext('Time'),
width: 120,
dataIndex: 'time',
- format: 'M d H:i:s'
+ format: 'M d H:i:s',
},
{
header: gettext('From'),
flex: 1,
dataIndex: 'from',
- renderer: Ext.htmlEncode
+ renderer: Ext.htmlEncode,
},
{
header: gettext('To'),
flex: 1,
dataIndex: 'to',
- renderer: Ext.htmlEncode
+ renderer: Ext.htmlEncode,
},
{
header: gettext('Status'),
icon = v;
if (v === 'Q' || v === 'B') {
returntext = vtext;
- } else if (rstatus !== undefined && rstatus !== '') {
+ } else if (rstatus !== undefined && rstatus !== '') {
var rtext = PMG.Utils.mail_status_map[rstatus] || rstatus;
returntext = vtext + '/' + rtext;
icon = rstatus;
return PMG.Utils.format_status_icon(icon) + returntext;
},
- dataIndex: 'dstatus'
+ dataIndex: 'dstatus',
},
{
header: gettext('Size'),
hidden: true,
- dataIndex: 'size'
+ dataIndex: 'size',
},
{
header: 'MSGID',
width: 300,
hidden: true,
dataIndex: 'msgid',
- renderer: Ext.htmlEncode
+ renderer: Ext.htmlEncode,
},
{
header: gettext('Client'),
width: 200,
hidden: true,
dataIndex: 'client',
- renderer: Ext.htmlEncode
- }
+ renderer: Ext.htmlEncode,
+ },
],
initComponent: function() {
me.callParent();
Proxmox.Utils.monStoreErrors(me.getView(), me.store);
- }
+ },
});
':path:subpath': {
action: 'changePath',
before: 'beforeChangePath',
- conditions : {
- ':path' : '(?:([%a-zA-Z0-9\\-\\_\\s,]+))',
- ':subpath' : '(?:(?::)([%a-zA-Z0-9\\-\\_\\s,]+))?'
- }
- }
+ conditions: {
+ ':path': '(?:([%a-zA-Z0-9\\-\\_\\s,]+))',
+ ':subpath': '(?:(?::)([%a-zA-Z0-9\\-\\_\\s,]+))?',
+ },
+ },
},
beforeChangePath: function(path, subpath, action) {
action.resume();
},
- changePath: function(path,subpath) {
+ changePath: function(path, subpath) {
var me = this;
var contentpanel = me.lookupReference('contentpanel');
var lastpanel = contentpanel.getLayout().getActiveItem();
if (lastpanel) {
contentpanel.remove(lastpanel, { destroy: true });
}
-
},
logout: function() {
changeLanguage: function() {
Ext.create('Proxmox.window.LanguageEditWindow', {
- cookieName: 'PMGLangCookie'
+ cookieName: 'PMGLangCookie',
}).show();
},
control: {
'[reference=logoutButton]': {
- click: 'logout'
+ click: 'logout',
},
'[reference=languageButton]': {
click: 'changeLanguage',
Ext.Ajax.request({
params: {
username: Proxmox.UserName,
- password: ticket
+ password: ticket,
},
url: '/api2/json/access/ticket',
method: 'POST',
success: function(response, opts) {
var obj = Ext.decode(response.responseText);
PMG.Utils.updateLoginData(obj.data);
- }
+ },
});
},
- interval: 15*60*1000
+ interval: 15*60*1000,
});
// select treeitem and load page from url fragment
var token = Ext.util.History.getToken() || 'pmgDashboard';
this.redirectTo(token, true);
-
- }
+ },
},
plugins: 'viewport',
xtype: 'container',
layout: {
type: 'hbox',
- align: 'middle'
+ align: 'middle',
},
margin: '2 0 2 5',
height: 38,
items: [
{
- xtype: 'proxmoxlogo'
+ xtype: 'proxmoxlogo',
},
{
padding: '0 0 0 5',
- xtype: 'versioninfo'
+ xtype: 'versioninfo',
},
{
- flex: 1
+ flex: 1,
},
{
xtype: 'proxmoxHelpButton',
iconCls: 'fa fa-info-circle x-btn-icon-el-default-toolbar-small ',
margin: '0 5 0 0',
listenToGlobalEvent: false,
- onlineHelp: 'pmg_documentation_index'
+ onlineHelp: 'pmg_documentation_index',
},
{
xtype: 'button',
style: {
// proxmox dark grey p light grey as border
backgroundColor: '#464d4d',
- borderColor: '#ABBABA'
+ borderColor: '#ABBABA',
},
margin: '0 5 0 0',
iconCls: 'fa fa-user',
{
reference: 'logoutButton',
iconCls: 'fa fa-sign-out',
- text: gettext('Logout')
+ text: gettext('Logout'),
},
],
},
- ]
+ ],
},
{
xtype: 'panel',
region: 'west',
layout: {
type: 'vbox',
- align: 'stretch'
+ align: 'stretch',
},
items: [{
xtype: 'navigationtree',
// because of a bug where a viewcontroller does not detect
// the selectionchange event of a treelist
listeners: {
- selectionchange: 'navigate'
- }
+ selectionchange: 'navigate',
+ },
}, {
xtype: 'box',
cls: 'x-treelist-nav',
- flex: 1
- }]
+ flex: 1,
+ }],
},
{
xtype: 'panel',
layout: { type: 'card' },
region: 'center',
border: false,
- reference: 'contentpanel'
- }
- ]
+ reference: 'contentpanel',
+ },
+ ],
});
/*global Proxmox*/
Ext.define('pmg-mynetworks', {
extend: 'Ext.data.Model',
- fields: [ 'cidr', 'comment' ],
+ fields: ['cidr', 'comment'],
proxy: {
type: 'proxmox',
- url: "/api2/json/config/mynetworks"
+ url: "/api2/json/config/mynetworks",
},
- idProperty: 'cidr'
+ idProperty: 'cidr',
});
Ext.define('PMG.MyNetworks', {
extend: 'Ext.grid.GridPanel',
alias: ['widget.pmgMyNetworks'],
- initComponent : function() {
+ initComponent: function() {
var me = this;
var store = new Ext.data.Store({
model: 'pmg-mynetworks',
sorters: {
property: 'cidr',
- order: 'DESC'
- }
+ order: 'DESC',
+ },
});
var reload = function() {
me.selModel = Ext.create('Ext.selection.RowModel', {});
- var remove_btn = Ext.createWidget('proxmoxStdRemoveButton', {
+ var remove_btn = Ext.createWidget('proxmoxStdRemoveButton', {
selModel: me.selModel,
baseurl: '/config/mynetworks',
callback: reload,
- waitMsgTarget: me
+ waitMsgTarget: me,
});
var run_editor = function() {
{
xtype: 'displayfield',
name: 'cidr',
- fieldLabel: 'CIDR'
+ fieldLabel: 'CIDR',
},
{
xtype: 'textfield',
name: 'comment',
- fieldLabel: gettext("Comment")
- }
- ]
+ fieldLabel: gettext("Comment"),
+ },
+ ],
};
var win = Ext.createWidget('proxmoxWindowEdit', config);
text: gettext('Edit'),
disabled: true,
selModel: me.selModel,
- handler: run_editor
+ handler: run_editor,
},
{
text: gettext('Create'),
{
xtype: 'proxmoxtextfield',
name: 'cidr',
- fieldLabel: 'CIDR'
+ fieldLabel: 'CIDR',
},
{
xtype: 'proxmoxtextfield',
name: 'comment',
- fieldLabel: gettext("Comment")
- }
- ]
+ fieldLabel: gettext("Comment"),
+ },
+ ],
};
/*jslint confusion: false*/
win.on('destroy', reload);
win.show();
- }
+ },
},
- remove_btn
+ remove_btn,
];
Proxmox.Utils.monStoreErrors(me, store, true);
tbar: tbar,
run_editor: run_editor,
viewConfig: {
- trackOver: false
+ trackOver: false,
},
columns: [
{
header: gettext('Trusted Network'),
width: 200,
sortable: true,
- dataIndex: 'cidr'
+ dataIndex: 'cidr',
},
{
header: gettext('Comment'),
sortable: false,
renderer: Ext.String.htmlEncode,
dataIndex: 'comment',
- flex: 1
- }
+ flex: 1,
+ },
],
listeners: {
itemdblclick: run_editor,
- activate: reload
- }
+ activate: reload,
+ },
});
me.callParent();
- }
+ },
});
text: gettext('Dashboard'),
iconCls: 'fa fa-tachometer',
path: 'pmgDashboard',
- leaf: true
+ leaf: true,
},
{
text: gettext('Mail Filter'),
text: gettext('Action Objects'),
iconCls: 'fa fa-flag',
path: 'pmgActionList',
- leaf: true
+ leaf: true,
},
{
text: gettext('Who Objects'),
iconCls: 'fa fa-user-circle',
path: 'pmgWhoConfiguration',
- leaf: true
+ leaf: true,
},
{
text: gettext('What Objects'),
iconCls: 'fa fa-cube',
path: 'pmgWhatConfiguration',
- leaf: true
+ leaf: true,
},
{
text: gettext('When Objects'),
iconCls: 'fa fa-clock-o',
path: 'pmgWhenConfiguration',
- leaf: true
- }
- ]
+ leaf: true,
+ },
+ ],
},
{
text: gettext('Configuration'),
text: gettext('Mail Proxy'),
iconCls: 'fa fa-envelope-o',
path: 'pmgMailProxyConfiguration',
- leaf: true
+ leaf: true,
},
{
text: gettext('Spam Detector'),
iconCls: 'fa fa-bullhorn',
path: 'pmgSpamDetectorConfiguration',
- leaf: true
+ leaf: true,
},
{
text: gettext('Virus Detector'),
iconCls: 'fa fa-bug',
path: 'pmgVirusDetectorConfiguration',
- leaf: true
+ leaf: true,
},
{
text: gettext('User Management'),
iconCls: 'fa fa-users',
path: 'pmgUserManagement',
- leaf: true
+ leaf: true,
},
{
text: gettext('Cluster'),
iconCls: 'fa fa-server',
path: 'pmgClusterAdministration',
- leaf: true
+ leaf: true,
},
{
text: gettext('Subscription'),
iconCls: 'fa fa-support',
path: 'pmgSubscription',
- leaf: true
- }
- ]
+ leaf: true,
+ },
+ ],
},
{
text: gettext('Administration'),
text: gettext('Spam Quarantine'),
iconCls: 'fa fa-bullhorn',
path: 'pmgSpamQuarantine',
- leaf: true
+ leaf: true,
},
{
text: gettext('Virus Quarantine'),
iconCls: 'fa fa-bug',
path: 'pmgVirusQuarantine',
- leaf: true
+ leaf: true,
},
{
text: gettext('Attachment Quarantine'),
iconCls: 'fa fa-paperclip',
path: 'pmgAttachmentQuarantine',
- leaf: true
+ leaf: true,
},
{
text: gettext('User Whitelist'),
iconCls: 'fa fa-file-o',
path: 'pmgUserWhitelist',
- leaf: true
+ leaf: true,
},
{
text: gettext('User Blacklist'),
iconCls: 'fa fa-file',
path: 'pmgUserBlacklist',
- leaf: true
+ leaf: true,
},
{
text: gettext('Tracking Center'),
iconCls: 'fa fa-map-o',
path: 'pmgMailTracker',
- leaf: true
+ leaf: true,
},
{
text: gettext('Queues'),
iconCls: 'fa fa-bars',
path: 'pmgQueueAdministration',
- leaf: true
- }
- ]
+ leaf: true,
+ },
+ ],
},
{
text: gettext('Statistics'),
text: gettext('Spam Scores'),
iconCls: 'fa fa-table',
path: 'pmgSpamScoreDistribution',
- leaf: true
+ leaf: true,
},
{
text: gettext('Virus Charts'),
iconCls: 'fa fa-bug',
path: 'pmgVirusCharts',
- leaf: true
+ leaf: true,
},
{
text: gettext('Hourly Distribution'),
iconCls: 'fa fa-area-chart',
path: 'pmgHourlyMailDistribution',
- leaf: true
+ leaf: true,
},
{
text: gettext('Postscreen'),
iconCls: 'fa fa-line-chart',
path: 'pmgRBLStatistics',
- leaf: true
+ leaf: true,
},
{
text: gettext('Domain'),
iconCls: 'fa fa-table',
path: 'pmgDomainStatistics',
- leaf: true
+ leaf: true,
},
{
text: gettext('Sender'),
iconCls: 'fa fa-table',
path: 'pmgSenderStatistics',
- leaf: true
+ leaf: true,
},
{
text: gettext('Receiver'),
iconCls: 'fa fa-table',
path: 'pmgReceiverStatistics',
- leaf: true
+ leaf: true,
},
{
text: gettext('Contact'),
iconCls: 'fa fa-table',
path: 'pmgContactStatistics',
- leaf: true
- }
- ]
- }
- ]
- }
+ leaf: true,
+ },
+ ],
+ },
+ ],
+ },
});
Ext.define('PMG.view.main.NavigationTree', {
expanderOnly: true,
expanderFirst: false,
store: 'NavigationStore',
- ui: 'nav'
+ ui: 'nav',
});
me.ogdata = ogdata;
if (me.ogdata === undefined) {
-
me.down('#oginfo').update(me.emptyText);
-
} else {
-
var html = '<b>' + Ext.String.htmlEncode(me.ogdata.name) + '</b>';
html += "<br><br>";
html += Ext.String.htmlEncode(Ext.String.trim(me.ogdata.info));
me.down('#addMenuButton').setDisabled(false);
},
- initComponent : function() {
+ initComponent: function() {
var me = this;
me.store = new Ext.data.Store({
model: 'pmg-object-list',
proxy: {
- type: 'proxmox'
+ type: 'proxmox',
},
sorters: [
{
- property : 'receivertest'
+ property: 'receivertest',
},
{
- property : 'otype',
- direction: 'ASC'
- }
- ]
+ property: 'otype',
+ direction: 'ASC',
+ },
+ ],
});
me.columns = [{
header: gettext('Type'),
dataIndex: 'otype',
renderer: PMG.Utils.format_otype,
- width: 200
+ width: 200,
}];
if (me.showDirection) {
dataIndex: 'receivertest',
renderer: function(value) {
return value ? PMG.Utils.receiverText : PMG.Utils.senderText;
- }
+ },
});
}
header: gettext('Value'),
dataIndex: 'descr',
renderer: Ext.String.htmlEncode,
- flex: 1
+ flex: 1,
});
var reload = function() {
return PMG.Utils.format_otype(rec.data.otype) +
': ' + rec.data.descr;
},
- waitMsgTarget: me
+ waitMsgTarget: me,
});
var full_subject = function(subject, receivertest) {
if (me.showDirection) {
- var direction = receivertest ?
- PMG.Utils.receiverText : PMG.Utils.senderText;
+ var direction = receivertest
+ ? PMG.Utils.receiverText : PMG.Utils.senderText;
return subject + ' (' + direction + ')';
} else {
var menu_items = [];
Ext.Array.each(me.otype_list, function(otype) {
-
var editor = PMG.Utils.object_editors[otype];
var config = Ext.apply({ method: 'POST' }, editor);
var win = Ext.create(config);
win.on('destroy', reload);
win.show();
- }
+ },
});
});
disabled: true,
itemId: 'addMenuButton',
menu: {
- items: menu_items
- }
+ items: menu_items,
+ },
},
{
xtype: 'proxmoxButton',
selModel: me.selModel,
enableFn: function(rec) {
var editor = PMG.Utils.object_editors[rec.data.otype];
- return (editor && !editor.uneditable);
+ return editor && !editor.uneditable;
},
- handler: run_editor
+ handler: run_editor,
},
- remove_btn
- ]
+ remove_btn,
+ ],
});
me.dockedItems.push({
dock: 'top',
border: 1,
layout: 'anchor',
- hidden: me.hideGroupInfo ? true : false,
+ hidden: !!me.hideGroupInfo,
itemId: 'ogdata',
items: [
{
me.fireEvent('dblclickOGInfo', me, e, t, me.ogdata);
},
element: 'el',
- scope: this
- }
- }
- }
- ]
+ scope: this,
+ },
+ },
+ },
+ ],
});
Proxmox.Utils.monStoreErrors(me, me.store, true);
run_editor: run_editor,
listeners: {
itemdblclick: run_editor,
- activate: reload
- }
+ activate: reload,
+ },
});
me.callParent();
if (me.baseurl) {
me.setBaseUrl(me.baseurl); // configure store, load()
}
- }
+ },
});
ogclass: undefined, // who, when, what
otype_list: [],
-
+
layout: 'border',
border: false,
-
- initComponent : function() {
+
+ initComponent: function() {
var me = this;
if (me.ogclass === undefined) {
throw "undefined object group class";
}
-
- if (!(PMG.Utils.oclass_text[me.ogclass])) {
+
+ if (!PMG.Utils.oclass_text[me.ogclass]) {
throw "unknown object group class";
}
title: PMG.Utils.oclass_text[me.ogclass],
border: false,
split: true,
- region: 'west'
+ region: 'west',
});
-
+
var right = Ext.create('PMG.ObjectGroup', {
otype_list: me.otype_list,
border: false,
var rec = left.selModel.getSelection()[0];
if (rec && rec.data && rec.data.id === ogdata.id) {
left.run_editor();
- return;
}
- }
- }
+ },
+ },
});
me.mon(left.store, "refresh", function() {
var baseurl = '/config/ruledb/' + me.ogclass + '/' + rec.data.id;
right.setBaseUrl(baseurl);
});
-
- me.items = [ left, right ];
+
+ me.items = [left, right];
me.callParent();
- }
+ },
});
Ext.define('PMG.WhoConfiguration', {
xtype: 'pmgWhoConfiguration',
ogclass: 'who',
- otype_list: [1000, 1001, 1002, 1003, 1004, 1005, 1006]
+ otype_list: [1000, 1001, 1002, 1003, 1004, 1005, 1006],
});
Ext.define('PMG.WhenConfiguration', {
xtype: 'pmgWhenConfiguration',
ogclass: 'when',
- otype_list: [2000]
+ otype_list: [2000],
});
Ext.define('PMG.WhatConfiguration', {
xtype: 'pmgWhatConfiguration',
ogclass: 'what',
- otype_list: [3000, 3001, 3002, 3003, 3004, 3005, 3006]
+ otype_list: [3000, 3001, 3002, 3003, 3004, 3005, 3006],
});
/*global Proxmox*/
Ext.define('pmg-object-group', {
extend: 'Ext.data.Model',
- fields: [ 'id', 'name', 'info' ],
- idProperty: 'id'
+ fields: ['id', 'name', 'info'],
+ idProperty: 'id',
});
Ext.define('pmg-object-list', {
fields: [
'id', 'descr',
{ name: 'otype', type: 'integer' },
- { name: 'receivertest', type: 'boolean' }
+ { name: 'receivertest', type: 'boolean' },
],
- idProperty: 'id'
+ idProperty: 'id',
});
xtype: 'textfield',
name: 'name',
allowBlank: false,
- fieldLabel: gettext('Name')
+ fieldLabel: gettext('Name'),
},
{
xtype: 'textareafield',
name: 'info',
- fieldLabel: gettext("Description")
- }
+ fieldLabel: gettext("Description"),
+ },
],
reload: function() {
method: 'PUT',
subject: me.subject,
width: 400,
- items: me.inputItems
+ items: me.inputItems,
};
var win = Ext.createWidget('proxmoxWindowEdit', config);
win.show();
},
- initComponent : function() {
+ initComponent: function() {
var me = this;
if (!me.ogclass) {
model: 'pmg-object-group',
proxy: {
type: 'proxmox',
- url: "/api2/json" + me.baseurl
+ url: "/api2/json" + me.baseurl,
},
sorters: {
property: 'name',
- order: 'DESC'
- }
+ order: 'DESC',
+ },
});
me.selModel = Ext.create('Ext.selection.RowModel', {});
baseurl: me.baseurl,
callback: function() { me.reload(); },
getRecordName: function(rec) { return rec.data.name; },
- waitMsgTarget: me
+ waitMsgTarget: me,
});
var tbar = [
text: gettext('Edit'),
disabled: true,
selModel: me.selModel,
- handler: function() { me.run_editor(); }
+ handler: function() { me.run_editor(); },
},
{
text: gettext('Create'),
isCreate: true,
width: 400,
subject: me.subject,
- items: me.inputItems
+ items: me.inputItems,
};
var win = Ext.createWidget('proxmoxWindowEdit', config);
win.on('destroy', me.reload, me);
win.show();
- }
+ },
},
- remove_btn
+ remove_btn,
];
Proxmox.Utils.monStoreErrors(me, me.store, true);
sortable: true,
flex: 1,
dataIndex: 'name',
- renderer: Ext.String.htmlEncode
- }
+ renderer: Ext.String.htmlEncode,
+ },
],
listeners: {
itemdblclick: function() {
me.run_editor();
}
},
- activate: function() { me.reload(); }
- }
+ activate: function() { me.reload(); },
+ },
});
me.callParent();
me.reload(); // initial load
- }
+ },
});
rulegroup: undefined,
- initComponent : function() {
+ initComponent: function() {
var me = this;
if (!me.rulegroup) {
listeners: {
itemdblclick: function(view, rec) {
me.fireEvent('selectObjectGroup', me, rec);
- }
- }
+ },
+ },
};
} else {
me.items = {
listeners: {
itemdblclick: function(view, rec) {
me.fireEvent('selectObjectGroup', me, rec);
- }
- }
+ },
+ },
};
}
me.callParent();
- }
+ },
});
extend: 'Ext.data.Model',
fields: [
'domain',
- { type: 'integer', name: 'total'},
- { type: 'integer', name: '5m'},
- { type: 'integer', name: '10m'},
- { type: 'integer', name: '20m'},
- { type: 'integer', name: '40m'},
- { type: 'integer', name: '80m'},
- { type: 'integer', name: '160m'},
- { type: 'integer', name: '320m'},
- { type: 'integer', name: '640m'},
- { type: 'integer', name: '1280m'},
- { type: 'integer', name: '1280m+'}
+ { type: 'integer', name: 'total' },
+ { type: 'integer', name: '5m' },
+ { type: 'integer', name: '10m' },
+ { type: 'integer', name: '20m' },
+ { type: 'integer', name: '40m' },
+ { type: 'integer', name: '80m' },
+ { type: 'integer', name: '160m' },
+ { type: 'integer', name: '320m' },
+ { type: 'integer', name: '640m' },
+ { type: 'integer', name: '1280m' },
+ { type: 'integer', name: '1280m+' },
],
- idProperty: 'domain'
+ idProperty: 'domain',
});
Ext.define('PMG.Postfix.QShape', {
extend: 'Ext.grid.GridPanel',
alias: 'widget.pmgPostfixQShape',
- nodename : undefined,
+ nodename: undefined,
store: {
autoLoad: true,
- model: 'pmg-qshape'
+ model: 'pmg-qshape',
},
controller: {
success: function(response, opts) {
view.store.load();
},
- failure: function (response, opts) {
+ failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
},
success: function(response, opts) {
view.store.load();
},
- failure: function (response, opts) {
+ failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
},
url: '/api2/extjs/nodes/' + view.nodename + '/postfix/discard_verify_cache',
method: 'POST',
waitMsgTarget: view,
- failure: function (response, opts) {
+ failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
},
'#': {
activate: function() {
this.view.store.load(); // reload
- }
- }
- }
+ },
+ },
+ },
},
tbar: [
{
text: gettext('Flush Queue'),
- handler: 'onFlush'
+ handler: 'onFlush',
},
{
xtype: 'proxmoxButton',
dangerous: true,
confirmMsg: "Are you sure you want to delete all deferred mails?",
selModel: null,
- handler: 'onDeleteAll'
+ handler: 'onDeleteAll',
},
{
text: gettext('Discard address verification database'),
- handler: 'onDiscardVerifyDatabase'
- }
+ handler: 'onDiscardVerifyDatabase',
+ },
],
columns: [
{
header: gettext('Domain'),
width: 200,
- dataIndex: 'domain'
+ dataIndex: 'domain',
},
{
header: gettext('Total'),
width: 80,
- dataIndex: 'total'
+ dataIndex: 'total',
},
{
header: '5m',
width: 80,
- dataIndex: '5m'
+ dataIndex: '5m',
},
{
header: '10m',
width: 80,
- dataIndex: '10m'
+ dataIndex: '10m',
},
{
header: '20m',
width: 80,
- dataIndex: '20m'
+ dataIndex: '20m',
},
{
header: '40m',
width: 80,
- dataIndex: '40m'
+ dataIndex: '40m',
},
{
header: '80m',
width: 80,
- dataIndex: '80m'
+ dataIndex: '80m',
},
{
header: '160m',
width: 80,
- dataIndex: '160m'
+ dataIndex: '160m',
},
{
header: '320m',
width: 80,
- dataIndex: '320m'
+ dataIndex: '320m',
},
{
header: '640m',
width: 80,
- dataIndex: '640m'
+ dataIndex: '640m',
},
{
header: '1280m',
width: 80,
- dataIndex: '1280m'
+ dataIndex: '1280m',
},
{
header: '1280m+',
width: 80,
- dataIndex: '1280m+'
- }
+ dataIndex: '1280m+',
+ },
],
setNodename: function(nodename) {
me.store.setProxy({
type: 'proxmox',
- url: "/api2/json/nodes/" + me.nodename + "/postfix/qshape"
+ url: "/api2/json/nodes/" + me.nodename + "/postfix/qshape",
});
me.store.load();
- }
+ },
});
emptyText: gettext('No E-Mail address selected'),
viewConfig: {
- deferEmptyText: false
+ deferEmptyText: false,
},
config: {
emailSelection: false,
- notFoundText: gettext('No data in database')
+ notFoundText: gettext('No data in database'),
},
statics: {
from: 0,
- to: 0
+ to: 0,
},
allowPositionSave: false,
me.setFrom(val);
params.starttime = val;
to.setMinValue(value);
-
} else if (field.name === 'to') {
me.setTo(val);
params.endtime = val + 24*60*60;
control: {
- '#':{
+ '#': {
beforedestroy: 'resetEmail',
- selectionchange: 'savePosition'
+ selectionchange: 'savePosition',
},
'combobox[reference=email]': {
change: 'changeEmail',
},
datefield: {
change: {
- fn: 'changeTime'
- }
- }
+ fn: 'changeTime',
+ },
+ },
- }
+ },
},
features: [
{
ftype: 'grouping',
- groupHeaderTpl: '{columnName}: {name} ({children.length})'
- }
+ groupHeaderTpl: '{columnName}: {name} ({children.length})',
+ },
],
tbar: {
layout: {
type: 'vbox',
- align: 'stretch'
+ align: 'stretch',
},
defaults: {
- margin: 2
+ margin: 2,
},
items: [
{
reference: 'from',
xtype: 'datefield',
format: 'Y-m-d',
- name: 'from'
+ name: 'from',
},
{
fieldLabel: gettext('Until'),
reference: 'to',
xtype: 'datefield',
format: 'Y-m-d',
- name: 'to'
+ name: 'to',
},
{
xtype: 'combobox',
emptyText:
'<div class="x-grid-empty">' +
gettext('No data in database') +
- '</div>'
+ '</div>',
},
store: {
proxy: {
type: 'proxmox',
- url: '/api2/json/quarantine/spamusers'
+ url: '/api2/json/quarantine/spamusers',
},
fields: [
{
name: 'mail',
- renderer: Ext.htmlEncode
- }
- ]
+ renderer: Ext.htmlEncode,
+ },
+ ],
},
queryMode: 'local',
editable: true,
anyMatch: true,
selectOnFocus: true,
reference: 'email',
- fieldLabel: 'E-Mail'
- }
- ]
- }
+ fieldLabel: 'E-Mail',
+ },
+ ],
+ },
});
text: gettext('Whitelist'),
iconCls: 'fa fa-file-o',
path: 'pmgUserWhitelist',
- leaf: true
+ leaf: true,
},
{
text: gettext('Blacklist'),
iconCls: 'fa fa-file',
path: 'pmgUserBlacklist',
- leaf: true
- }
- ]
- }
- ]
- }
+ leaf: true,
+ },
+ ],
+ },
+ ],
+ },
},
animation: false,
expanderOnly: true,
expanderFirst: false,
- ui: 'nav'
+ ui: 'nav',
});
Ext.define('PMG.QuarantineView', {
':path:subpath': {
action: 'changePath',
before: 'beforeChangePath',
- conditions : {
- ':path' : '(?:([%a-zA-Z0-9\\-\\_\\s,]+))',
- ':subpath' : '(?:(?::)([%a-zA-Z0-9\\-\\_\\s,]+))?'
- }
- }
+ conditions: {
+ ':path': '(?:([%a-zA-Z0-9\\-\\_\\s,]+))',
+ ':subpath': '(?:(?::)([%a-zA-Z0-9\\-\\_\\s,]+))?',
+ },
+ },
},
beforeChangePath: function(path, subpath, action) {
action.resume();
},
- changePath: function(path,subpath) {
+ changePath: function(path, subpath) {
var me = this;
var contentpanel = me.lookupReference('contentpanel');
var lastpanel = contentpanel.getLayout().getActiveItem();
changeLanguage: function() {
Ext.create('Proxmox.window.LanguageEditWindow', {
- cookieName: 'PMGLangCookie'
+ cookieName: 'PMGLangCookie',
}).show();
},
control: {
'[reference=logoutButton]': {
- click: 'logout'
+ click: 'logout',
},
'[reference=languageButton]': {
click: 'changeLanguage',
}
} else {
// select treeitem and load page from url fragment
-
+
token = Ext.util.History.getToken() || 'pmgSpamQuarantine';
this.redirectTo(token, true);
}
- }
+ },
},
plugins: 'viewport',
layout: {
- type: 'border'
+ type: 'border',
},
items: [
xtype: 'container',
layout: {
type: 'hbox',
- align: 'middle'
+ align: 'middle',
},
margin: '2 0 2 5',
height: 38,
items: [
{
- xtype: 'proxmoxlogo'
+ xtype: 'proxmoxlogo',
},
{
padding: '0 0 0 5',
- xtype: 'versioninfo'
+ xtype: 'versioninfo',
},
{
- flex: 1
+ flex: 1,
},
{
xtype: 'button',
style: {
// proxmox dark grey p light grey as border
backgroundColor: '#464d4d',
- borderColor: '#ABBABA'
+ borderColor: '#ABBABA',
},
margin: '0 5 0 0',
iconCls: 'fa fa-user',
{
reference: 'logoutButton',
iconCls: 'fa fa-sign-out',
- text: gettext('Logout')
+ text: gettext('Logout'),
},
],
},
- ]
+ ],
},
{
xtype: 'quarantinenavigationtree',
// because of a bug where a viewcontroller does not detect
// the selectionchange event of a treelist
listeners: {
- selectionchange: 'navigate'
- }
+ selectionchange: 'navigate',
+ },
},
{
xtype: 'panel',
layout: {
- type: 'card'
+ type: 'card',
},
region: 'center',
border: false,
- reference: 'contentpanel'
- }
- ]
+ reference: 'contentpanel',
+ },
+ ],
});
control: {
pmgPostfixQShape: {
- itemdblclick: 'onSelect'
- }
- }
+ itemdblclick: 'onSelect',
+ },
+ },
},
items: [
title: gettext('Summary'),
nodename: Proxmox.NodeName,
itemId: 'qshape',
- xtype: 'pmgPostfixQShape'
+ xtype: 'pmgPostfixQShape',
},
{
title: gettext('Deferred Mail'),
nodename: Proxmox.NodeName,
reference: 'mailq',
itemId: 'mailqueue',
- xtype: 'pmgPostfixMailQueue'
- }
- ]
+ xtype: 'pmgPostfixMailQueue',
+ },
+ ],
});
title: gettext('Statistics') + ': ' + gettext('Postscreen'),
- tbar: [ { xtype: 'pmgStatTimeSelector' } ],
+ tbar: [{ xtype: 'pmgStatTimeSelector' }],
items: [
{
title: gettext('Rejects'),
xtype: 'proxmoxRRDChart',
- fields: [ 'rbl_rejects', 'pregreet_rejects'],
+ fields: ['rbl_rejects', 'pregreet_rejects'],
fieldTitles: ['RBL', 'PREGREET'],
store: {
type: 'pmgStatStore',
fields: [
{ type: 'integer', name: 'rbl_rejects' },
{ type: 'integer', name: 'pregreet_rejects' },
- { type: 'date', dateFormat: 'timestamp', name: 'time' }
- ]
- }
- }
- ]
+ { type: 'date', dateFormat: 'timestamp', name: 'time' },
+ ],
+ },
+ },
+ ],
});
xtype: 'panel',
itemId: 'info',
bodyPadding: 10,
- html: gettext('Please select a receiver.')
- }
+ html: gettext('Please select a receiver.'),
+ },
],
disableSelection: true,
{ type: 'integer', name: 'bytes' },
{ type: 'boolean', name: 'blocked' },
{ type: 'integer', name: 'spamlevel' },
- { type: 'date', dateFormat: 'timestamp', name: 'time' }
+ { type: 'date', dateFormat: 'timestamp', name: 'time' },
],
proxy: {
type: 'pmgfilterproxy',
filterId: 'x-gridfilter-sender',
- sortParam: 'orderby'
+ sortParam: 'orderby',
},
sorters: [
{
property: 'time',
- direction: 'ASC'
- }
- ]
+ direction: 'ASC',
+ },
+ ],
},
columns: [
renderer: Ext.htmlEncode,
flex: 1,
filter: { type: 'string' },
- dataIndex: 'sender'
+ dataIndex: 'sender',
},
{
header: gettext('Size') + ' (KB)',
renderer: function(v) { return Ext.Number.toFixed(v/1024, 0); },
- dataIndex: 'bytes'
+ dataIndex: 'bytes',
},
{
xtype: 'datecolumn',
header: gettext('Date'),
format: 'Y-m-d',
- dataIndex: 'time'
+ dataIndex: 'time',
},
{
xtype: 'datecolumn',
header: gettext('Time'),
format: 'H:i:s',
- dataIndex: 'time'
+ dataIndex: 'time',
},
{
header: gettext('Virus info'),
- dataIndex: 'virusinfo'
+ dataIndex: 'virusinfo',
},
{
header: gettext('Score'),
- dataIndex: 'spamlevel'
- }
+ dataIndex: 'spamlevel',
+ },
],
initComponent: function() {
me.callParent();
Proxmox.Utils.monStoreErrors(me, me.store, true);
- }
+ },
});
Ext.define('PMG.ReceiverList', {
emptyText: gettext('No data in database'),
viewConfig: {
- deferEmptyText: false
+ deferEmptyText: false,
},
- tbar: [ { xtype: 'pmgStatTimeSelector' } ],
+ tbar: [{ xtype: 'pmgStatTimeSelector' }],
store: {
type: 'pmgStatStore',
'receiver',
{ type: 'integer', name: 'count' },
{ type: 'integer', name: 'bytes' },
- { type: 'integer', name: 'viruscount' }
+ { type: 'integer', name: 'viruscount' },
],
proxy: {
type: 'pmgfilterproxy',
sortParam: 'orderby',
- filterId: 'x-gridfilter-receiver'
+ filterId: 'x-gridfilter-receiver',
},
sorters: [
{
property: 'count',
- direction: 'DESC'
+ direction: 'DESC',
},
{
property: 'bytes',
- direction: 'DESC'
+ direction: 'DESC',
},
{
property: 'receiver',
- direction: 'ASC'
- }
- ]
+ direction: 'ASC',
+ },
+ ],
},
columns: [
type: 'string',
itemDefaults: {
// any Ext.form.field.Text configs accepted
- }
- }
+ },
+ },
},
{
text: gettext('Count'),
columns: [
{
text: gettext('Mail'),
- dataIndex: 'count'
+ dataIndex: 'count',
},
{
header: gettext('Virus'),
- dataIndex: 'viruscount'
+ dataIndex: 'viruscount',
},
{
header: gettext('Spam'),
- dataIndex: 'spamcount'
- }
- ]
+ dataIndex: 'spamcount',
+ },
+ ],
},
{
text: gettext('Size') + ' (KB)',
dataIndex: 'bytes',
renderer: function(v) {
return Ext.Number.toFixed(v/1024, 0);
- }
- }
+ },
+ },
],
initComponent: function() {
me.callParent();
Proxmox.Utils.monStoreErrors(me, me.store, true);
- }
+ },
});
Ext.define('PMG.ReceiverStatistics', {
layout: 'border',
border: false,
defaults: {
- border: false
+ border: false,
},
controller: {
xclass: 'Ext.app.ViewController',
selectionChange: function(grid, selected, eOpts) {
- var details = this.lookupReference('details');
+ var details = this.lookupReference('details');
if (selected.length > 0) {
var receiver = selected[0].data.receiver;
var url = "/api2/json/statistics/receiver/" +
} else {
details.setUrl();
}
- }
+ },
},
items: [
layout: 'fit',
flex: 1,
- listeners: { selectionchange: 'selectionChange' }
+ listeners: { selectionchange: 'selectionChange' },
},
{
xtype: 'pmgReceiverDetails',
region: 'east',
reference: 'details',
split: true,
- flex: 1
- }
- ]
+ flex: 1,
+ },
+ ],
});
xtype: 'textfield',
submitValue: false,
name: 'teststring',
- isDirty: function () { return false; },
- reset: Ext.emptyFn
- },{
+ isDirty: function() { return false; },
+ reset: Ext.emptyFn,
+ }, {
margin: '0 0 0 5',
xtype: 'button',
text: 'Test',
waitMsgTarget: me.up('window'),
params: {
regex: regex,
- text: me.down('textfield[name=teststring]').getValue()
+ text: me.down('textfield[name=teststring]').getValue(),
},
method: 'POST',
success: function(response) {
' (elapsed time: ' +
response.result.data + 'ms' + ')',
buttons: Ext.Msg.OK,
- icon: Ext.MessageBox.INFO
+ icon: Ext.MessageBox.INFO,
});
},
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
- }
+ },
}],
initComponent: function() {
}
me.callParent();
-
- }
+ },
});
/*global Proxmox*/
Ext.define('pmg-domains', {
extend: 'Ext.data.Model',
- fields: [ 'domain', 'comment' ],
- idProperty: 'domain'
+ fields: ['domain', 'comment'],
+ idProperty: 'domain',
});
Ext.define('PMG.RelayDomains', {
onlineHelp: 'pmgconfig_mailproxy_relay_domains',
- initComponent : function() {
+ initComponent: function() {
var me = this;
var store = new Ext.data.Store({
model: 'pmg-domains',
sorters: {
property: 'domain',
- order: 'DESC'
+ order: 'DESC',
},
proxy: {
type: 'proxmox',
- url: '/api2/json' + me.baseurl
+ url: '/api2/json' + me.baseurl,
},
});
selModel: me.selModel,
baseurl: me.baseurl,
callback: reload,
- waitMsgTarget: me
+ waitMsgTarget: me,
});
var run_editor = function() {
{
xtype: 'displayfield',
name: 'domain',
- fieldLabel: me.domain_desc
+ fieldLabel: me.domain_desc,
},
{
xtype: 'textfield',
name: 'comment',
- fieldLabel: gettext("Comment")
- }
- ]
+ fieldLabel: gettext("Comment"),
+ },
+ ],
};
var win = Ext.createWidget('proxmoxWindowEdit', config);
text: gettext('Edit'),
disabled: true,
selModel: me.selModel,
- handler: run_editor
+ handler: run_editor,
},
{
text: gettext('Create'),
{
xtype: 'proxmoxtextfield',
name: 'domain',
- fieldLabel: me.domain_desc
+ fieldLabel: me.domain_desc,
},
{
xtype: 'proxmoxtextfield',
name: 'comment',
- fieldLabel: gettext("Comment")
- }
- ]
+ fieldLabel: gettext("Comment"),
+ },
+ ],
};
/*jslint confusion: false*/
win.on('destroy', reload);
win.show();
- }
+ },
},
- remove_btn
+ remove_btn,
];
Proxmox.Utils.monStoreErrors(me, store, true);
tbar: tbar,
run_editor: run_editor,
viewConfig: {
- trackOver: false
+ trackOver: false,
},
columns: [
{
header: me.domain_desc,
width: 200,
sortable: true,
- dataIndex: 'domain'
+ dataIndex: 'domain',
},
{
header: gettext('Comment'),
sortable: false,
renderer: Ext.String.htmlEncode,
dataIndex: 'comment',
- flex: 1
- }
+ flex: 1,
+ },
],
listeners: {
itemdblclick: run_editor,
- activate: reload
- }
+ activate: reload,
+ },
});
me.callParent();
- }
+ },
});
['admin', PMG.Utils.format_user_role('admin')],
['helpdesk', PMG.Utils.format_user_role('helpdesk')],
['qmanager', PMG.Utils.format_user_role('qmanager')],
- ['audit', PMG.Utils.format_user_role('audit')]
- ]
+ ['audit', PMG.Utils.format_user_role('audit')],
+ ],
});
'id', 'name',
{ name: 'active', type: 'boolean' },
{ name: 'direction', type: 'integer' },
- { name: 'priority', type: 'integer' }
+ { name: 'priority', type: 'integer' },
],
- idProperty: 'id'
+ idProperty: 'id',
});
Ext.define('PMG.RulesConfiguration', {
layout: 'border',
border: false,
defaults: {
- border: false
+ border: false,
},
controller: {
listeners: {
destroy: function() {
gridView.getStore().load();
- }
- }
+ },
+ },
});
win.load();
win.show();
Proxmox.Utils.API2Request({
url: '/config/ruledb/rules/' + record.data.id + '/config',
params: {
- active: record.data.active ? 0 : 1
+ active: record.data.active ? 0 : 1,
},
method: 'PUT',
callback: function() {
},
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
},
- reload: function(){
+ reload: function() {
var me = this;
me.lookupReference('rulegrid').getStore().load();
},
listeners: {
destroy: function() {
me.lookupReference('rulegrid').getStore().load();
- }
- }
+ },
+ },
});
win.load();
win.show();
callback: function() {
me.reload();
},
- failure: function (response, opts) {
+ failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
- }
+ },
);
},
control: {
'grid[reference=rulegrid]': {
itemdblclick: 'showEditWindow',
- selectionchange: 'selectedRuleChange'
+ selectionchange: 'selectedRuleChange',
},
'button[reference=addButton]': {
- click: 'addRule'
- }
- }
+ click: 'addRule',
+ },
+ },
},
viewModel: {
data: {
selectedRule: undefined,
- baseUrl: '/config/ruledb/rules'
- }
+ baseUrl: '/config/ruledb/rules',
+ },
},
items: [
region: 'center',
bind: {
- selection: '{selectedRule}'
+ selection: '{selectedRule}',
},
- dockedItems:{
+ dockedItems: {
xtype: 'toolbar',
reference: 'mytb',
items: [
xtype: 'button',
text: gettext('Add'),
iconCls: 'fa fa-plus-circle',
- reference: 'addButton'
+ reference: 'addButton',
},
{
xtype: 'proxmoxStdRemoveButton',
callback: 'reload',
getRecordName: function(rec) { return rec.data.name; },
bind: {
- baseurl: '{baseUrl}'
- }
+ baseurl: '{baseUrl}',
+ },
},
'->',
{
text: gettext('Factory Defaults'),
- handler: 'onFactoryDefaults'
- }
- ]
+ handler: 'onFactoryDefaults',
+ },
+ ],
},
viewConfig: {
getRowClass: function(record, rowIndex) {
return record.get('active') ? 'enabled' : 'disabled';
- }
+ },
},
store: {
reference: 'rulesStore',
proxy: {
type: 'proxmox',
- url: '/api2/json/config/ruledb/rules'
+ url: '/api2/json/config/ruledb/rules',
},
sorters: [
{
property: 'priority',
- direction: 'DESC'
+ direction: 'DESC',
},
{
- property: 'name'
- }
- ]
+ property: 'name',
+ },
+ ],
},
sortableColumns: false,
{
text: 'Active',
dataIndex: 'active',
- hidden : true
+ hidden: true,
},
{
text: 'Name',
dataIndex: 'name',
- flex: 1
+ flex: 1,
},
{
text: 'Priority',
- dataIndex: 'priority'
+ dataIndex: 'priority',
},
{
text: 'Direction',
dataIndex: 'direction',
- renderer: PMG.Utils.format_rule_direction
+ renderer: PMG.Utils.format_rule_direction,
},
{
text: '',
{
iconCls: 'fa fa-fw fa-pencil',
tooltip: 'Edit',
- handler: 'editIconClick'
+ handler: 'editIconClick',
},
{
getClass: function(val, meta, rec) {
return 'fa fa-fw fa-' + (rec.get('active') ? 'toggle-on' : 'toggle-off');
},
getTip: function(val, meta, rec) {
- return (rec.get('active') ? 'Deactivate' : 'Activate');
+ return rec.get('active') ? 'Deactivate' : 'Activate';
},
- handler: 'toggleIconClick'
- }
- ]
- }
- ]
+ handler: 'toggleIconClick',
+ },
+ ],
+ },
+ ],
},
{
region: 'east',
reference: 'infopanel',
xtype: 'pmgRuleInfo',
split: true,
- width: 440
- }
- ]
+ width: 440,
+ },
+ ],
});
xtype: 'textfield',
name: 'name',
allowBlank: false,
- fieldLabel: gettext('Name')
+ fieldLabel: gettext('Name'),
},
{
xtype: 'proxmoxintegerfield',
allowBlank: false,
minValue: 0,
maxValue: 100,
- fieldLabel: gettext('Priority')
+ fieldLabel: gettext('Priority'),
},
{
xtype: 'proxmoxKVComboBox',
[1, PMG.Utils.rule_direction_text[1]],
[2, PMG.Utils.rule_direction_text[2]]],
value: 2,
- fieldLabel: gettext('Direction')
+ fieldLabel: gettext('Direction'),
},
{
xtype: 'proxmoxcheckbox',
defaultValue: 0,
uncheckedValue: 0,
checked: false,
- fieldLabel: gettext('Active')
- }
- ]
+ fieldLabel: gettext('Active'),
+ },
+ ],
});
success: function(response, opts) {
me.setRuleInfo(response.result.data);
},
- failure: function (response, opts) {
+ failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
},
callback: function() {
me.reload();
},
- failure: function (response, opts) {
+ failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
}
- }
+ },
);
},
var me = this;
var baseurl = me.getViewModel().get('baseurl');
var url = baseurl + '/' + type;
- var id = (type === 'action')?record.data.ogroup:record.data.id;
+ var id = type === 'action'?record.data.ogroup:record.data.id;
Proxmox.Utils.API2Request({
url: url,
params: { ogroup: id },
callback: function() {
me.reload();
},
- failure: function (response, opts) {
+ failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
},
var viewmodel = me.getViewModel();
if (ruledata === undefined) {
-
viewmodel.set('selectedRule', null);
viewmodel.get('objects').setData([]);
-
} else {
-
ruledata.name = Ext.String.htmlEncode(ruledata.name);
viewmodel.set('selectedRule', ruledata);
var data = [];
Ext.Array.each(['from', 'to', 'when', 'what', 'action'], function(oc) {
-
var store = viewmodel.get(oc + 'objects');
if (ruledata[oc] === undefined || store === undefined) { return; }
var ids = Ext.Array.pluck(ruledata[oc], 'id');
// for the actions, we have a different id field
- var idField = (oc === 'action')?'ogroup':'id';
+ var idField = oc === 'action'?'ogroup':'id';
store.clearFilter();
store.addFilter({
- filterFn:function(record){
+ filterFn: function(record) {
// FIXME
// actions have the ogroup as a string
// -> parseInt
- return (ids.indexOf(parseInt(record.data[idField], 10)) === -1);
- }
+ return ids.indexOf(parseInt(record.data[idField], 10)) === -1;
+ },
});
store.load();
Ext.Array.each(ruledata[oc], function(og) {
control: {
'grid[reference=usedobjects]': {
- drop: 'addDrop'
+ drop: 'addDrop',
},
'tabpanel[reference=availobjects] > grid': {
- drop: 'removeDrop'
- }
- }
+ drop: 'removeDrop',
+ },
+ },
},
viewModel: {
data: {
- baseurl: ''
+ baseurl: '',
},
stores: {
objects: {
fields: ['oclass', 'name', 'typeid'],
groupField: 'oclass',
- sorters: 'name'
+ sorters: 'name',
},
actionobjects: {
model: 'pmg-action-list',
proxy: {
type: 'proxmox',
- url: "/api2/json/config/ruledb/action/objects"
+ url: "/api2/json/config/ruledb/action/objects",
},
- sorters: 'name'
+ sorters: 'name',
},
fromobjects: {
model: 'pmg-object-group',
proxy: {
type: 'proxmox',
- url: "/api2/json/config/ruledb/who"
+ url: "/api2/json/config/ruledb/who",
},
- sorters: 'name'
+ sorters: 'name',
},
toobjects: {
model: 'pmg-object-group',
proxy: {
type: 'proxmox',
- url: "/api2/json/config/ruledb/who"
+ url: "/api2/json/config/ruledb/who",
},
- sorters: 'name'
+ sorters: 'name',
},
whatobjects: {
model: 'pmg-object-group',
proxy: {
type: 'proxmox',
- url: "/api2/json/config/ruledb/what"
+ url: "/api2/json/config/ruledb/what",
},
- sorters: 'name'
+ sorters: 'name',
},
whenobjects: {
model: 'pmg-object-group',
proxy: {
type: 'proxmox',
- url: "/api2/json/config/ruledb/when"
+ url: "/api2/json/config/ruledb/when",
},
- sorters: 'name'
- }
- }
+ sorters: 'name',
+ },
+ },
},
defaults: {
- padding: '5 10 5 10'
+ padding: '5 10 5 10',
},
bodyPadding: '5 0 5 0',
layout: {
type: 'vbox',
- align: 'stretch'
+ align: 'stretch',
},
scrollable: true,
xtype: 'panel',
bodyPadding: '10 10 10 10',
data: {
- name: ''
+ name: '',
},
bind: {
data: {
priority: '{selectedRule.priority}',
active: '{selectedRule.active}',
direction: '{selectedRule.direction}',
- selected: '{selectedRule}'
- }
+ selected: '{selectedRule}',
+ },
},
tpl: [
'<tpl if="selected">',
gettext('Active') + ': {[Proxmox.Utils.format_boolean(values.active)]}<br>',
'<tpl else>',
gettext('Please select a rule.'),
- '</tpl>'
- ]
+ '</tpl>',
+ ],
},
{
xtype: 'grid',
enableGroupingMenu: false,
collapsible: false,
groupHeaderTpl: [
- '{[PMG.Utils.format_oclass(values.name)]}'
- ]
+ '{[PMG.Utils.format_oclass(values.name)]}',
+ ],
}],
title: gettext('Used Objects'),
dropZone: {
indicatorHtml: '',
indicatorCls: '',
- handleNodeDrop: Ext.emptyFn
- }
- }
+ handleNodeDrop: Ext.emptyFn,
+ },
+ },
},
columns: [
{
header: gettext('Type'),
dataIndex: 'oclass',
- hidden: true
+ hidden: true,
},
{
header: gettext('Name'),
dataIndex: 'name',
- flex: 1
+ flex: 1,
},
{
text: '',
{
iconCls: 'fa fa-fw fa-minus-circle',
tooltip: gettext('Remove'),
- handler: 'removeIconClick'
- }
- ]
- }
+ handler: 'removeIconClick',
+ },
+ ],
+ },
],
bind: {
store: '{objects}',
- hidden: '{!selectedRule}'
- }
+ hidden: '{!selectedRule}',
+ },
},
{
xtype: 'tabpanel',
reference: 'availobjects',
hidden: true,
bind: {
- hidden: '{!selectedRule}'
+ hidden: '{!selectedRule}',
},
defaults: {
xtype: 'grid',
dropZone: {
indicatorHtml: '',
indicatorCls: '',
- handleNodeDrop: Ext.emptyFn
- }
- }
+ handleNodeDrop: Ext.emptyFn,
+ },
+ },
},
columns: [
{
header: gettext('Name'),
dataIndex: 'name',
- flex: 1
+ flex: 1,
},
{
text: '',
{
iconCls: 'fa fa-fw fa-plus-circle',
tooltip: gettext('Add'),
- handler: 'addIconClick'
- }
- ]
- }
- ]
+ handler: 'addIconClick',
+ },
+ ],
+ },
+ ],
},
items: [
{
title: gettext('Action'),
bind: {
- store: '{actionobjects}'
+ store: '{actionobjects}',
},
type: 'action',
- iconCls: 'fa fa-flag'
+ iconCls: 'fa fa-flag',
},
{
title: gettext('From'),
iconCls: 'fa fa-user-circle',
type: 'from',
bind: {
- store: '{fromobjects}'
- }
+ store: '{fromobjects}',
+ },
},
{
title: gettext('To'),
iconCls: 'fa fa-user-circle',
type: 'to',
bind: {
- store: '{toobjects}'
- }
+ store: '{toobjects}',
+ },
},
{
title: gettext('What'),
iconCls: 'fa fa-cube',
type: 'what',
bind: {
- store: '{whatobjects}'
- }
+ store: '{whatobjects}',
+ },
},
{
title: gettext('When'),
iconCls: 'fa fa-clock-o',
type: 'when',
bind: {
- store: '{whenobjects}'
- }
- }
- ]
- }
- ]
+ store: '{whenobjects}',
+ },
+ },
+ ],
+ },
+ ],
});
xtype: 'panel',
itemId: 'info',
bodyPadding: 10,
- html: gettext('Please select a sender.')
- }
+ html: gettext('Please select a sender.'),
+ },
],
disableSelection: true,
{ type: 'integer', name: 'bytes' },
{ type: 'boolean', name: 'blocked' },
{ type: 'integer', name: 'spamlevel' },
- { type: 'date', dateFormat: 'timestamp', name: 'time' }
+ { type: 'date', dateFormat: 'timestamp', name: 'time' },
],
proxy: {
type: 'pmgfilterproxy',
filterId: 'x-gridfilter-receiver',
- sortParam: 'orderby'
+ sortParam: 'orderby',
},
sorters: [
{
property: 'time',
- direction: 'ASC'
- }
- ]
+ direction: 'ASC',
+ },
+ ],
},
columns: [
renderer: Ext.htmlEncode,
flex: 1,
filter: { type: 'string' },
- dataIndex: 'receiver'
+ dataIndex: 'receiver',
},
{
header: gettext('Size') + ' (KB)',
renderer: function(v) { return Ext.Number.toFixed(v/1024, 0); },
- dataIndex: 'bytes'
+ dataIndex: 'bytes',
},
{
xtype: 'datecolumn',
header: gettext('Date'),
format: 'Y-m-d',
- dataIndex: 'time'
+ dataIndex: 'time',
},
{
xtype: 'datecolumn',
header: gettext('Time'),
format: 'H:i:s',
- dataIndex: 'time'
- }
+ dataIndex: 'time',
+ },
],
initComponent: function() {
me.callParent();
Proxmox.Utils.monStoreErrors(me, me.store, true);
- }
+ },
});
Ext.define('PMG.SenderList', {
emptyText: gettext('No data in database'),
viewConfig: {
- deferEmptyText: false
+ deferEmptyText: false,
},
- tbar: [ { xtype: 'pmgStatTimeSelector' } ],
+ tbar: [{ xtype: 'pmgStatTimeSelector' }],
store: {
type: 'pmgStatStore',
'sender',
{ type: 'integer', name: 'count' },
{ type: 'integer', name: 'bytes' },
- { type: 'integer', name: 'viruscount' }
+ { type: 'integer', name: 'viruscount' },
],
proxy: {
type: 'pmgfilterproxy',
sortParam: 'orderby',
- filterId: 'x-gridfilter-sender'
+ filterId: 'x-gridfilter-sender',
},
sorters: [
{
property: 'count',
- direction: 'DESC'
+ direction: 'DESC',
},
{
property: 'bytes',
- direction: 'DESC'
+ direction: 'DESC',
},
{
property: 'sender',
- direction: 'ASC'
- }
- ]
+ direction: 'ASC',
+ },
+ ],
},
columns: [
type: 'string',
itemDefaults: {
// any Ext.form.field.Text configs accepted
- }
- }
+ },
+ },
},
{
text: gettext('Count'),
columns: [
{
text: gettext('Mail'),
- dataIndex: 'count'
+ dataIndex: 'count',
},
{
header: gettext('Virus'),
- dataIndex: 'viruscount'
- }
- ]
+ dataIndex: 'viruscount',
+ },
+ ],
},
{
text: gettext('Size') + ' (KB)',
dataIndex: 'bytes',
renderer: function(v) {
return Ext.Number.toFixed(v/1024, 0);
- }
- }
+ },
+ },
],
initComponent: function() {
me.callParent();
Proxmox.Utils.monStoreErrors(me, me.store, true);
- }
+ },
});
Ext.define('PMG.SenderStatistics', {
layout: 'border',
border: false,
defaults: {
- border: false
+ border: false,
},
controller: {
xclass: 'Ext.app.ViewController',
selectionChange: function(grid, selected, eOpts) {
- var details = this.lookupReference('details');
+ var details = this.lookupReference('details');
if (selected.length > 0) {
var sender = selected[0].data.sender;
var url = "/api2/json/statistics/sender/" +
} else {
details.setUrl();
}
- }
+ },
},
items: [
layout: 'fit',
flex: 1,
- listeners: { selectionchange: 'selectionChange' }
+ listeners: { selectionchange: 'selectionChange' },
},
{
xtype: 'pmgSenderDetails',
region: 'east',
reference: 'details',
split: true,
- flex: 1
- }
- ]
+ flex: 1,
+ },
+ ],
});
init: function(view) {
var upgradeBtn = view.lookupReference('upgradeBtn');
upgradeBtn.setDisabled(!(Proxmox.UserName && Proxmox.UserName === 'root@pam'));
- }
+ },
},
items: [
{
xtype: 'pmgServerStatus',
- itemId: 'status'
+ itemId: 'status',
},
{
xtype: 'proxmoxNodeServiceView',
startOnlyServices: {
syslog: true,
pmgproxy: true,
- pmgdaemon: true
+ pmgdaemon: true,
},
- nodename: Proxmox.NodeName
+ nodename: Proxmox.NodeName,
},
{
xtype: 'proxmoxNodeAPT',
text: gettext('Upgrade'),
handler: function() {
Proxmox.Utils.openXtermJsViewer('upgrade', 0, Proxmox.NodeName);
- }
+ },
},
itemId: 'updates',
- nodename: Proxmox.NodeName
+ nodename: Proxmox.NodeName,
},
{
xtype: 'proxmoxJournalView',
itemId: 'logs',
title: gettext('Syslog'),
- url: "/api2/extjs/nodes/" + Proxmox.NodeName + "/journal"
+ url: "/api2/extjs/nodes/" + Proxmox.NodeName + "/journal",
},
{
xtype: 'proxmoxNodeTasks',
itemId: 'tasks',
title: gettext('Tasks'),
height: 'auto',
- nodename: Proxmox.NodeName
- }
- ]
+ nodename: Proxmox.NodeName,
+ },
+ ],
});
bodyPadding: '10 0 0 0',
defaults: {
width: 700,
- padding: '0 0 10 10'
+ padding: '0 0 10 10',
},
layout: 'column',
waitMsgTarget: me,
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
},
nodeReboot: function() {
this.nodeCommand('reboot');
- }
+ },
},
tbar: [
{
text: gettext("Console"),
iconCls: 'fa fa-terminal',
- handler: 'openConsole'
+ handler: 'openConsole',
},
{
xtype: 'proxmoxButton',
dangerous: true,
confirmMsg: gettext('Node') + " '" + Proxmox.NodeName + "' - " + gettext('Restart'),
handler: 'nodeReboot',
- iconCls: 'fa fa-undo'
+ iconCls: 'fa fa-undo',
},
{
xtype: 'proxmoxButton',
dangerous: true,
confirmMsg: gettext('Node') + " '" + Proxmox.NodeName + "' - " + gettext('Shutdown'),
handler: 'nodeShutdown',
- iconCls: 'fa fa-power-off'
+ iconCls: 'fa fa-power-off',
},
'->',
{
- xtype: 'proxmoxRRDTypeSelector'
- }
+ xtype: 'proxmoxRRDTypeSelector',
+ },
],
initComponent: function() {
name: 'cpu',
convert: function(val) {
return val*100;
- }
+ },
},
{
type: 'number',
name: 'iowait',
convert: function(val) {
return val*100;
- }
+ },
},
{ type: 'number', name: 'memtotal' },
{ type: 'number', name: 'memused' },
{ type: 'number', name: 'rootused' },
{ type: 'number', name: 'netin' },
{ type: 'number', name: 'netout' },
- { type: 'date', dateFormat: 'timestamp', name: 'time' }
- ]
+ { type: 'date', dateFormat: 'timestamp', name: 'time' },
+ ],
});
Ext.apply(me, {
xtype: 'proxmoxRRDChart',
title: gettext('CPU usage'),
unit: 'percent',
- fields: ['cpu','iowait'],
+ fields: ['cpu', 'iowait'],
fieldTitles: [gettext('CPU usage'), gettext('IO delay')],
- store: rrdstore
+ store: rrdstore,
},
{
xtype: 'proxmoxRRDChart',
title: gettext('Server load'),
fields: ['loadavg'],
fieldTitles: [gettext('Load average')],
- store: rrdstore
+ store: rrdstore,
},
{
xtype: 'proxmoxRRDChart',
title: gettext('Memory usage'),
unit: 'bytes',
- fields: ['memtotal','memused'],
+ fields: ['memtotal', 'memused'],
fieldTitles: [gettext('Total'), gettext('Used')],
- store: rrdstore
+ store: rrdstore,
},
{
xtype: 'proxmoxRRDChart',
title: gettext('Swap usage'),
unit: 'bytes',
- fields: ['swaptotal','swapused'],
+ fields: ['swaptotal', 'swapused'],
fieldTitles: [gettext('Total'), gettext('Used')],
- store: rrdstore
+ store: rrdstore,
},
{
xtype: 'proxmoxRRDChart',
title: gettext('Network traffic'),
unit: 'bytespersecond',
- fields: ['netin','netout'],
+ fields: ['netin', 'netout'],
fieldTitles: [gettext('Ingress'), gettext('Egress')],
- store: rrdstore
+ store: rrdstore,
},
{
xtype: 'proxmoxRRDChart',
title: gettext('Disk usage'),
unit: 'bytes',
- fields: ['roottotal','rootused'],
+ fields: ['roottotal', 'rootused'],
fieldTitles: [gettext('Total'), gettext('Used')],
- store: rrdstore
- }
+ store: rrdstore,
+ },
],
listeners: {
activate: function() {
},
destroy: function() {
rrdstore.stopUpdate();
- }
- }
+ },
+ },
});
me.callParent();
- }
+ },
});
-
+
if (Ext.isFunction(me.callback)) {
me.callback(btn.action);
}
- }
+ },
},
items: [
text: gettext('Deliver'),
iconCls: 'fa fa-fw fa-paper-plane-o',
action: 'deliver',
- handler: 'callCallback'
+ handler: 'callCallback',
},
{
text: gettext('Delete'),
iconCls: 'fa fa-fw fa-trash-o',
action: 'delete',
- handler: 'callCallback'
+ handler: 'callCallback',
},
{ xtype: 'menuseparator' },
{
text: gettext('Whitelist'),
iconCls: 'fa fa-fw fa-check',
action: 'whitelist',
- handler: 'action'
+ handler: 'action',
},
{
text: gettext('Blacklist'),
iconCls: 'fa fa-fw fa-times',
action: 'blacklist',
- handler: 'action'
- }
- ]
+ handler: 'action',
+ },
+ ],
});
{
title: gettext('Options'),
itemId: 'options',
- xtype: 'pmgSpamDetectorOptions'
+ xtype: 'pmgSpamDetectorOptions',
},
{
title: gettext('Quarantine'),
itemId: 'quarantine',
- xtype: 'pmgSpamQuarantineOptions'
+ xtype: 'pmgSpamQuarantineOptions',
},
{
title: gettext('Status'),
itemId: 'status',
- xtype: 'pmgSpamDetectorStatus'
+ xtype: 'pmgSpamDetectorStatus',
},
{
title: gettext('Custom Scores'),
itemId: 'scores',
- xtype: 'pmgSpamDetectorCustomScores'
+ xtype: 'pmgSpamDetectorCustomScores',
},
- ]
+ ],
});
Ext.define('pmg-sa-custom', {
extend: 'Ext.data.Model',
- fields: [ 'name', 'score', 'comment', 'digest' ],
- idProperty: 'name'
+ fields: ['name', 'score', 'comment', 'digest'],
+ idProperty: 'name',
});
Ext.define('PMG.SpamDetectorCustomScores', {
vm.set('digest', digestel.digest);
vm.set('applied', !changes);
vm.set('changetext', `<pre>${changes || ''}</pre>`);
- }
+ },
});
},
xtype: 'hiddenfield',
name: 'digest',
value: vm.get('digest'),
- }
- ]
+ },
+ ],
}).show();
},
xtype: 'proxmoxtextfield',
name: 'name',
allowBlank: false,
- fieldLabel: gettext('Name')
+ fieldLabel: gettext('Name'),
},
{
xtype: 'numberfield',
name: 'score',
allowBlank: false,
- fieldLabel: gettext('Score')
+ fieldLabel: gettext('Score'),
},
{
xtype: 'proxmoxtextfield',
name: 'comment',
- fieldLabel: gettext("Comment")
+ fieldLabel: gettext("Comment"),
},
{
xtype: 'hiddenfield',
name: 'digest',
value: vm.get('digest'),
- }
- ]
+ },
+ ],
});
win.on('destroy', me.reload, me);
{
xtype: 'displayfield',
name: 'name',
- fieldLabel: gettext('Name')
+ fieldLabel: gettext('Name'),
},
{
xtype: 'numberfield',
name: 'score',
allowBlank: false,
- fieldLabel: gettext('Score')
+ fieldLabel: gettext('Score'),
},
{
xtype: 'proxmoxtextfield',
name: 'comment',
- fieldLabel: gettext("Comment")
+ fieldLabel: gettext("Comment"),
},
{
xtype: 'hiddenfield',
name: 'digest',
value: vm.get('digest'),
- }
- ]
+ },
+ ],
});
win.load();
model: 'pmg-sa-custom',
proxy: {
type: 'proxmox',
- url: "/api2/json/config/customscores"
+ url: "/api2/json/config/customscores",
},
sorters: {
property: 'name',
- }
+ },
},
tbar: [
xtype: 'proxmoxButton',
text: gettext('Edit'),
disabled: true,
- handler: 'run_editor'
+ handler: 'run_editor',
},
{
text: gettext('Create'),
let digest = this.up('grid').digest;
let url = `/config/customscores/${rec.getId()}`;
if (digest) {
- url += `?digest=${digest}`
+ url += `?digest=${digest}`;
}
return url;
},
disabled: '{applied}',
},
handler: 'restart',
- }
+ },
],
viewConfig: {
- trackOver: false
+ trackOver: false,
},
columns: [
header: gettext('Name'),
width: 200,
sortable: true,
- dataIndex: 'name'
+ dataIndex: 'name',
},
{
header: gettext('Score'),
width: 200,
sortable: true,
- dataIndex: 'score'
+ dataIndex: 'score',
},
{
header: gettext('Comment'),
sortable: false,
renderer: Ext.String.htmlEncode,
dataIndex: 'comment',
- flex: 1
- }
+ flex: 1,
+ },
],
listeners: {
itemdblclick: 'run_editor',
- }
+ },
},
{
xtype: 'panel',
hidden: true,
bind: {
hidden: '{applied}',
- html: '{changetext}'
+ html: '{changetext}',
},
reference: 'changes',
tbar: [
gettext('Pending changes') + ' (' +
- gettext('Please restart pmg-smtp-filter to activate changes') + ')'
+ gettext('Please restart pmg-smtp-filter to activate changes') + ')',
],
split: true,
- }
+ },
],
});
alias: 'widget.pmgSpamDetectorLanguagesInputPanel',
languages: [
- [ 'af', 'Afrikaans' ],
- [ 'am', 'Amharic' ],
- [ 'ar', 'Arabic' ],
- [ 'be', 'Byelorussian' ],
- [ 'bg', 'Bulgarian' ],
- [ 'bs', 'Bosnian' ],
- [ 'ca', 'Catalan' ],
- [ 'cs', 'Czech' ],
- [ 'cy', 'Welsh' ],
- [ 'da', 'Danish' ],
- [ 'de', 'German' ],
- [ 'el', 'Greek' ],
- [ 'en', 'English' ],
- [ 'eo', 'Esperanto' ],
- [ 'es', 'Spanish' ],
- [ 'et', 'Estonian' ],
- [ 'eu', 'Basque' ],
- [ 'fa', 'Persian' ],
- [ 'fi', 'Finnish' ],
- [ 'fr', 'French' ],
- [ 'fy', 'Frisian' ],
- [ 'ga', 'Irish' ],
- [ 'gd', 'Scottish' ],
- [ 'he', 'Hebrew' ],
- [ 'hi', 'Hindi' ],
- [ 'hr', 'Croatian' ],
- [ 'hu', 'Hungarian' ],
- [ 'hy', 'Armenian' ],
- [ 'id', 'Indonesian' ],
- [ 'is', 'Icelandic' ],
- [ 'it', 'Italian' ],
- [ 'ja', 'Japanese' ],
- [ 'ka', 'Georgian' ],
- [ 'ko', 'Korean' ],
- [ 'la', 'Latin' ],
- [ 'lt', 'Lithuanian' ],
- [ 'lv', 'Latvian' ],
- [ 'mr', 'Marathi' ],
- [ 'ms', 'Malay' ],
- [ 'ne', 'Nepali' ],
- [ 'nl', 'Dutch' ],
- [ 'no', 'Norwegian' ],
- [ 'pl', 'Polish' ],
- [ 'pt', 'Portuguese' ],
- [ 'qu', 'Quechua' ],
- [ 'Rhaeto', 'Romance' ],
- [ 'ro', 'Romanian' ],
- [ 'ru', 'Russian' ],
- [ 'sa', 'Sanskrit' ],
- [ 'sco', 'Scots' ],
- [ 'sk', 'Slovak' ],
- [ 'sl', 'Slovenian' ],
- [ 'sq', 'Albanian' ],
- [ 'sr', 'Serbian' ],
- [ 'sv', 'Swedish' ],
- [ 'sw', 'Swahili' ],
- [ 'ta', 'Tamil' ],
- [ 'th', 'Thai' ],
- [ 'tl', 'Tagalog' ],
- [ 'tr', 'Turkish' ],
- [ 'uk', 'Ukrainian' ],
- [ 'vi', 'Vietnamese' ],
- [ 'yi', 'Yiddish' ],
- [ 'zh', 'Chinese' ]
+ ['af', 'Afrikaans'],
+ ['am', 'Amharic'],
+ ['ar', 'Arabic'],
+ ['be', 'Byelorussian'],
+ ['bg', 'Bulgarian'],
+ ['bs', 'Bosnian'],
+ ['ca', 'Catalan'],
+ ['cs', 'Czech'],
+ ['cy', 'Welsh'],
+ ['da', 'Danish'],
+ ['de', 'German'],
+ ['el', 'Greek'],
+ ['en', 'English'],
+ ['eo', 'Esperanto'],
+ ['es', 'Spanish'],
+ ['et', 'Estonian'],
+ ['eu', 'Basque'],
+ ['fa', 'Persian'],
+ ['fi', 'Finnish'],
+ ['fr', 'French'],
+ ['fy', 'Frisian'],
+ ['ga', 'Irish'],
+ ['gd', 'Scottish'],
+ ['he', 'Hebrew'],
+ ['hi', 'Hindi'],
+ ['hr', 'Croatian'],
+ ['hu', 'Hungarian'],
+ ['hy', 'Armenian'],
+ ['id', 'Indonesian'],
+ ['is', 'Icelandic'],
+ ['it', 'Italian'],
+ ['ja', 'Japanese'],
+ ['ka', 'Georgian'],
+ ['ko', 'Korean'],
+ ['la', 'Latin'],
+ ['lt', 'Lithuanian'],
+ ['lv', 'Latvian'],
+ ['mr', 'Marathi'],
+ ['ms', 'Malay'],
+ ['ne', 'Nepali'],
+ ['nl', 'Dutch'],
+ ['no', 'Norwegian'],
+ ['pl', 'Polish'],
+ ['pt', 'Portuguese'],
+ ['qu', 'Quechua'],
+ ['Rhaeto', 'Romance'],
+ ['ro', 'Romanian'],
+ ['ru', 'Russian'],
+ ['sa', 'Sanskrit'],
+ ['sco', 'Scots'],
+ ['sk', 'Slovak'],
+ ['sl', 'Slovenian'],
+ ['sq', 'Albanian'],
+ ['sr', 'Serbian'],
+ ['sv', 'Swedish'],
+ ['sw', 'Swahili'],
+ ['ta', 'Tamil'],
+ ['th', 'Thai'],
+ ['tl', 'Tagalog'],
+ ['tr', 'Turkish'],
+ ['uk', 'Ukrainian'],
+ ['vi', 'Vietnamese'],
+ ['yi', 'Yiddish'],
+ ['zh', 'Chinese'],
],
onGetValues: function(values) {
if (!values.languages) {
- values['delete'] = 'languages';
+ values.delete = 'languages';
} else if (Ext.isArray(values.languages)) {
/*jslint confusion: true*/
/*languages is an array and string here*/
},
- initComponent : function() {
+ initComponent: function() {
var me = this;
me.column1 = [];
xtype: 'checkboxfield',
inputValue: me.languages[i][0],
boxLabel: me.languages[i][1],
- name: 'languages'
+ name: 'languages',
};
if ((i % 4) === 0) {
me.column1.push(config);
}
me.callParent();
- }
+ },
});
Ext.define('PMG.SpamDetectorLanguages', {
subject: 'Languages',
- initComponent : function() {
+ initComponent: function() {
var me = this;
me.items = Ext.create('PMG.SpamDetectorLanguagesInputPanel');
var value = response.result.data.languages || '';
var languages = value.split(/[\ \,\;]+/);
me.setValues({ languages: languages });
- }
+ },
});
- }
+ },
});
monStoreErrors: true,
- initComponent : function() {
+ initComponent: function() {
var me = this;
me.add_boolean_row('use_awl', gettext('Use auto-whitelists'),
me.add_boolean_row('use_bayes', gettext('Use Bayesian filter'),
{ defaultValue: 1 });
-
+
me.add_boolean_row('rbl_checks', gettext('Use RBL checks'),
{ defaultValue: 1 });
{ defaultValue: 1 });
me.add_integer_row('maxspamsize', gettext('Max Spam Size (bytes)'),
- { defaultValue: 256*1024,
- minValue: 64, deleteEmpty: true });
+ {
+ defaultValue: 256*1024,
+ minValue: 64, deleteEmpty: true,
+});
me.rows.languages = {
required: true,
editor: 'PMG.SpamDetectorLanguages',
renderer: function(value) {
return value || 'all';
- }
+ },
};
me.add_integer_row('bounce_score', gettext('Backscatter Score'),
- { defaultValue: 0,
+ {
+ defaultValue: 0,
minValue: 0, maxValue: 1000,
- deleteEmpty: true });
+ deleteEmpty: true,
+});
me.add_integer_row('clamav_heuristic_score', gettext('Heuristic Score'),
- { defaultValue: 3,
+ {
+ defaultValue: 3,
minValue: 0, maxValue: 1000,
- deleteEmpty: true });
+ deleteEmpty: true,
+});
var baseurl = '/config/spam';
xtype: 'proxmoxButton',
disabled: true,
handler: function() { me.run_editor(); },
- selModel: me.selModel
+ selModel: me.selModel,
}],
url: '/api2/json' + baseurl,
editorConfig: {
url: '/api2/extjs' + baseurl,
- onlineHelp: 'pmgconfig_spamdetector'
+ onlineHelp: 'pmgconfig_spamdetector',
},
interval: 5000,
cwidth1: 200,
listeners: {
- itemdblclick: me.run_editor
- }
+ itemdblclick: me.run_editor,
+ },
});
me.callParent();
me.on('activate', me.rstore.startUpdate);
me.on('destroy', me.rstore.stopUpdate);
me.on('deactivate', me.rstore.stopUpdate);
- }
+ },
});
fields: [
'channel', 'version', 'update_version',
{ name: 'update_avail', type: 'boolean' },
- { name: 'last_updated', type: 'date', dateFormat: 'timestamp' }
+ { name: 'last_updated', type: 'date', dateFormat: 'timestamp' },
],
- idProperty: 'channel'
+ idProperty: 'channel',
});
Ext.define('PMG.SpamDetectorStatusGrid', {
title: gettext('Status'),
viewConfig: {
- trackOver: false
+ trackOver: false,
},
columns: [
{
header: gettext('Channel'),
sortable: true,
flex: 1,
- dataIndex: 'channel'
+ dataIndex: 'channel',
},
{
header: gettext('Last Update'),
sortable: true,
flex: 2,
- dataIndex: 'last_updated'
+ dataIndex: 'last_updated',
},
{
header: gettext('Version'),
flex: 1,
sortable: true,
- dataIndex: 'version'
+ dataIndex: 'version',
},
{
header: gettext('Update Available'),
} else {
return Proxmox.Utils.yesText + ' (' + record.data.update_version + ')';
}
- }
- }
+ },
+ },
],
listeners: {
activate: function() {
var me = this;
me.store.load();
- }
+ },
},
tbar: [
var upid = response.result.data;
var win = Ext.create('Proxmox.window.TaskViewer', {
- upid: upid
+ upid: upid,
});
win.show();
me.mon(win, 'close', function() { me.store.load(); });
- }
+ },
});
- }
- }
+ },
+ },
],
- initComponent : function() {
+ initComponent: function() {
var me = this;
me.store = Ext.create('Ext.data.Store', {
model: 'pmg-spamassassin-database',
proxy: {
type: 'proxmox',
- url: "/api2/json/nodes/" + Proxmox.NodeName + "/spamassassin/rules"
+ url: "/api2/json/nodes/" + Proxmox.NodeName + "/spamassassin/rules",
},
sorters: {
property: 'name',
- order: 'DESC'
- }
+ order: 'DESC',
+ },
});
me.callParent();
Proxmox.Utils.monStoreErrors(me.getView(), me.store, true);
- }
+ },
});
-Ext.define('PMG.grid.SpamInfoGrid',{
+Ext.define('PMG.grid.SpamInfoGrid', {
extend: 'Ext.grid.GridPanel',
xtype: 'pmgSpamInfoGrid',
store: {
autoDestroy: true,
- fields: [ 'desc', 'name', { type: 'number', name: 'score' } ],
+ fields: ['desc', 'name', { type: 'number', name: 'score' }],
proxy: {
type: 'proxmox',
- root: 'data.spaminfo'
- }
+ root: 'data.spaminfo',
+ },
},
setID: function(rec) {
hidden: true,
features: [{
- ftype: 'summary'
+ ftype: 'summary',
}],
columns: [
summaryType: 'count',
summaryRenderer: function(value, summaryData, dataIndex, metaData) {
return gettext('Spamscore');
- }
+ },
},
{
text: gettext('Score'),
summaryType: 'sum',
summaryRenderer: function(value, summaryData, dataIndex, metaData) {
return Ext.util.Format.round(value, 5);
- }
+ },
},
{
text: gettext('Description'),
dataIndex: 'desc',
- flex: 3
- }
- ]
+ flex: 3,
+ },
+ ],
});
fields: [
{ type: 'number', name: 'spamavg' },
{ type: 'integer', name: 'count' },
- { type: 'date', dateFormat: 'timestamp', name: 'day' }
+ { type: 'date', dateFormat: 'timestamp', name: 'day' },
],
proxy: {
type: 'proxmox',
- url: "/api2/json/quarantine/spam"
+ url: "/api2/json/quarantine/spam",
},
- idProperty: 'day'
+ idProperty: 'day',
});
Ext.define('pmg-spam-list', {
extend: 'Ext.data.Model',
- fields: [ 'id', 'envelope_sender', 'from', 'sender', 'receiver', 'subject',
+ fields: ['id', 'envelope_sender', 'from', 'sender', 'receiver', 'subject',
{ type: 'number', name: 'spamlevel' },
{ type: 'integer', name: 'bytes' },
{ type: 'date', dateFormat: 'timestamp', name: 'time' },
name: 'day',
convert: function(v, rec) {
return Ext.Date.format(rec.get('time'), 'Y-m-d');
- }, depends: ['time']
- }
+ }, depends: ['time'],
+ },
],
proxy: {
type: 'proxmox',
- url: "/api2/json/quarantine/spam"
+ url: "/api2/json/quarantine/spam",
},
- idProperty: 'id'
+ idProperty: 'id',
});
Ext.define('PMG.SpamQuarantine', {
updatePreview: function(raw, rec) {
var preview = this.lookupReference('preview');
- if (!rec || !rec.data || !rec.data.id) {
+ if (!rec || !rec.data || !rec.data.id) {
preview.update('');
preview.setDisabled(true);
return;
}
- var url = '/api2/htmlmail/quarantine/content?id=' + rec.data.id + ((raw)?'&raw=1':'');
+ var url = '/api2/htmlmail/quarantine/content?id=' + rec.data.id + (raw?'&raw=1':'');
preview.setDisabled(false);
this.lookupReference('raw').setDisabled(false);
this.lookupReference('spam').setDisabled(false);
gettext('Confirm'),
Ext.String.format(
gettext("Action '{0}' for '{1}' items"),
- action, selected.length
+ action, selected.length,
),
function(button) {
if (button !== 'yes') {
PMG.Utils.doQuarantineAction(action, idlist.join(';'), function() {
list.getController().load();
});
- }
+ },
);
return;
}
var menu = Ext.create('PMG.menu.SpamContextMenu', {
callback: function(action) {
me.doAction(action, list.getSelection());
- }
+ },
});
menu.showAt(event.getXY());
},
- keyPress: function (table, record, item, index, event) {
+ keyPress: function(table, record, item, index, event) {
var me = this;
var list = me.lookup('list');
var key = event.getKey();
var action = '';
- switch(key) {
+ switch (key) {
case event.DELETE:
case 127:
action = 'delete';
control: {
'button[reference=raw]': {
- click: 'toggleRaw'
+ click: 'toggleRaw',
},
'button[reference=spam]': {
- click: 'toggleSpamInfo'
+ click: 'toggleSpamInfo',
},
'pmgQuarantineList': {
selectionChange: 'onSelectMail',
itemkeypress: 'keyPress',
- rowcontextmenu: 'openContextMenu'
- }
- }
+ rowcontextmenu: 'openContextMenu',
+ },
+ },
},
items: [
groupDir: 'DESC',
sorters: [{
property: 'time',
- direction: 'DESC'
- }]
+ direction: 'DESC',
+ }],
},
columns: [
header: gettext('Sender/Subject'),
dataIndex: 'subject',
renderer: PMG.Utils.sender_renderer,
- flex: 1
+ flex: 1,
},
{
header: gettext('Score'),
dataIndex: 'spamlevel',
align: 'right',
- width: 70
+ width: 70,
},
{
header: gettext('Size') + ' (KB)',
renderer: function(v) { return Ext.Number.toFixed(v/1024, 0); },
dataIndex: 'bytes',
align: 'right',
- width: 90
+ width: 90,
},
{
header: gettext('Date'),
dataIndex: 'day',
- hidden: true
+ hidden: true,
},
{
xtype: 'datecolumn',
header: gettext('Time'),
dataIndex: 'time',
- format: 'H:i:s'
- }
- ]
+ format: 'H:i:s',
+ },
+ ],
},
{
title: gettext('Selected Mail'),
reference: 'raw',
text: gettext('Toggle Raw'),
enableToggle: true,
- iconCls: 'fa fa-file-code-o'
+ iconCls: 'fa fa-file-code-o',
},
{
xtype: 'button',
reference: 'spam',
text: gettext('Toggle Spam Info'),
enableToggle: true,
- iconCls: 'fa fa-bullhorn'
+ iconCls: 'fa fa-bullhorn',
},
'->',
{
href: '{downloadMailURL}',
download: '{mailid}',
},
- iconCls: 'fa fa-download'
+ iconCls: 'fa fa-download',
},
'-',
{
reference: 'whitelist',
text: gettext('Whitelist'),
iconCls: 'fa fa-check',
- handler: 'btnHandler'
+ handler: 'btnHandler',
},
{
reference: 'blacklist',
text: gettext('Blacklist'),
iconCls: 'fa fa-times',
- handler: 'btnHandler'
+ handler: 'btnHandler',
},
{
reference: 'deliver',
text: gettext('Deliver'),
iconCls: 'fa fa-paper-plane-o',
- handler: 'btnHandler'
+ handler: 'btnHandler',
},
{
reference: 'delete',
text: gettext('Delete'),
iconCls: 'fa fa-trash-o',
- handler: 'btnHandler'
- }
- ]
+ handler: 'btnHandler',
+ },
+ ],
},
{
xtype: 'pmgSpamInfoGrid',
border: false,
- reference: 'spaminfo'
+ reference: 'spaminfo',
},
{
xtype: 'pmgMailInfo',
hidden: true,
reference: 'mailinfo',
},
- ]
- }
- ]
+ ],
+ },
+ ],
});
authmodeTextHash: {
ticket: 'Ticket',
ldap: 'LDAP',
- ldapticket: 'LDAP or Ticket'
+ ldapticket: 'LDAP or Ticket',
},
reportstyleTextHash: {
none: gettext('No Reports'),
'short': gettext('Short'),
verbose: gettext('Verbose'),
- custom: gettext('Custom')
+ custom: gettext('Custom'),
},
-
- initComponent : function() {
+
+ initComponent: function() {
var me = this;
me.add_integer_row('lifetime', gettext('Lifetime (days)'),
- { minValue: 1, defaultValue: 7,
- deleteEmpty: true });
+ {
+ minValue: 1, defaultValue: 7,
+ deleteEmpty: true,
+});
var render_authmode = function(value) {
return me.authmodeTextHash[value] || value;
defaultValue: 'ticket',
renderer: render_authmode,
comboItems: [
- ['ticket', render_authmode('ticket') ],
- ['ldap', render_authmode('ldap') ],
- ['ldapticket', render_authmode('ldapticket') ]]
+ ['ticket', render_authmode('ticket')],
+ ['ldap', render_authmode('ldap')],
+ ['ldapticket', render_authmode('ldapticket')]],
});
var render_reportstyle = function(value) {
defaultValue: 'verbose',
renderer: render_reportstyle,
comboItems: [
- ['none', render_reportstyle('none') ],
- ['short', render_reportstyle('short') ],
- ['verbose', render_reportstyle('verbose') ],
- ['custom', render_reportstyle('custom') ]]
+ ['none', render_reportstyle('none')],
+ ['short', render_reportstyle('short')],
+ ['verbose', render_reportstyle('verbose')],
+ ['custom', render_reportstyle('custom')]],
});
/*jslint confusion: false*/
{ deleteEmpty: true, defaultValue: Proxmox.Utils.noneText });
me.add_boolean_row('viewimages', gettext('View images'),
- { defaultValue: 1});
-
+ { defaultValue: 1 });
+
me.add_boolean_row('allowhrefs', gettext('Allow HREFs'),
- {defaultValue: 1 });
+ { defaultValue: 1 });
var baseurl = '/config/spamquar';
xtype: 'proxmoxButton',
disabled: true,
handler: function() { me.run_editor(); },
- selModel: me.selModel
+ selModel: me.selModel,
}],
url: '/api2/json' + baseurl,
editorConfig: {
url: '/api2/extjs' + baseurl,
- onlineHelp: 'pmgconfig_spamdetector_quarantine'
+ onlineHelp: 'pmgconfig_spamdetector_quarantine',
},
interval: 5000,
cwidth1: 200,
listeners: {
- itemdblclick: me.run_editor
- }
+ itemdblclick: me.run_editor,
+ },
});
me.callParent();
me.on('activate', me.rstore.startUpdate);
me.on('destroy', me.rstore.stopUpdate);
me.on('deactivate', me.rstore.stopUpdate);
- }
+ },
});
title: gettext('Statistics') + ': ' + gettext('Spam Scores'),
- tbar: [ { xtype: 'pmgStatTimeSelector' } ],
+ tbar: [{ xtype: 'pmgStatTimeSelector' }],
store: {
xclass: 'PMG.data.StatStore',
} else {
return PMG.Utils.scoreText + ' ' + rec.data.level.toString();
}
- }
- }
- ]
+ },
+ },
+ ],
},
columns: [
{
header: PMG.Utils.scoreText,
flex: 1,
- dataIndex: 'label'
+ dataIndex: 'label',
},
{
header: gettext("Count"),
width: 150,
- dataIndex: 'count'
+ dataIndex: 'count',
},
{
header: gettext("Percentage"),
dataIndex: 'ratio',
widget: {
xtype: 'progressbarwidget',
- textTpl: ['{percent:number("0")}%' ]
- }
- }
- ]
+ textTpl: ['{percent:number("0")}%'],
+ },
+ },
+ ],
});
},
proxy: {
- type: 'proxmox'
+ type: 'proxmox',
},
autoReload: true,
me.callParent([config]);
me.reload();
- }
+ },
});
var day = this.selected_day;
var starttime, endtime, span;
-
+
if (!month) {
starttime = new Date(year, 0);
endtime = new Date(year + 1, 0);
data.starttime = (starttime.getTime() / 1000).toFixed(0);
data.endtime = (endtime.getTime() / 1000).toFixed(0);
-
+
return data;
- }
+ },
},
-
+
layout: {
- type: 'hbox'
+ type: 'hbox',
},
-
+
controller: {
xclass: 'Ext.app.ViewController',
updateVisibility: function() {
var view = this.getView();
-
+
var yearsel = this.lookupReference('yearsel');
var monthsel = this.lookupReference('monthsel');
var daysel = this.lookupReference('daysel');
var data = statics.getTimeSpan();
Ext.GlobalEvents.fireEvent('pmgStatTimeSelectorUpdate', data);
},
-
+
onSelect: function() {
this.updateVisibility();
},
-
+
init: function(view) {
var statics = Ext.getClass(view);
-
+
var yearsel = this.lookupReference('yearsel');
var monthsel = this.lookupReference('monthsel');
var daysel = this.lookupReference('daysel');
-
+
yearsel.setValue(statics.selected_year);
monthsel.setValue(statics.selected_month);
daysel.setValue(statics.selected_month ? statics.selected_day : 0);
this.updateVisibility();
- }
+ },
},
-
+
items: [
{
xtype: 'combobox',
reference: 'yearsel',
store: {
- fields: [ 'year' ],
+ fields: ['year'],
data: (function() {
var today = new Date();
var year = today.getFullYear();
- return [{ year: year }, { year: year -1 },{ year: year -2 }];
- }())
+ return [{ year: year }, { year: year -1 }, { year: year -2 }];
+ }()),
},
listeners: { select: 'onSelect' },
- value: (new Date()).getFullYear(),
+ value: new Date().getFullYear(),
queryMode: 'local',
displayField: 'year',
editable: false,
- valueField: 'year'
+ valueField: 'year',
},
{
xtype: 'combobox',
reference: 'monthsel',
store: {
- fields: [ 'month', 'name' ],
+ fields: ['month', 'name'],
data: (function() {
var i;
var data = [{ month: 0, name: gettext('Whole year') }];
for (i = 1; i <= 12; i++) {
- data.push({ month: i, name: Ext.Date.monthNames[i-1]});
+ data.push({ month: i, name: Ext.Date.monthNames[i-1] });
}
return data;
- }())
+ }()),
},
listeners: { select: 'onSelect' },
queryMode: 'local',
displayField: 'name',
editable: false,
- valueField: 'month'
+ valueField: 'month',
},
{
xtype: 'combobox',
reference: 'daysel',
store: {
- fields: [ 'day', 'name' ],
+ fields: ['day', 'name'],
data: (function() {
var i;
var data = [{ day: 0, name: gettext('Whole month') }];
for (i = 1; i <= 31; i++) {
- data.push({ day: i, name: i});
+ data.push({ day: i, name: i });
}
return data;
- }())
+ }()),
},
listeners: { select: 'onSelect' },
queryMode: 'local',
displayField: 'name',
editable: false,
- valueField: 'day'
- }
- ]
+ valueField: 'day',
+ },
+ ],
}, function() {
-
var today = new Date();
-
+
this.selected_year = today.getFullYear();
this.selected_month = today.getMonth() + 1;
this.selected_day = today.getDate();
-
});
xtype: 'textfield',
name: 'key',
value: '',
- fieldLabel: gettext('Subscription Key')
- }
+ fieldLabel: gettext('Subscription Key'),
+ },
});
Ext.define('PMG.Subscription', {
onlineHelp: 'getting_help',
viewConfig: {
- enableTextSelection: true
+ enableTextSelection: true,
},
showReport: function() {
var getReportFileName = function() {
var now = Ext.Date.format(new Date(), 'D-d-F-Y-G-i');
- return Proxmox.NodeName + '-report-' + now + '.txt';
+ return Proxmox.NodeName + '-report-' + now + '.txt';
};
var view = Ext.createWidget('component', {
'background-color': 'white',
'white-space': 'pre',
'font-family': 'monospace',
- padding: '5px'
- }
+ padding: '5px',
+ },
});
var reportWindow = Ext.create('Ext.window.Window', {
element.click();
document.body.removeChild(element);
}
- }
- }
+ },
+ },
],
- items: view
+ items: view,
});
Proxmox.Utils.API2Request({
var report = Ext.htmlEncode(response.result.data);
reportWindow.show();
view.update(report);
- }
+ },
});
},
- initComponent : function() {
+ initComponent: function() {
var me = this;
var reload = function() {
var rows = {
productname: {
- header: gettext('Type')
+ header: gettext('Type'),
},
key: {
- header: gettext('Subscription Key')
+ header: gettext('Subscription Key'),
},
status: {
header: gettext('Status'),
- renderer: render_status
+ renderer: render_status,
},
message: {
- visible: false
+ visible: false,
},
serverid: {
- header: gettext('Server ID')
+ header: gettext('Server ID'),
},
sockets: {
- header: gettext('Sockets')
+ header: gettext('Sockets'),
},
checktime: {
header: gettext('Last checked'),
- renderer: Proxmox.Utils.render_timestamp
+ renderer: Proxmox.Utils.render_timestamp,
},
nextduedate: {
- header: gettext('Next due date')
- }
+ header: gettext('Next due date'),
+ },
};
Ext.apply(me, {
url: '/api2/json' + baseurl,
cwidth1: 170,
- tbar: [
+ tbar: [
{
text: gettext('Upload Subscription Key'),
handler: function() {
var win = Ext.create('PMG.SubscriptionKeyEdit', {
- url: '/api2/extjs/' + baseurl
+ url: '/api2/extjs/' + baseurl,
});
win.show();
win.on('destroy', reload);
- }
+ },
},
{
text: gettext('Remove Subscription'),
failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
},
- callback: reload
+ callback: reload,
});
- }
+ },
},
'-',
{
text: gettext('System Report'),
handler: function() {
- Proxmox.Utils.checked_command(function (){ me.showReport(); });
- }
- }
+ Proxmox.Utils.checked_command(function() { me.showReport(); });
+ },
+ },
],
- rows: rows
+ rows: rows,
});
me.callParent();
reload();
- }
+ },
});
layout: {
type: 'vbox',
align: 'stretch',
- multi: true
+ multi: true,
},
bodyPadding: '0 0 10 0',
defaults: {
collapsible: true,
animCollapse: false,
- margin: '10 10 0 10'
+ margin: '10 10 0 10',
},
items: [
{
title: gettext('Interfaces'),
xtype: 'proxmoxNodeNetworkView',
types: ['bond'],
- nodename: Proxmox.NodeName
+ nodename: Proxmox.NodeName,
},
{
title: gettext('DNS'),
xtype: 'proxmoxNodeDNSView',
- nodename: Proxmox.NodeName
+ nodename: Proxmox.NodeName,
},
{
title: gettext('Time'),
xtype: 'proxmoxNodeTimeView',
- nodename: Proxmox.NodeName
- }
- ]
+ nodename: Proxmox.NodeName,
+ },
+ ],
},
{
itemId: 'options',
title: gettext('Options'),
- xtype: 'pmgSystemOptions'
+ xtype: 'pmgSystemOptions',
},
{
itemId: 'backup',
- xtype: 'pmgBackupRestore'
- }
+ xtype: 'pmgBackupRestore',
+ },
],
initComponent: function() {
var networktime = me.getComponent('network');
Ext.Array.forEach(networktime.query(), function(item) {
- item.relayEvents(networktime, [ 'activate', 'deactivate', 'destroy']);
+ item.relayEvents(networktime, ['activate', 'deactivate', 'destroy']);
});
- }
+ },
});
url: '/api2/json/config/admin',
editorConfig: {
url: '/api2/extjs/config/admin',
- onlineHelp: 'pmgconfig_systemconfig'
+ onlineHelp: 'pmgconfig_systemconfig',
},
controller: {
onEdit: function() {
var me = this.getView();
me.run_editor();
- }
+ },
},
tbar: [{
text: gettext('Edit'),
xtype: 'proxmoxButton',
disabled: true,
- handler: 'onEdit'
+ handler: 'onEdit',
}],
listeners: {
- itemdblclick: 'onEdit'
+ itemdblclick: 'onEdit',
},
add_proxy_row: function(name, text, opts) {
emptyText: Proxmox.Utils.noneText,
labelWidth: Proxmox.Utils.compute_min_label_width(
text, opts.labelWidth),
- fieldLabel: text
- }
- }
+ fieldLabel: text,
+ },
+ },
};
},
- initComponent : function() {
+ initComponent: function() {
var me = this;
me.add_boolean_row('dailyreport', gettext('Send daily admin reports'),
- { defaultValue: 1});
+ { defaultValue: 1 });
me.add_boolean_row('advfilter', gettext('Use advanced statistic filters'),
- { defaultValue: 1});
+ { defaultValue: 1 });
me.add_integer_row('statlifetime', gettext('User statistic lifetime (days)'),
{ minValue: 1, defaultValue: 7, deleteEmpty: true });
me.on('activate', me.rstore.startUpdate);
me.on('deactivate', me.rstore.stopUpdate);
me.on('destroy', me.rstore.stopUpdate);
- }
+ },
});
/*global Proxmox*/
Ext.define('pmg-transport', {
extend: 'Ext.data.Model',
- fields: [ 'domain', 'host', 'protocol', { name: 'port', type: 'integer' },
- { name: 'use_mx', type: 'boolean' }, 'comment' ],
+ fields: ['domain', 'host', 'protocol', { name: 'port', type: 'integer' },
+ { name: 'use_mx', type: 'boolean' }, 'comment'],
proxy: {
type: 'proxmox',
- url: "/api2/json/config/transport"
+ url: "/api2/json/config/transport",
},
- idProperty: 'domain'
+ idProperty: 'domain',
});
Ext.define('PMG.Transport', {
extend: 'Ext.grid.GridPanel',
alias: ['widget.pmgTransport'],
- initComponent : function() {
+ initComponent: function() {
let me = this;
let store = new Ext.data.Store({
model: 'pmg-transport',
sorters: {
property: 'domain',
- order: 'DESC'
- }
+ order: 'DESC',
+ },
});
Proxmox.Utils.monStoreErrors(me, store, true);
let reload = () => store.load();
text: gettext('Edit'),
disabled: true,
selModel: me.selModel,
- handler: run_editor
+ handler: run_editor,
},
{
text: gettext('Create'),
});
win.on('destroy', reload);
win.show();
- }
+ },
},
{
xtype: 'proxmoxStdRemoveButton',
selModel: me.selModel,
baseurl: '/config/transport',
callback: reload,
- waitMsgTarget: me
+ waitMsgTarget: me,
},
],
viewConfig: {
- trackOver: false
+ trackOver: false,
},
columns: [
{
header: gettext('Relay Domain'),
width: 200,
- dataIndex: 'domain'
+ dataIndex: 'domain',
},
{
header: gettext('Host'),
width: 200,
- dataIndex: 'host'
+ dataIndex: 'host',
},
{
header: gettext('Protocol'),
width: 200,
- dataIndex: 'protocol'
+ dataIndex: 'protocol',
},
{
header: gettext('Port'),
width: 80,
- dataIndex: 'port'
+ dataIndex: 'port',
},
{
header: gettext('Use MX'),
width: 80,
renderer: Proxmox.Utils.format_boolean,
- dataIndex: 'use_mx'
+ dataIndex: 'use_mx',
},
{
header: gettext('Comment'),
renderer: Ext.String.htmlEncode,
dataIndex: 'comment',
- flex: 1
- }
+ flex: 1,
+ },
],
listeners: {
itemdblclick: run_editor,
- activate: reload
- }
+ activate: reload,
+ },
});
me.callParent();
- }
+ },
});
Ext.define('PMG.TransportEditor', {
alias: 'widget.pmgTransportEditor',
mixins: ['Proxmox.Mixin.CBind'],
- cbindData: (cfg) => { return {
+ cbindData: (cfg) => ({
domainXType: cfg.method === 'POST' ? 'proxmoxtextfield' : 'displayfield',
- }},
+ }),
viewModel: {
data: {
xtype: '{domainXType}',
},
name: 'domain',
- fieldLabel: gettext("Relay Domain")
+ fieldLabel: gettext("Relay Domain"),
},
{
xtype: 'textfield',
name: 'host',
- fieldLabel: gettext("Host")
+ fieldLabel: gettext("Host"),
},
{
xtype: 'proxmoxKVComboBox',
fieldLabel: gettext('Protocol'),
deleteEmpty: false,
comboItems: [
- [ 'smtp', 'SMTP' ],
- [ 'lmtp', 'LMTP' ]
+ ['smtp', 'SMTP'],
+ ['lmtp', 'LMTP'],
],
allowBlank: true,
value: 'smtp',
bind: {
- value: '{proto}'
+ value: '{proto}',
},
},
{
value: 25,
minValue: 1,
maxValue: 65535,
- fieldLabel: gettext("Port")
+ fieldLabel: gettext("Port"),
},
{
xtype: 'proxmoxcheckbox',
{
xtype: 'textfield',
name: 'comment',
- fieldLabel: gettext("Comment")
+ fieldLabel: gettext("Comment"),
},
],
});
/*global Proxmox*/
Ext.define('pmg-address-list', {
extend: 'Ext.data.Model',
- fields: [ 'address' ],
- idProperty: 'address'
+ fields: ['address'],
+ idProperty: 'address',
});
// base class - do not use directly
name: 'address',
minLength: 3,
regex: /^[^\,\;\s]*$/, // no whitespace no , and no ;
- fieldLabel: gettext("Address")
+ fieldLabel: gettext("Address"),
}];
Ext.Object.each(params, function(key, value) {
items.push({
xtype: 'hidden',
name: key,
- value: value
+ value: value,
});
});
onlineHelp: 'pmg_userblackwhitelist',
isCreate: true,
isAdd: true,
- items: items
+ items: items,
};
if (me.listname === 'blacklist') {
callback: function(options, success, response) {
me.store.load();
},
- failure: function (response, opts) {
+ failure: function(response, opts) {
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
},
var view = this.getView();
if (value && combobox.isValid()) {
view.getStore().getProxy().setExtraParams({
- pmail: value
+ pmail: value,
});
view.getStore().load();
}
view.getStore().load();
} else {
emailcb.getStore().getProxy().setExtraParams({
- list: view.listname === 'blacklist' ? 'BL' : 'WL'
+ list: view.listname === 'blacklist' ? 'BL' : 'WL',
});
}
Proxmox.Utils.monStoreErrors(view.getView(), view.getStore(), true);
},
control: {
- 'combobox':{
+ 'combobox': {
change: {
fn: 'changeEmail',
- buffer: 500
- }
- }
- }
+ buffer: 500,
+ },
+ },
+ },
},
tbar: [
store: {
proxy: {
type: 'proxmox',
- url: '/api2/json/quarantine/quarusers'
+ url: '/api2/json/quarantine/quarusers',
},
fields: [
{
name: 'mail',
- renderer: Ext.htmlEncode
- }
- ]
+ renderer: Ext.htmlEncode,
+ },
+ ],
},
queryParam: false,
queryCaching: false,
emptyText:
'<div class="x-grid-empty">' +
gettext('No data in database') +
- '</div>'
+ '</div>',
},
- fieldLabel: 'E-Mail'
+ fieldLabel: 'E-Mail',
},
{
text: gettext('Add'),
- handler: 'onAddAddress'
+ handler: 'onAddAddress',
},
{
xtype: 'proxmoxButton',
if (text && param) {
return Ext.String.format(text, param);
}
- }
- }
+ },
+ },
],
columns: [
header: gettext('Address'),
dataIndex: 'address',
renderer: Ext.String.htmlEncode,
- flex: 1
- }
- ]
+ flex: 1,
+ },
+ ],
});
Ext.define('PMG.UserBlacklist', {
autoDestroy: true,
proxy: {
type: 'proxmox',
- url: "/api2/json/quarantine/blacklist"
+ url: "/api2/json/quarantine/blacklist",
},
sorters: {
- property: 'address'
- }
+ property: 'address',
+ },
},
dockedItems: [
bodyStyle: {
padding: '10px',
'border-left': '0px',
- 'border-right': '0px'
+ 'border-right': '0px',
},
html: gettext('With this feature, you can manually mark E-mails from certain domains or addresses as spam.') + '<br><br>' +
'<b>*.com</b> (all mails from <b>.com</b> domains)' + '<br>' +
'<b>*@example.com</b> (all mails from domain <b>example.com</b>)' + '<br>' +
- '<b>john@example.com</b> (all mails from <b>john@example.com</b>)'
+ '<b>john@example.com</b> (all mails from <b>john@example.com</b>)',
- }
- ]
+ },
+ ],
});
Ext.define('PMG.UserWhitelist', {
autoDestroy: true,
proxy: {
type: 'proxmox',
- url: "/api2/json/quarantine/whitelist"
+ url: "/api2/json/quarantine/whitelist",
},
sorters: {
- property: 'address'
- }
+ property: 'address',
+ },
},
dockedItems: [
bodyStyle: {
padding: '10px',
'border-left': '0px',
- 'border-right': '0px'
+ 'border-right': '0px',
},
html: gettext('With this feature, you can manually bypass spam checking for certain domains or E-mail addresses.') + '<br><br>' +
'<b>*.com</b> (all mails from <b>.com</b> domains)' + '<br>' +
'<b>*@example.com</b> (all mails from domain <b>example.com</b>)' + '<br>' +
- '<b>john@example.com</b> (all mails from <b>john@example.com</b>)'
- }
- ]
+ '<b>john@example.com</b> (all mails from <b>john@example.com</b>)',
+ },
+ ],
});
var baseurl = '/api2/extjs/access/users';
me.isCreate = !userid;
- me.url = userid ? baseurl + '/' + userid : baseurl;
+ me.url = userid ? baseurl + '/' + userid : baseurl;
me.method = userid ? 'PUT' : 'POST';
- me.autoLoad = userid ? true : false;
+ me.autoLoad = !!userid;
return {
useridXType: userid ? 'displayfield' : 'textfield',
- isSuperUser: userid === 'root@pam'
+ isSuperUser: userid === 'root@pam',
};
},
minLength: 4,
cbind: {
submitValue: '{isCreate}',
- xtype: '{useridXType}'
- }
+ xtype: '{useridXType}',
+ },
},
{
xtype: 'textfield',
allowBlank: false,
name: 'password',
listeners: {
- change: function(field){
+ change: function(field) {
field.next().validate();
},
- blur: function(field){
+ blur: function(field) {
field.next().validate();
- }
+ },
},
cbind: {
hidden: '{!isCreate}',
- disabled: '{!isCreate}'
- }
+ disabled: '{!isCreate}',
+ },
},
{
xtype: 'textfield',
submitValue: false,
cbind: {
hidden: '{!isCreate}',
- disabled: '{!isCreate}'
- }
+ disabled: '{!isCreate}',
+ },
},
{
xtype: 'pmgRoleSelector',
allowBlank: false,
fieldLabel: gettext('Role'),
cbind: {
- disabled: '{isSuperUser}'
- }
+ disabled: '{isSuperUser}',
+ },
},
{
xtype: 'datefield',
submitFormat: 'U',
fieldLabel: gettext('Expire'),
cbind: {
- disabled: '{isSuperUser}'
- }
+ disabled: '{isSuperUser}',
+ },
},
{
xtype: 'proxmoxcheckbox',
defaultValue: 1,
checked: true,
cbind: {
- disabled: '{isSuperUser}'
- }
- }
+ disabled: '{isSuperUser}',
+ },
+ },
],
column2: [
name: 'firstname',
fieldLabel: gettext('First Name'),
cbind: {
- deleteEmpty: '{!isCreate}'
- }
+ deleteEmpty: '{!isCreate}',
+ },
},
{
xtype: 'proxmoxtextfield',
name: 'lastname',
fieldLabel: gettext('Last Name'),
cbind: {
- deleteEmpty: '{!isCreate}'
- }
+ deleteEmpty: '{!isCreate}',
+ },
},
{
xtype: 'proxmoxtextfield',
fieldLabel: gettext('E-Mail'),
vtype: 'proxmoxMail',
cbind: {
- deleteEmpty: '{!isCreate}'
- }
- }
+ deleteEmpty: '{!isCreate}',
+ },
+ },
],
columnB: [
fieldLabel: gettext('Comment'),
cbind: {
disabled: '{isSuperUser}',
- deleteEmpty: '{!isCreate}'
- }
+ deleteEmpty: '{!isCreate}',
+ },
},
{
xtype: 'proxmoxtextfield',
name: 'keys',
fieldLabel: gettext('Key IDs'),
cbind: {
- deleteEmpty: '{!isCreate}'
- }
- }
- ]
+ deleteEmpty: '{!isCreate}',
+ },
+ },
+ ],
},
getValues: function(dirtyOnly) {
}
me.callParent([values]);
- }
+ },
});
{
title: gettext('Local'),
itemId: 'local',
- xtype: "pmgUserView"
+ xtype: "pmgUserView",
},
{
title: 'LDAP',
itemId: 'ldap',
- xtype: 'pmgLDAPConfig'
+ xtype: 'pmgLDAPConfig',
},
{
title: 'Fetchmail',
itemId: 'pop',
- xtype: 'pmgFetchmailView'
- }
- ]
+ xtype: 'pmgFetchmailView',
+ },
+ ],
});
Ext.define('pmg-users', {
extend: 'Ext.data.Model',
fields: [
- 'userid', 'firstname', 'lastname' , 'email', 'comment',
+ 'userid', 'firstname', 'lastname', 'email', 'comment',
'role', 'keys', 'realm',
{ type: 'boolean', name: 'enable' },
- { type: 'date', dateFormat: 'timestamp', name: 'expire' }
+ { type: 'date', dateFormat: 'timestamp', name: 'expire' },
],
proxy: {
type: 'proxmox',
- url: "/api2/json/access/users"
+ url: "/api2/json/access/users",
},
- idProperty: 'userid'
+ idProperty: 'userid',
});
Ext.define('PMG.UserView', {
sorters: [
{
property: 'realm',
- direction: 'ASC'
+ direction: 'ASC',
},
{
property: 'userid',
- direction: 'ASC'
- }
- ]
+ direction: 'ASC',
+ },
+ ],
},
controller: {
var rec = view.selModel.getSelection()[0];
var win = Ext.create('PMG.UserEdit', {
- userid: rec.data.userid
+ userid: rec.data.userid,
});
win.on('destroy', function() { view.reload(); });
win.show();
onPassword: function(btn, event, rec) {
var view = this.getView();
- var win = Ext.create('Proxmox.window.PasswordEdit',{
- userid: rec.data.userid
+ var win = Ext.create('Proxmox.window.PasswordEdit', {
+ userid: rec.data.userid,
});
win.on('destroy', function() { view.reload(); });
win.show();
onAfterRemove: function(btn, res) {
var view = this.getView();
view.reload();
- }
+ },
},
listeners: {
scope: 'controller',
- itemdblclick: 'onEdit'
+ itemdblclick: 'onEdit',
},
tbar: [
{
text: gettext('Add'),
reference: 'addBtn',
- handler: 'onAdd'
+ handler: 'onAdd',
},
{
xtype: 'proxmoxButton',
text: gettext('Edit'),
disabled: true,
- handler: 'onEdit'
+ handler: 'onEdit',
},
{
xtype: 'proxmoxStdRemoveButton',
baseurl: '/access/users',
reference: 'removeBtn',
callback: 'onAfterRemove',
- waitMsgTarget: true
+ waitMsgTarget: true,
},
{
xtype: 'proxmoxButton',
text: gettext('Password'),
disabled: true,
- handler: 'onPassword'
- }
+ handler: 'onPassword',
+ },
],
columns: [
width: 200,
sortable: true,
renderer: 'renderUsername',
- dataIndex: 'userid'
+ dataIndex: 'userid',
},
{
header: gettext('Realm'),
width: 100,
sortable: true,
- dataIndex: 'realm'
+ dataIndex: 'realm',
},
{
header: gettext('Role'),
width: 150,
sortable: true,
renderer: PMG.Utils.format_user_role,
- dataIndex: 'role'
+ dataIndex: 'role',
},
{
header: gettext('Enabled'),
width: 80,
sortable: true,
renderer: Proxmox.Utils.format_boolean,
- dataIndex: 'enable'
+ dataIndex: 'enable',
},
{
header: gettext('Expire'),
width: 80,
sortable: true,
renderer: Proxmox.Utils.format_expire,
- dataIndex: 'expire'
+ dataIndex: 'expire',
},
{
header: gettext('Name'),
width: 150,
sortable: true,
renderer: 'renderFullName',
- dataIndex: 'firstname'
+ dataIndex: 'firstname',
},
{
header: gettext('Comment'),
sortable: false,
renderer: Ext.String.htmlEncode,
dataIndex: 'comment',
- flex: 1
- }
+ flex: 1,
+ },
],
reload: function() {
var me = this;
me.store.load();
- }
+ },
});
/*global Proxmox*/
-Ext.define('PMG.view.main.VersionInfo',{
+Ext.define('PMG.view.main.VersionInfo', {
extend: 'Ext.Component',
xtype: 'versioninfo',
makeApiCall: true,
data: {
- version: false
+ version: false,
},
tpl: [
'Mail Gateway',
'<tpl if="version">',
' {version}',
- '</tpl>'
+ '</tpl>',
],
initComponent: function() {
method: 'GET',
success: function(response) {
me.update(response.result.data);
- }
+ },
});
}
- }
+ },
});
layout: {
type: 'vbox',
- align: 'stretch'
+ align: 'stretch',
},
controller: {
xclass: 'Ext.app.ViewController',
init: function(view) {
-
var panel = view.lookupReference('contentPanel');
var fromField =
Proxmox.Utils.API2Request({
}
panel.update(Ext.String.htmlEncode(data));
},
- failure: function (response, opts) {
+ failure: function(response, opts) {
view.destroy();
Ext.Msg.alert(gettext('Error'), response.htmlStatus);
- }
+ },
});
-
- }
+ },
},
items: [
fieldLabel: gettext('From'),
reference: 'fromField',
focusable: false,
- exitable: false
+ exitable: false,
},
{
xtype: 'textfield',
fieldLabel: gettext('To'),
reference: 'toField',
focusable: false,
- exitable: false
+ exitable: false,
},
{
xtype: 'textfield',
fieldLabel: gettext('Subject'),
reference: 'subjectField',
focusable: false,
- exitable: false
+ exitable: false,
},
{
xtype: 'displayfield',
- fieldLabel: gettext('Header')
+ fieldLabel: gettext('Header'),
},
{
xtype: 'panel',
reference: 'contentPanel',
flex: 1,
autoScroll: true,
- bodyStyle: 'white-space:pre'
- }
- ]
+ bodyStyle: 'white-space:pre',
+ },
+ ],
});
xtype: 'pmgVirusCharts',
title: gettext('Statistics') + ': ' + gettext('Virus Charts'),
-
+
border: false,
disableSelection: true,
- tbar: [ { xtype: 'pmgStatTimeSelector' } ],
+ tbar: [{ xtype: 'pmgStatTimeSelector' }],
emptyText: gettext('No data in database'),
viewConfig: {
- deferEmptyText: false
+ deferEmptyText: false,
},
store: {
xclass: 'PMG.data.StatStore',
- fields: [ 'name', 'count' ],
- staturl: "/api2/json/statistics/virus"
+ fields: ['name', 'count'],
+ staturl: "/api2/json/statistics/virus",
},
columns: [
{
header: gettext('Name'),
flex: 1,
- dataIndex: 'name'
+ dataIndex: 'name',
},
{
header: gettext('Count'),
width: 150,
- dataIndex: 'count'
- }
+ dataIndex: 'count',
+ },
],
initComponent: function() {
var me = this;
-
+
me.callParent();
-
+
Proxmox.Utils.monStoreErrors(me, me.store);
- }
+ },
});
{
title: gettext('Options'),
itemId: 'options',
- xtype: 'pmgVirusDetectorOptions'
+ xtype: 'pmgVirusDetectorOptions',
},
{
title: gettext('ClamAV'),
itemId: 'clamav',
- xtype: 'pmgClamAVDatabase'
+ xtype: 'pmgClamAVDatabase',
},
{
title: gettext('Quarantine'),
itemId: 'quarantine',
- xtype: 'pmgVirusQuarantineOptions'
- }
- ]
+ xtype: 'pmgVirusQuarantineOptions',
+ },
+ ],
});
monStoreErrors: true,
- initComponent : function() {
+ initComponent: function() {
var me = this;
me.add_boolean_row('archiveblockencrypted',
gettext('Block encrypted archives and documents'));
-
+
me.add_integer_row('archivemaxrec', gettext('Max recursion'),
- { minValue: 1, defaultValue: 5,
- deleteEmpty: true });
+ {
+ minValue: 1, defaultValue: 5,
+ deleteEmpty: true,
+});
me.add_integer_row('archivemaxfiles', gettext('Max files'),
- { minValue: 0, defaultValue: 1000,
- deleteEmpty: true });
+ {
+ minValue: 0, defaultValue: 1000,
+ deleteEmpty: true,
+});
me.add_integer_row('archivemaxsize', gettext('Max file size'),
- { minValue: 1000000, defaultValue: 25000000,
- deleteEmpty: true });
+ {
+ minValue: 1000000, defaultValue: 25000000,
+ deleteEmpty: true,
+});
me.add_integer_row('maxscansize', gettext('Max scan size'),
- { minValue: 1000000, defaultValue: 100000000,
- deleteEmpty: true });
+ {
+ minValue: 1000000, defaultValue: 100000000,
+ deleteEmpty: true,
+});
me.add_integer_row('maxcccount', gettext('Max credit card numbers'),
- { minValue: 0, defaultValue: 0,
- deleteEmpty: true });
-
+ {
+ minValue: 0, defaultValue: 0,
+ deleteEmpty: true,
+});
+
var baseurl = '/config/clamav';
me.selModel = Ext.create('Ext.selection.RowModel', {});
xtype: 'proxmoxButton',
disabled: true,
handler: function() { me.run_editor(); },
- selModel: me.selModel
+ selModel: me.selModel,
}],
url: '/api2/json' + baseurl,
editorConfig: {
url: '/api2/extjs' + baseurl,
- onlineHelp: 'pmgconfig_clamav_options'
+ onlineHelp: 'pmgconfig_clamav_options',
},
interval: 5000,
cwidth1: 270,
listeners: {
- itemdblclick: me.run_editor
- }
+ itemdblclick: me.run_editor,
+ },
});
me.callParent();
me.on('activate', me.rstore.startUpdate);
me.on('destroy', me.rstore.stopUpdate);
me.on('deactivate', me.rstore.stopUpdate);
- }
+ },
});
/*format is a string and a function*/
Ext.define('pmg-virus-list', {
extend: 'Ext.data.Model',
- fields: [ 'id', 'envelope_sender', 'from', 'sender', 'receiver', 'subject',
+ fields: ['id', 'envelope_sender', 'from', 'sender', 'receiver', 'subject',
{ type: 'integer', name: 'bytes' },
{ type: 'string', name: 'virusname' },
{ type: 'date', dateFormat: 'timestamp', name: 'time' },
name: 'day',
convert: function(v, rec) {
return Ext.Date.format(rec.get('time'), 'Y-m-d');
- }, depends: ['time']
- }
+ }, depends: ['time'],
+ },
],
proxy: {
type: 'proxmox',
- url: "/api2/json/quarantine/virus"
+ url: "/api2/json/quarantine/virus",
},
- idProperty: 'id'
+ idProperty: 'id',
});
Ext.define('PMG.VirusQuarantine', {
var rec = list.selModel.getSelection()[0];
var preview = this.lookupReference('preview');
- if (!rec || !rec.data || !rec.data.id) {
+ if (!rec || !rec.data || !rec.data.id) {
preview.update('');
preview.setDisabled(true);
return;
}
- var url = '/api2/htmlmail/quarantine/content?id=' + rec.data.id + ((raw)?'&raw=1':'');
+ var url = '/api2/htmlmail/quarantine/content?id=' + rec.data.id + (raw?'&raw=1':'');
preview.setDisabled(false);
preview.update("<iframe frameborder=0 width=100% height=100% sandbox='allow-same-origin' src='" + url +"'></iframe>");
},
control: {
'button[reference=raw]': {
- click: 'toggleRaw'
+ click: 'toggleRaw',
},
'pmgQuarantineList': {
- selectionChange: 'onSelectMail'
- }
- }
+ selectionChange: 'onSelectMail',
+ },
+ },
},
groupDir: 'DESC',
sorters: [{
property: 'time',
- direction: 'DESC'
- }]
+ direction: 'DESC',
+ }],
},
columns: [
header: gettext('Sender/Subject'),
dataIndex: 'subject',
renderer: PMG.Utils.sender_renderer,
- flex: 1
+ flex: 1,
},
{
header: gettext('Virus'),
dataIndex: 'virusname',
align: 'right',
- width: 70
+ width: 70,
},
{
header: gettext('Size') + ' (KB)',
renderer: function(v) { return Ext.Number.toFixed(v/1024, 0); },
dataIndex: 'bytes',
align: 'right',
- width: 90
+ width: 90,
},
{
header: gettext('Date'),
dataIndex: 'day',
- hidden: true
+ hidden: true,
},
{
xtype: 'datecolumn',
header: gettext('Time'),
dataIndex: 'time',
- format: 'H:m:s'
- }
- ]
+ format: 'H:m:s',
+ },
+ ],
},
{
title: gettext('Selected Mail'),
reference: 'raw',
text: gettext('Toggle Raw'),
enableToggle: true,
- iconCls: 'fa fa-file-code-o'
+ iconCls: 'fa fa-file-code-o',
},
'->',
{
reference: 'deliver',
text: gettext('Deliver'),
iconCls: 'fa fa-paper-plane-o',
- handler: 'btnHandler'
+ handler: 'btnHandler',
},
{
reference: 'delete',
text: gettext('Delete'),
iconCls: 'fa fa-trash-o',
- handler: 'btnHandler'
- }
- ]
+ handler: 'btnHandler',
+ },
+ ],
},
{
xtype: 'pmgMailInfo',
hidden: true,
reference: 'mailinfo',
},
- ]
- }
- ]
+ ],
+ },
+ ],
});
monStoreErrors: true,
- initComponent : function() {
+ initComponent: function() {
var me = this;
me.add_integer_row('lifetime', gettext('Lifetime (days)'),
- { minValue: 1, defaultValue: 7,
- deleteEmpty: true });
+ {
+ minValue: 1, defaultValue: 7,
+ deleteEmpty: true,
+});
me.add_boolean_row('viewimages', gettext('View images'),
- { defaultValue: 1});
+ { defaultValue: 1 });
me.add_boolean_row('allowhrefs', gettext('Allow HREFs'),
- {defaultValue: 1 });
+ { defaultValue: 1 });
var baseurl = '/config/virusquar';
xtype: 'proxmoxButton',
disabled: true,
handler: function() { me.run_editor(); },
- selModel: me.selModel
+ selModel: me.selModel,
}],
url: '/api2/json' + baseurl,
editorConfig: {
url: '/api2/extjs' + baseurl,
- onlineHelp: 'pmgconfig_clamav_quarantine'
+ onlineHelp: 'pmgconfig_clamav_quarantine',
},
interval: 5000,
cwidth1: 200,
listeners: {
- itemdblclick: me.run_editor
- }
+ itemdblclick: me.run_editor,
+ },
});
me.callParent();
me.on('activate', me.rstore.startUpdate);
me.on('destroy', me.rstore.stopUpdate);
me.on('deactivate', me.rstore.stopUpdate);
- }
+ },
});
layout: {
type: 'hbox',
align: 'center',
- pack: 'center'
+ pack: 'center',
},
defaults: {
xtype: 'box',
flex: 1,
style: {
- 'text-align':'center'
- }
+ 'text-align': 'center',
+ },
},
items: [
itemId: 'traffic',
data: {
'bytes_in': 0,
- 'bytes_out': 0
+ 'bytes_out': 0,
},
tpl: [
'<h3><i class="fa fa-exchange green"></i> ' + gettext('Traffic') + '</h3>',
'</tr><tr>',
'<td class="right half"><h2>{bytes_out}</h2></td>',
'<td class="left">' + PMG.Utils.format_rule_direction(1) + '</td>',
- '</tr></table>'
- ]
+ '</tr></table>',
+ ],
},
{
itemId: 'ptime',
data: {
- 'avg_ptime': 0
+ 'avg_ptime': 0,
},
tpl: [
'<h3><i class="fa fa-clock-o"></i> ' + gettext('Avg. Mail Processing Time') + '</h3>',
- '<p><h2>{avg_ptime}</h2></p>'
- ]
- }
- ]
+ '<p><h2>{avg_ptime}</h2></p>',
+ ],
+ },
+ ],
});
grid: true,
majorTickSteps: 2,
label: {
- fillStyle: '#5f5f5f'
+ fillStyle: '#5f5f5f',
},
style: {
axisLine: false,
- majorTickSize: 0
- }
+ majorTickSize: 0,
+ },
},
{
type: 'time',
dateFormat: 'H:i',
fields: ['time'],
label: {
- fillStyle: '#5f5f5f'
+ fillStyle: '#5f5f5f',
},
style: {
axisLine: false,
- majorTickSize: 0
- }
- }
+ majorTickSize: 0,
+ },
+ },
],
border: false,
flex: 1,
- noTool: true
+ noTool: true,
});
data: {
icon: 'question-circle',
- message: gettext('Unknown')
+ message: gettext('Unknown'),
},
style: {
- cursor: 'pointer'
+ cursor: 'pointer',
},
setSubStatus: function(status) {
data.icon = 'check green';
data.message = gettext('Your subscription status is valid.');
break;
- case 1:
+ case 1:
data.icon = 'exclamation-triangle yellow';
data.message = gettext('Warning: Your subscription levels are not the same.');
break;
- case 0:
+ case 0:
data.icon = 'times-circle red';
data.message = gettext('You have at least one node without subscription.');
break;
'<tr><td class="center">',
'<i class="fa fa-3x fa-{icon}"></i>',
'</td><td class="center">{message}</td></tr>',
- '</table>'
+ '</table>',
],
listeners: {
fn: function() {
var mainview = this.component.up('mainview');
mainview.getController().redirectTo('pmgSubscription');
- }
- }
- }
+ },
+ },
+ },
});
if (routeTo.params.path === 'mail') {
let mail = new MailView();
resolve({
- template: mail.getTpl()
- },{
+ template: mail.getTpl(),
+ }, {
context: {
- mailid: routeTo.params.subpath
- }
+ mailid: routeTo.params.subpath,
+ },
});
} else {
reject();
}
- }
+ },
},
{
path: '/mail/:mailid/:action',
url: '/api2/json/quarantine/content/',
data: {
action: action,
- id: mailid
+ id: mailid,
},
headers: {
- CSRFPreventionToken: Proxmox.CSRFPreventionToken
+ CSRFPreventionToken: Proxmox.CSRFPreventionToken,
},
success: (data, status, xhr) => {
loader.close();
gettext("Info"),
() => {
if (action === 'delete' ||
- action === 'deliver')
- {
+ action === 'deliver') {
// refresh the main list when a mail
// got deleted or delivered
app.ptr.refresh();
}
- }
+ },
);
reject();
},
loader.close();
PMG.Utils.showError(xhr);
reject();
- }
- })
+ },
+ });
},
() => {
reject();
- }
+ },
);
- }
- }
- ]
+ },
+ },
+ ],
});
let quarlist = new QuarantineView();
delete me._autoLogin;
me._screen.on('open', () => {
me._form.trigger('submit');
- })
+ });
}
me._screen.open();
height: function(item) {
return me._calculateHeight(item);
},
- emptyTemplate: '<div class="empty">No data in database</div>'
+ emptyTemplate: '<div class="empty">No data in database</div>',
});
// setup pull to refresh
sorter: {
property: 'time',
numeric: true,
- direction: 'DESC'
+ direction: 'DESC',
},
- grouperFn: (val) => PMG.Utils.unixToIso(val['time'])
+ grouperFn: (val) => PMG.Utils.unixToIso(val.time),
});
}).catch(PMG.Utils.showError).then(() => {
e.detail();
me._loginScreen.close();
PMG.Utils.setLoginInfo(data);
return PMG.Utils.getSubscriptionInfo();
- }).then(data => {
- return PMG.Utils.checkSubscription(data, showPopup);
- }).then(data => {
+ }).then(data => PMG.Utils.checkSubscription(data, showPopup)).then(data => {
app.ptr.refresh();
if (mail) {
let url = "/mail/" + mail + "/" + (action || "");
main: me.config.mainView !== undefined ? me.config.mainView : true,
url: '/',
pushState: true,
- pushStateAnimateOnLoad: true
+ pushStateAnimateOnLoad: true,
});
}
setStarttime(starttime) {
date = new Date(PMG.Utils.isoToUnix(starttime)*1000);
}
// starttime is at beginning of date
- date.setHours(0,0,0,0);
+ date.setHours(0, 0, 0, 0);
let result = Math.round(date.getTime()/1000);
if (result !== me.starttime) {
me.starttime = result;
return true;
}
- return false
+ return false;
}
setEndtime(endtime) {
var me = this;
case 'ios-item':
height = 53;
break;
- default: ;
+ default:
}
}
_renderItem(item) {
var me = this;
- if(typeof item === 'object') {
+ if (typeof item === 'object') {
if (item.skel) {
return item.divider? me.skelDividerTpl : me.skelTpl;
} else if (item.divider) {
let prop = options.sorter.property;
let numeric = options.sorter.numeric;
let dir = options.sorter.direction === "ASC" ? 1 : -1;
- items.sort((a,b) => {
+ items.sort((a, b) => {
let result;
if (numeric) {
result = a[prop] - b[prop];
} else {
- result = a[prop] === b[prop] ? 0 : (a[prop] < b[prop] ? 1 : -1);
+ result = a[prop] === b[prop] ? 0 : a[prop] < b[prop] ? 1 : -1;
}
return result * dir;
let item = items[i+offset];
let curgroup = options.grouperFn(item);
if (curgroup != lastgroup) {
- me.vList.insertItemBefore(i+(offset++), {
+ me.vList.insertItemBefore(i+offset++, {
divider: true,
- group: curgroup
+ group: curgroup,
});
lastgroup = curgroup;
}
url: '/api2/json/quarantine/spam',
data: {
starttime: me.starttime,
- endtime: me.endtime
+ endtime: me.endtime,
},
dataType: 'json',
success: (response, status, xhr) => {
},
error: xhr => {
reject(xhr);
- }
+ },
});
});
}
},
authOK(options) {
var authCookie = PMG.Utils.getCookie('PMGAuthCookie') || "";
- return (authCookie.substr(0,7) === 'PMGQUAR' && Proxmox.UserName !== '');
+ return authCookie.substr(0, 7) === 'PMGQUAR' && Proxmox.UserName !== '';
},
isoToUnix(iso) {
let fields = iso.split('-').map((field) => parseInt(field, 10));
// monthIndex starts at 0
- let date = new Date(fields[0],fields[1]-1, fields[2]);
+ let date = new Date(fields[0], fields[1]-1, fields[2]);
return Math.round(date.getTime()/1000);
},
unixToIso(unix) {
${errorText}
`,
closeButton: true,
- destroyOnClose: true
+ destroyOnClose: true,
});
},
extractParams() {
window.history.replaceState(
window.history.state,
document.title,
- location.pathname + (queryString? "?" + queryString : '')
+ location.pathname + (queryString? "?" + queryString : ''),
);
}
},
error: (xhr, status) => {
reject(xhr);
- }
+ },
});
});
},
gettext("No valid subscription"),
() => {
resolve(data);
- }
+ },
);
} else {
resolve();
resolve();
}
});
- }
- }
+ },
+ },
};
projects / pmg-gui.git / commitdiff