Admin Control Panel v2.0

✎ Editing: iconsole.js ← Back

//create namespace for our functions
var ic = new Object();

ic.url='/cgi-bin/cgictl';

function is_null(some){
    return ( typeof(some)=='undefined' || some==null );
};

/* extend Array class
    removeIndexes(param) where param is index or sorted array of indexes to remove
 */

Array.prototype.removeIndexes=function(inds){
    if (typeof(inds) == 'number')
            this.splice(inds,1);
    else{
            removed=0;
            for(i=0;i<inds.length;i++){
                    this.splice(inds[i]-removed,1);
                    removed++;
            };
    }
    return this;
};

Array.prototype.toStr=function(delim){
    if (typeof(delim)=='undefined')
        delim=',';
    rval='';
    for(i=0;i<this.length;i++){
         rval += this[i] + delim;
    };
    return rval.substring(0,rval.length-delim.length);
}

// function ic_translateError()

function ic_reqSuccess(data, textStatus, callback)
{
	if(!ic.storage.get('sid'))
	{
		ic.__pendingRequests.push(function(){
			ic_reqSuccess(data, textStatus, callback);
		});
		return;
	}

if(data.BLError)
	{
		data.errorMsg = localizeBLError(data.BLError)+" "+data.BLErrorDesc;
	}

// don't pass textStatus
	if(typeof(callback)==='function')
		callback(data);
}

ic.__connectionErrorHandlers    = [];
ic.__connectionRestoredHandlers = [];

ic.registerConnectionErrorHandler = function(func)
{
	ic.__connectionErrorHandlers.push(func);
}

ic.registerConnectionRestoredHandler = function(func)
{
	ic.__connectionRestoredHandlers.push(func);
}

function ic_reqErrorNoSIDCheck(XMLHttpRequest, textStatus, errorThrown, callback)
{
	// let's create object known by the callback
	// FIXME: more flexible and localized error specification
	// should be provided
	var obj = {};
	if(textStatus == 'error')
		obj.errorMsg = 'HTTP Connection error';
	else
		obj.errorMsg =
			' Response: ' + XMLHttpRequest.responseText +
			' Status: ' + textStatus +
			' Error: ' + errorThrown;

if(typeof(callback)=='function')
		callback(obj);
}

ic.__pendingRequests = [];

ic.processPendingRequests = function()
{
	for(var i = 0; i < ic.__pendingRequests.length; i++)
		ic.__pendingRequests[i]();

ic.__pendingRequests = [];
}

ic.request = function(action, callback, _data, method)
{
	var params =
	{
		global     : false,
		type       : is_null(method) ? 'POST' : method,
		beforeSend : function(xhr) {
		               var sid = ic.storage.get('sid');
		               if (sid !== null) {
		                  xhr.setRequestHeader("X-Csrf-Token", sid);
		               }
		             },
		dataType   : 'json',
		cache      : false,
		url        : ic.url + '?action=' + action,
		data       : is_null(_data) ? {} : _data
	};

var isUserLoginAction = (action.indexOf('userLogin') > -1);

params.success = function(a,b)
	{
		if(isUserLoginAction)
			callback(a);
		else if(a.errorMsg == 'Authorization failed')
			__pendRequestAndActivateLoginForm();
		else
			ic_reqSuccess(a, b, callback)
	};
	params.error = function(a,b,c)
	{
		if(isUserLoginAction)
			ic_reqErrorNoSIDCheck(a, b, c, callback);
		else
			ic_reqError(a, b, c, callback)
	};

/*    console.log(params); */

if(!isUserLoginAction && !ic.storage.get('sid'))
		__pendRequestAndActivateLoginForm();
	else
		jQuery.ajax(params);
}

ic.json_get = function(action,callback)
{
	ic.request(action,callback,'','GET');
}

ic.json_post = function(action,data,callback)
{
	if(typeof(data) === 'object')
		data = Object.toQueryString(data);

ic.request(action,callback,data,'POST');
}

/* exceptions */

ic.errorView = {
	errList    : new Array(),
	countNew   : 0,
	countMax   : 200,
	writeError : null,
	countAll   : function(){
		return this.errList.length;
	},
	selectExceptionLink : function() {
		return $('#listControl > div#CONTROL_EXCEPTIONS > a');
	},
	countNewReset : function(){
		this.countNew = 0;
		this.selectExceptionLink().html(_res("CONTROL_EXCEPTIONS"));
	},
	clear : function(){
		this.errList.length=0;
	},
	add : function(txt)
	{
		this.errList.unshift([ txt, new Date().getTime() ]);
		if(this.countMax && this.errList.length >= this.countMax)
			this.errList.pop();

if(window.location.hash == '#exceptions')
			searchForm.doSearch();
		else
		{
			this.countNew += ((this.countMax && this.countNew >= this.countMax) ? 0 : 1);
			this.selectExceptionLink().html(
				'<b style="color:#e00a41">'
					+ _res("CONTROL_EXCEPTIONS")
					+ ' (' + this.countNew + ')</b>');
		}
	}
}

ic.errorViewAppend = function(txt, $errorBox)
{
	if($errorBox && ($errorBox.length > 0))
		$errorBox.html(txt);
	else
		this.errorView.add(txt);
};

ic.errorHandlers = [];

ic.ajaxError = function(data, $errorBox)
{
	if(!data){
		this.errorViewAppend('Null result', $errorBox)
		return true;
	}

for(var i = 0, len = ic.errorHandlers.length; i < len; i++)
		if(true === ic.errorHandlers[i](data, $errorBox))
			return true;

if(data.errorMsg) {
		this.errorViewAppend(data.errorMsg, $errorBox);
		return true;
	}
	return false;
}

/* some statistics and statuses */

ic.getStatistics = function(callback){
	ic.json_get('getStatistics', callback)
};

ic.getConsolidationStatus = function(callback){
	ic.json_get('getConsolidationStatus', callback)
};

ic.getStatusRTP = function(callback){
	ic.json_get('getStatusRTP',callback);
};

/* Getting tasks lists */

ic.listODSTasks = function(callback){
	ic.json_get('listODSTasks',callback);
};

ic.listUpdateTasks = function(callback){
	ic.json_get('listUpdateTasks',callback);
};

/* Various tasks manipulations  */

ic.startTask = function(taskId,callback){
	ic.json_get('startTask'+'&taskId='+taskId,callback);
};

ic.stopTask = function(taskId,callback){
	ic.json_get('stopTask'+'&taskId='+taskId,callback);
};
ic.resumeTask = function(taskId,callback){
	ic.json_get('resumeTask'+'&taskId='+taskId,callback);
};

ic.suspendTask = function(taskId,callback)
{
	ic.json_get('suspendTask'+'&taskId='+taskId,callback);
}

ic.removeTask = function(taskId,callback)
{
	ic.json_get('removeTask'+'&taskId=' + taskId, callback);
}

ic.createTask = function(taskName, taskClass, settings,callback){
	ic.json_post('createTask',
		{
			taskName  : taskName,
			taskClass : taskClass,
			taskSettings  : Object.toJSON(settings)
		},
		callback);
};

ic.getTaskSettings = function(taskId,callback)
{
	ic.json_get('getTaskSettings'+'&taskId='+taskId,callback);
};

ic.getTaskStatistics = function(taskId, callback, params)
{
	var req = '&taskId=' + taskId;
	if(params){
		if(params.checksum)
			req += '&checksum=' + params.checksum;
	}
	ic.json_get('getTaskStatistics' + req, callback)
}

ic.getStructure = function(structureName, callback)
{
	ic.json_get('getStructure'+'&name='+structureName, callback)
}

/* task schedule manipulations */
ic.getTaskSchedule = function(taskId, callback)
{
	ic.json_get('getTaskSchedule'+'&taskId='+taskId, callback);
}

ic.setTaskSchedule = function(taskId, settings, callback){
	ic.json_post('setTaskSchedule',
		{
			'taskId'   : taskId,
			'settings' : Object.toJSON(settings)
		},
		callback);
};

ic.createReport = function(params, callback){
	ic.json_post('createReport', params, callback)
};

ic.getReportList = function(params, callback){
	ic.json_post('getReportList', params, callback)
};

ic.getReportStatus = function(reportId, callback){
	ic.json_get('getReportStatus'+'&reportId='+reportId, callback)
};

ic.removeReports = function(params, callback){
	ic.json_post('removeReports', params, callback);
};

ic.qinfo = function(callback){
	ic.json_get('qinfo', callback);
}
ic.qsearch = function(params, callback){
	ic.json_post('qsearch', params, callback);
};
ic.qrestore = function(params, callback){
	ic.json_post('qrestore', params, callback);
};
ic.qdelete = function(params, callback){
	ic.json_post('qdelete', params, callback);
};
ic.backupSearch = function(params, callback){
	ic.json_post('backupSearch', params, callback);
};
ic.backupRestore = function(params, callback){
	ic.json_post('qrestore', params, callback);
};
ic.backupDelete = function(params, callback){
	ic.json_post('qdelete', params, callback);
};
ic.backupInfo = function(callback){
	ic.json_get('backupInfo', callback);
}

ic._tasks = {};

ic.getTaskList = function(clbk, taskClass){
	if(taskClass)
	{
		ic.json_get('getTaskList' + '&class=' + taskClass,
			function(response){
				if(!ic.errorMsg){
					ic._tasks[ taskClass ] = {};
					for(i = 0; i < response.length; i++) {
						elem = response[i];
						ic._tasks[ taskClass ][ elem.id ] = elem;
					}
				}
				clbk(response);
			});
	}
	else
		ic.json_get('getTaskList', clbk);
};

ic.getTree = function(params, callback){
	ic.json_post('getTree', params, callback);
}

function callFunction( func, arg )
{
	if(jQuery.isFunction(func))
		func(arg);
}

function ic_filterQSClass(clazz)
{
	if(clazz == ic.TaskClass.QS)
		return ic.TaskClass.ODS;
	return clazz;
}

function ic_updateTaskList_handleChange(item, callbacks)
{
	var clazz = ic_filterQSClass(item.clazz);

if(!ic._tasks[clazz] || !ic._tasks[clazz][item.id])
		return; // internal error

var obj = ic._tasks[clazz][item.id];

if(item.change === 'name')
	{
		obj.name = item.name;
		callFunction(callbacks.onNameChange, obj);
	}
	else if(item.change === 'state')
	{
		obj.state = item.state;
		callFunction(callbacks.onStateChange, obj);
	}
	else if(item.change === 'scanned')
	{
		obj.scanned_objects = item.scanned_objects;
		callFunction(callbacks.onScannedChange, obj);
	}
	else if(item.change === 'detected')
	{
		obj.threats_found = item.threats_found;
		callFunction(callbacks.onDetectedChange, obj);
	}
	else if(item.change === 'suspicious')
	{
		obj.suspicious_objects = item.suspicious_objects;
		callFunction(callbacks.onSuspChange, obj);
	}
	else if(item.change === 'schedule')
	{
		obj.schedule = item.schedule;
		callFunction(callbacks.onScheduleChange, obj);
	}
}

function ic_updateTaskList_handleAdd(item, callbacks)
{
	if(!ic._tasks[item.clazz] || !item.id)
		return; // internal error

ic._tasks[item.clazz][item.id] = item;
	callFunction( callbacks.onAddTask, item );
}

function ic_updateTaskList_handleDel(taskId, callbacks)
{
	if(!taskId)
		return; // internal error

callFunction( callbacks.onDeleteTask, taskId );

for(clazz in ic.TaskClass)
		if(ic._tasks[clazz])
			delete ic._tasks[clazz][taskId];
}

function ic_updateTaskList_handleDiff(response, callbacks)
{
	if(ic.ajaxError(response))
		return;

for(var i = 0; i < response.length; i++)
	{
		var item = response[i];
		if(item.change)
			ic_updateTaskList_handleChange(item, callbacks);
		else if(item.add)
			ic_updateTaskList_handleAdd(item.add, callbacks);
		else if(item.del)
			ic_updateTaskList_handleDel(item.del, callbacks);
	}

callFunction( callbacks.onComplete, response );
}

ic.updateTaskList = function(clazz, callbacks)
{
	if(!ic._tasks[clazz])
		return;

ic.json_post( 'updateTaskList',
		{
			'class' : clazz,
			'list'  : Object.toJSON(ic._tasks[clazz])
		},
		function(response){ // onSuccess
			if(callbacks.check(response))
				ic_updateTaskList_handleDiff(response, callbacks);
		}
	);
}

ic._singleTasks = new Object();

ic.getOneTaskByType = function(taskType, clbk)
{
	if(typeof(ic._singleTasks[taskType]) == 'undefined')
		ic.getTaskList(function(response){
			if(response.errorMsg)
				clbk(response);
			else {
				ic._singleTasks[taskType] = response[0].id;
				clbk(response[0]);
			}
		}, taskType);
	else
		ic.getTask(ic._singleTasks[taskType], clbk);
}

ic.getRTPTask = function(clbk)
{
	ic.getOneTaskByType(ic.TaskClass.OAS, clbk);
}

ic.getNotifierTask = function(clbk)
{
	ic.getOneTaskByType(ic.TaskClass.Notifier, clbk);
}

ic.getSnmpTask = function(clbk)
{
	ic.getOneTaskByType(ic.TaskClass.Snmp, clbk);
}

ic.getQuarantineTask = function(clbk)
{
	ic.getOneTaskByType(ic.TaskClass.Quarantine, clbk);
}

ic.getQSTask = function(clbk)
{
	ic.getOneTaskByType(ic.TaskClass.QS, clbk);
}

ic.getTaskHandlers = {};

ic.getTask = function(taskId, clbk, currentState)
{
	if( typeof(ic.getTaskHandlers[taskId]) === 'undefined' )
		ic.getTaskHandlers[taskId] = [];

var len = ic.getTaskHandlers[taskId].length;

ic.getTaskHandlers[taskId][len] = clbk;

if( ic.getTaskHandlers[taskId].length > 1 )
		return;

var req = 'getTask&taskId=' + taskId;
	if(currentState)
		req += '&currentState=' + currentState;

ic.json_get(req, function(response){
		for(i = 0; i < ic.getTaskHandlers[taskId].length; i++)
			ic.getTaskHandlers[taskId][i](response);

ic.getTaskHandlers[taskId].length = 0;
	});
}

ic.setTaskSettings = function(taskId, settings, clbk){
	ic.json_post('setTaskSettings',
		{
			'taskId'   : taskId,
			'settings' : Object.toJSON(settings)
		},
		clbk);
}

ic.setTaskSettingsAndSchedule = function(taskId, settings, schedule, clbk, skipCtimeCheck)
{
	if (typeof settings['ScanScope'] != 'undefined' && typeof settings['ScanScope'].length != 'undefined'){
		for(var i = 0; i < settings['ScanScope'].length; ++i){
			// if user set SizeLimit to 2048Mb, we will substruct 1b to prevent error
			if(settings['ScanScope'][i]['ScanSettings']['SizeLimit'] == 2048 * 1024 * 1024){
				settings['ScanScope'][i]['ScanSettings']['SizeLimit'] -= 1;
			}
		}
	}

var data = {
		'taskId'   : taskId,
		'settings' : Object.toJSON(settings),
		'schedule' : Object.toJSON(schedule),
		'ctime'    : settings.ctime
	};

if(skipCtimeCheck === true)
		data.skipCtimeCheck = true;

ic.json_post('setTaskSettings', data, clbk);
}

ic.getProductSettings = function(callback){
	ic.json_get('getProductSettings',callback);
};

ic.setProductSettings = function(
	productSettings,
	qnbSettings,
	eventStorageSettings,
	callback,
	skipCtimeCheck
){
	var data = {
		'product'      : Object.toJSON(productSettings),
		'qnb'          : Object.toJSON(qnbSettings),
		'eventStorage' : Object.toJSON(eventStorageSettings),
		'ctime'        : productSettings.ctime
	};
	if(skipCtimeCheck === true)
		data.skipCtimeCheck = true;

ic.json_post('setProductSettings', data, callback);
}

ic.getSummary = function(callback){
	ic.json_get('getSummary', callback);
}

ic.searchLogs = function(params, clbk){
	ic.json_post('searchLogs', params, clbk);
}

ic.rollbackBases = function(clbk){
	ic.json_get('rollbackBases', clbk);
}

ic.getRollbackStatus = function(clbk){
	ic.json_get('getRollbackStatus', clbk);
}

/* licenses manipulations */

ic.licenseGet = function(callback){
	ic.json_get('licenseGet',callback);
};

ic.licenseUninstallKey = function(active, callback){
	ic.json_get('licenseUninstallKey'+'&active='+(active?'true':'false'),callback);
};

ic.getTime = function() {
	return new Date().getTime();
}

ic._serialNums = [];

ic.listUsers = function(callback)
{
	ic.json_get('listUsers', callback);
}

ic.listGroups = function(callback)
{
	ic.json_get('listGroups', callback);
}

ic.userLogin = function(user, pass, callback)
{
	ic.json_post('userLogin',
		{
			username : user,
			password : pass
		},
		callback);
}

ic.changePassword = function( currentPassword_, newPassword_, callback )
{
	ic.json_post('changePassword',
		{
			currentPassword : currentPassword_,
			newPassword     : newPassword_
		},
		callback);
}

ic.clearQuarantine = function(callback)
{
	ic.json_get('clearQuarantine',callback);
}

ic.clearBackup = function(callback)
{
	ic.json_get('clearBackup',callback);
}

ic.getProductVersion = function(callback)
{
	ic.json_get('getProductVersion', callback);
}

Cancel