...

(function () {
'use strict';

define('app',[
], function () {

var app = angular.module("JetBackupApp", [
		"ngRoute",
		"ngAnimate",
		"ngSanitize",
		"ngMaterial",
		"ui.bootstrap",
		"permission",
		"permission.ng",
		"angular-loading-bar",
		"moment-picker",
		"chart.js",
		"jm.i18next"
	]).run(["permissions", function(permissions) {
		permissions.init(window.PAGE.permissions);
	}]).config([
		'$routeProvider', '$httpProvider', '$animateProvider', '$controllerProvider', '$compileProvider', '$filterProvider', '$permissionProvider', '$provide', 'cfpLoadingBarProvider',
		function ($routeProvider, $httpProvider, $animateProvider, $controllerProvider, $compileProvider, $filterProvider, $permissionProvider, $provide, cfpLoadingBarProvider) {

$animateProvider.classNameFilter(/(action-module)/);
			$permissionProvider.suppressUndefinedPermissionWarning(true);

cfpLoadingBarProvider.includeSpinner = false;
			cfpLoadingBarProvider.includeBar = true;
			cfpLoadingBarProvider.parentSelector = '#loading-bar-container';

$httpProvider.interceptors.push('responseObserver');
			$httpProvider.defaults.ignoreLoadingBar = true;

app.register = {
				controller: $controllerProvider.register,
				directive: $compileProvider.directive,
				filter: $filterProvider.register,
				factory: $provide.factory,
				service: $provide.service
			};

if(template === 'reseller') {

allPermissions.permissions.except.push('isShowcase');
				allPermissions.permissions.redirectTo.isShowcase = '/showcase';
				
				$routeProvider
				.when('/accounts',						{ templateUrl: path + "/accounts.htm?v=" + version, data: { permissions: { only: 'canManageAccounts', redirectTo: '/' } } })
				.when('/accountsOrphans',				{ templateUrl: path + "/accountsOrphans.htm?v=" + version, data: { permissions: { only: ['canManageAccounts','isReseller'], redirectTo: '/' } } })
				.when('/accountManage/:id',			{ templateUrl: path + "/accountManage.htm?v=" + version, data: { permissions: { only: 'canManageAccounts', redirectTo: '/' } } })
				.when('/alerts',						{ templateUrl: path + "/alerts.htm?v=" + version, data: { permissions: { only: 'canViewAlerts', redirectTo: '/' } } })
				.when('/queue',						{ templateUrl: path + "/queue.htm?v=" + version, data: { permissions: { only: 'canManageQueue', redirectTo: '/' } } })
				.when('/destinations',					{ templateUrl: path + "/destinations.htm?v=" + version, data: { permissions: { only: 'canManageDestinations', redirectTo: '/' } } })
				.when('/destinationManage/:id', 		{ templateUrl: path + "/destinationManage.htm?v=" + version, data: { permissions: { only: 'canManageDestinations', redirectTo: '/' } } })
				.when('/destinationManage', 			{ templateUrl: path + "/destinationManage.htm?v=" + version, data: { permissions: { only: 'canManageDestinations', redirectTo: '/' } } })
				.when("/restoreConditions", 			{ templateUrl: path + "/restoreConditions.htm?v=" + version, data: { permissions: { only: 'isRoot', redirectTo: '/' } } })
				.when("/restoreConditionManage", 		{ templateUrl: path + "/restoreConditionManage.htm?v=" + version, data: { permissions: { only: 'isRoot', redirectTo: '/' } } })
				.when("/restoreConditionManage/:id", 	{ templateUrl: path + "/restoreConditionManage.htm?v=" + version, data: { permissions: { only: 'isRoot', redirectTo: '/' } } })
				.when("/filePermissions", 				{ templateUrl: path + "/filePermissions.htm?v=" + version, data: rootPermissions })
				.when("/filePermissionsManage", 		{ templateUrl: path + "/filePermissionsManage.htm?v=" + version, data: rootPermissions })
				.when("/filePermissionsManage/:id", 	{ templateUrl: path + "/filePermissionsManage.htm?v=" + version, data: rootPermissions })
				.when("/queuePriorities", 				{ templateUrl: path + "/queuePriorities.htm?v=" + version, data: rootPermissions })
				.when("/queuePriorityManage", 			{ templateUrl: path + "/queuePriorityManage.htm?v=" + version, data: rootPermissions })
				.when("/queuePriorityManage/:id", 		{ templateUrl: path + "/queuePriorityManage.htm?v=" + version, data: rootPermissions })
				.when('/permissions',					{ templateUrl: path + "/permissions.htm?v=" + version, data: { permissions: { only: 'canManagePermissions', redirectTo: '/' } } })
				.when('/backupJobs',					{ templateUrl: path + "/backupJobs.htm?v=" + version, data: { permissions: { only: 'canManageBackupJobs', redirectTo: '/' } } })
				.when("/backupJobManage/:id",			{ templateUrl: path + "/backupJobManage.htm?v=" + version, data: { permissions: { only: 'canManageBackupJobs', redirectTo: '/' } } })
				.when("/backupJobManage",				{ templateUrl: path + "/backupJobManage.htm?v=" + version, data: { permissions: { only: 'canManageBackupJobs', redirectTo: '/' } } })
				.when('/cloneJobs',					{ templateUrl: path + "/cloneJobs.htm?v=" + version, data: { permissions: { only: 'canManageCloneJobs', redirectTo: '/' } } })
				.when("/cloneJobManage/:id",			{ templateUrl: path + "/cloneJobManage.htm?v=" + version, data: { permissions: { only: 'canManageCloneJobs', redirectTo: '/' } } })
				.when("/cloneJobManage",				{ templateUrl: path + "/cloneJobManage.htm?v=" + version, data: { permissions: { only: 'canManageCloneJobs', redirectTo: '/' } } })
				.when('/settings', 					{ templateUrl: path + "/settings.htm?v=" + version, data: rootPermissions })
				.when('/settings/:section', 			{ templateUrl: path + "/settings.htm?v=" + version, data: rootPermissions })
				.when('/settings/notification/manage', { templateUrl: path + "/settings/notificationManage.htm?v=" + version, data: rootPermissions })
				.when('/settings/notification/manage/:id', { templateUrl: path + "/settings/notificationManage.htm?v=" + version, data: rootPermissions })
				.when('/security',						{ templateUrl: path + "/security.htm?v=" + version, data: rootPermissions })
				.when('/extension',						{ templateUrl: path + "/extension.htm?v=" + version, data: { permissions: { only: 'isWPIntegration', redirectTo: '/' } } })
				.when('/downloads',					{ templateUrl: path + "/downloads.htm?v=" + version, data: { permissions: { only: 'canDownloadBackups', redirectTo: '/' } } })
				.when('/restore/singleaccount',						{
					templateUrl: path + "/restore.htm?v=" + version,
					controller: 'accountBackups',
					resolve: {
						$uibModalInstance: function () { return {close:function(){}}; },
						account: function() { return null; }
					},
					data: { permissions: { only: 'canManageAccountBackups', redirectTo: '/' } } })
				.when('/restore/:section',						{ templateUrl: path + "/restore.htm?v=" + version, data: { permissions: { only: 'canManageAccountBackups', redirectTo: '/' } } })
				//.when('/restoreSingle',				{ templateUrl: path + "/restoreSingle.htm?v=" + version, controller: "accountBackups", resolve: { $uibModalInstance: function () { return {close:function(){}}; }, account: function() { return window.PAGE.account; } }, data: { permissions: { only: 'canManageAccountBackups', redirectTo: '/' } } })
				.when('/hooks',						{ templateUrl: path + "/hooks.htm?v=" + version, data: { permissions: { only: 'canManageHooks', redirectTo: '/' } } })
				.when("/hookManage",					{ templateUrl: path + "/hookManage.htm?v=" + version, data: { permissions: { only: 'canManageHooks', redirectTo: '/' } } })
				.when("/hookManage/:id",				{ templateUrl: path + "/hookManage.htm?v=" + version, data: { permissions: { only: 'canManageHooks', redirectTo: '/' } } })
				.when('/tags',							{ templateUrl: path + "/tags.htm?v=" + version, data: rootPermissions })
				.when("/tagManage",					{ templateUrl: path + "/tagManage.htm?v=" + version, data: rootPermissions })
				.when("/tagManage/:id",				{ templateUrl: path + "/tagManage.htm?v=" + version, data: rootPermissions })
				.when('/plugins',						{ templateUrl: path + "/plugins.htm?v=" + version, data: rootPermissions })
				.when('/plugins/:section',				{ templateUrl: path + "/plugins.htm?v=" + version, data: rootPermissions })
				.when('/plugin/:plugin',				{ templateUrl: path + "/plugin.htm?v=" + version, data: allPermissions })
				.when('/repositoryManage', 			{ templateUrl: path + "/repositoryManage.htm?v=" + version, data: rootPermissions })
				.when('/repositoryManage/:id', 		{ templateUrl: path + "/repositoryManage.htm?v=" + version, data: rootPermissions })
				.when('/logs', 						{ templateUrl: path + "/logs.htm?v=" + version, data: { permissions: { only: 'canViewLogs', redirectTo: '/' } } })
				.when('/fileManager/:type/:id', 		{ templateUrl: path + "/fileManager.htm?v=" + version, data: { permissions: { only: ['canManageDestinations','canManageFileBackups'], redirectTo: '/' } } })
				//.when("/accountFilterGroups", 			{ templateUrl: path + "/accountFilterGroups.htm?v=" + version, data: { permissions: { only: 'canManageBackupJobs', redirectTo: '/' } } })
				//.when("/accountFilterGroupManage", 		{ templateUrl: path + "/accountFilterGroupManage.htm?v=" + version, data: { permissions: { only: 'canManageBackupJobs', redirectTo: '/' } } })
				//.when("/accountFilterGroupManage/:id", 	{ templateUrl: path + "/accountFilterGroupManage.htm?v=" + version, data: { permissions: { only: 'canManageBackupJobs', redirectTo: '/' } } })
				.when('/accountFilters',				{ templateUrl: path + "/accountFilters.htm?v=" + version, data: { permissions: { only: ['canManageBackupJobs','canManageCloneJobs'], redirectTo: '/' } } })
				.when('/accountFilterManage',			{ templateUrl: path + "/accountFilterManage.htm?v=" + version, data: { permissions: { only: ['canManageBackupJobs','canManageCloneJobs'], redirectTo: '/' } } })
				.when('/accountFilterManage/:id',		{ templateUrl: path + "/accountFilterManage.htm?v=" + version, data: { permissions: { only: ['canManageBackupJobs','canManageCloneJobs'], redirectTo: '/' } } })
				.when('/schedules',				{ templateUrl: path + "/schedules.htm?v=" + version, data: { permissions: { only: ['canManageBackupJobs','canManageCloneJobs'], redirectTo: '/' } } })
				.when('/scheduleManage',			{ templateUrl: path + "/scheduleManage.htm?v=" + version, data: { permissions: { only: ['canManageBackupJobs','canManageCloneJobs'], redirectTo: '/' } } })
				.when('/scheduleManage/:id',		{ templateUrl: path + "/scheduleManage.htm?v=" + version, data: { permissions: { only: ['canManageBackupJobs','canManageCloneJobs'], redirectTo: '/' } } })
				.when('/license', 						{ templateUrl: path + "/license.htm?v=" + version, 	data: { permissions: { only: 'isLicenseIssue', redirectTo: '/' } } })
				.when("/disasterRecovery", 			{ templateUrl: path + "/disasterRecovery.htm?v=" + version, data: { permissions: { only: 'isDisasterRecovery', except: ['isDisableUI', 'isLicenseIssue', 'isAgreement'], redirectTo: '/' } } })
				.when('/agreement', 					{ templateUrl: path + "/agreement.htm?v=" + version, data: { permissions: { only: 'isAgreement', except: ['isDisableUI', 'isLicenseIssue'], redirectTo: '/' } } })
				.when('/agreementPanel', 				{ templateUrl: path + "/agreementPanel.htm?v=" + version, data: { permissions: { only: 'isAgreementPanel', except: ['isDisableUI', 'isLicenseIssue', 'isAgreement','isDisasterRecovery'], redirectTo: '/' } } })
				.when('/disableui', 					{ templateUrl: path + "/disableUI.htm?v=" + version, data: { permissions: { only: 'isDisableUI', except: ['isLicenseIssue'], redirectTo: '/' } } })
				.when('/showcase', 					{ templateUrl: path + "/showcase.htm?v=" + version, data: { permissions: { only: 'isShowcase', except: ['isLicenseIssue', 'isAgreement', 'isAgreementPanel', 'isDisasterRecovery'], redirectTo: '/' } } })
				.when('/support', 						{ templateUrl: path + "/support.htm?v=" + version, data: rootPermissions })
				.when('/404', 							{ templateUrl: path + "/404.htm?v=" + version })
				.when('/myAccount',					{ templateUrl: path + "/myAccount.htm?v=" + version, data: allPermissions })
				.when('/', 							{ templateUrl: path + "/dashboard.htm?v=" + version, data: allPermissions })
				.otherwise('/404');
			} else {
				
				$routeProvider
				.when('/alerts',				{ templateUrl: path + "/alerts.htm?v=" + version, data: { permissions: { only: 'canViewAlerts', redirectTo: '/' } } })
				.when('/queue',				{ templateUrl: path + "/queue.htm?v=" + version, data: { permissions: { only: 'canManageQueue', redirectTo: '/' } } })
				.when('/downloads',			{ templateUrl: path + "/downloads.htm?v=" + version, data: { permissions: { only: 'canDownloadBackups', redirectTo: '/' } } })
				.when('/restore/:type',		{ templateUrl: path + "_enduser/restore.htm?v=" + version, data: { permissions: { only: 'canManageAccountBackups', redirectTo: '/' } } })
				.when('/disableui', 					{ templateUrl: path + "/disableUI.htm?v=" + version, data: { permissions: { only: 'isDisableUI', except: ['isLicenseIssue'], redirectTo: '/' } } })
				.when('/license', 						{ templateUrl: path + "_enduser/rootActionRequired.htm?v=" + version, 	data: { permissions: { only: 'isLicenseIssue', redirectTo: '/' } } })
				.when('/plugin/:plugin',				{ templateUrl: path + "/plugin.htm?v=" + version, data: allPermissions })
				.when('/disasterRecovery', 			{ templateUrl: path + "_enduser/rootActionRequired.htm?v=" + version, data: { permissions: { only: 'isDisasterRecovery', except: ['isDisableUI', 'isLicenseIssue', 'isAgreement'], redirectTo: '/' } } })
				.when('/agreement', 					{ templateUrl: path + "_enduser/rootActionRequired.htm?v=" + version, data: { permissions: { only: 'isAgreement', except: ['isDisableUI', 'isLicenseIssue'], redirectTo: '/' } } })
				.when('/agreementPanel', 				{ templateUrl: path + "/agreementPanel.htm?v=" + version, data: { permissions: { only: 'isAgreementPanel', except: ['isDisableUI', 'isLicenseIssue', 'isAgreement','isDisasterRecovery'], redirectTo: '/' } } })
				.when('/404', 						{ templateUrl: path + "/404.htm?v=" + version })
				.when('/myAccount',					{ templateUrl: path + "/myAccount.htm?v=" + version, data: allPermissions })
				.when('/', 							{ templateUrl: path + "_enduser/dashboard.htm?v=" + version, data: allPermissions })
				.otherwise('/404');
			}
		}
	]).controller("JetBackup",
		["$rootScope", "$scope", "$location", "$route", "$timeout", "lang", "permissions", "consts", "util", "api", "alert", "$uibModalStack",
			function($rootScope, $scope, $location, $route, $timeout, lang, permissions, consts, util, api, alert, $uibModalStack) {
			
				$rootScope.util = util;
				$rootScope.const = consts;
				$rootScope.perm = permissions;
				$rootScope.lang = lang;
				$rootScope.path = window.PAGE.path;
				$rootScope.template = window.PAGE.template;
				$rootScope.primaryURL = $rootScope.path.location + window.location.search + '#!';
				$rootScope.loggedAccount = window.PAGE.account;
				$rootScope.license = window.PAGE.license;
				$rootScope.plugins = window.PAGE.plugins;
				$rootScope.avx_enabled = window.PAGE.avxenabled;
				$rootScope.logoutURL = window.PAGE.logout_url !== undefined ? window.PAGE.logout_url : '';

$rootScope.reloadPage = function () {
					window.location.reload();
				};
				
				app.registerPluginController = function(plugin, callback) {
					app.registerController(
						plugin.type + plugin.code,
						'plugins/' + plugin.type + '/' + plugin.code,
						callback
					);
				};

app.registerShowcaseController = function(showcase, callback) {
					app.registerController(
						showcase.feature + showcase.order,
						'showcase/' + showcase.order + "_" + showcase.feature,
						callback
					);
				};

app.registerController = function(controllerName, controllerPath, callback) {
					if(callback === undefined || typeof callback !== 'function') callback = function() {};

var controllerFile = controllerPath + '/controller';

require.undef(controllerFile);
					require([controllerFile], function () {
						var queue = app._invokeQueue;
						for(var i = 0; i < queue.length; i++) {
							var controller = queue[i];
							var pattern = new RegExp("^" + controllerName + "($|_)");
							if(controller[0] !== '$controllerProvider' || controller[1] !== 'register' || !pattern.test(controller[2][0])) continue;
							app.register.controller(controller[2][0], controller[2][1]);
						}

$timeout(callback($scope.path.media + '/app/' + controllerPath, controllerName));
					});
				};

$rootScope.includePath = function(file, views) {
					if(!file) return '';
					if(!views) views = 'views';
					return $rootScope.path.media + '/app/' + views + '/' + file + '.htm?v=' + $rootScope.info.version;
				};

$rootScope.downloadURL = function (args) {
					var sep = /\?/.test($scope.path.download) ? '&' : '?';
					return $scope.path.download + sep + args;
				};

$rootScope.changeView = function(view) {
					$uibModalStack.dismissAll();
					$location.path(view);
				};

$rootScope.info = window.PAGE.info;
				$rootScope.info.currentYear = new Date().getUTCFullYear();

$rootScope.menuItem = 'Dashboard';
				$rootScope.$on('menuItem', function(event, item) { $rootScope.menuItem = item; });

$rootScope.menuExpanded = !!parseInt(localStorage.getItem('menuExpanded'));
				$scope.toggleMenu = function() {
					$rootScope.menuExpanded = !$rootScope.menuExpanded;
					localStorage.setItem('menuExpanded', $scope.menuExpanded ? 1 : 0);
				};

$rootScope.expandedRow = {};
				$rootScope.openActions = function(row, group) {
					if(group === undefined) group = 'general';
					$rootScope.expandedRow[group] = ($rootScope.expandedRow[group] !== undefined && $rootScope.expandedRow[group] === row) ? undefined : row;
				};

$rootScope.isOpenedActions = function(row, group) {
					if(group === undefined) group = 'general';
					return $rootScope.expandedRow[group] === row;
				};

$rootScope.$on('$routeChangeStart', function() { lang.initNS('dashboard'); });

$rootScope.processStatus = true;
				$rootScope.processSyncAccountsStatus = true;
				$rootScope.inRescueMode = true;
				$rootScope.canDeleteSnapshots = false;

$scope.checkProcess = function () {
					api.getProcessStatus({
						withLoader: false,
						success: function(data) {
							$rootScope.processStatus = !!data.status;
							$rootScope.processSyncAccountsStatus = !data.sync_accounts;
							$rootScope.inRescueMode = !!data.rescue;
							$rootScope.canDeleteSnapshots = !!data.delete_snapshots;

// if service is up check every 30 sec, if down every 5 sec
							setTimeout($scope.checkProcess, $rootScope.processStatus && $rootScope.processSyncAccountsStatus ? 30000 : 2000);
						},
						failed: function (message) {
							alert.error(message);
						}
					});
				};

$scope.checkProcess();
			}
		]
	).factory('responseObserver', ["$q", "storage", function responseObserver($q, storage) {
		return {
			responseError: function(errorResponse) {

var apiConfig = storage.create('api');

// On valid response - reset the counter
				if(errorResponse.status < 300) {
					apiConfig.set('failedCounter', 0);
					apiConfig.save();
				}
				// On invalid response - count for 5 seconds and then reload the page
				else {
					var now = (new Date()).getTime();
					var failedCounter = apiConfig.get('failedCounter', 0);
					if(failedCounter == 0) failedCounter = now;

if((now - failedCounter) >= 10000) {
						apiConfig.set('failedCounter', 0);
						apiConfig.save();
						location.reload();
					} else {
						apiConfig.set('failedCounter', failedCounter);
						apiConfig.save();
					}
				}

return $q.reject(errorResponse);
			}
		};
	}]);

return app;
});

define('controllers/404',['app'], function(app) {
	app.controller("404",
		["$rootScope", "$scope", "cfpLoadingBar",
			function ($rootScope, $scope, cfpLoadingBar) {
				cfpLoadingBar.complete();
			}
		]
	);
});

define('controllers/myAccount',['app'], function(app) {
	app.controller("myAccount",
		["$rootScope", "$scope", "$location", "$timeout", "$interval", "$q", "api", "meta", "lang", "filter", "util", "consts", "confirm", "alert",
			function ($rootScope, $scope, $location, $timeout, $interval, $q, api, meta, lang, filter, util, consts, confirm, alert) {
				$rootScope.$emit('menuItem', 'Accounts');

$scope.info = {};
				$scope.details = {
					email: '',
					backup_type: 0,
					encryption_key: 0,
					privacy: 0
				};

$scope.saveData = util.duplicateObject($scope.details);

$scope.encryptionKey = '';
				$scope.currentEncryptionKey = '';
				$scope.saveing = false;
				$scope.changed = false;

$scope.$watch("saveData", function(){
					$scope.changed = util.isChanged($scope.saveData, $scope.details, ['_id']);
				}, true);

$scope.$on('$destroy', function() {
					if($scope.changed && !$scope.cancelled)
					{
						confirm.open({
							message: lang.t("You didn't saved your changes"),
							confirm: $scope.saveChanges,
							cancelLabel: lang.t("Disregard Changes"),
							confirmLabel: lang.t("Save"),
						});
					}
				});

$scope.requireEncryptionKey = function() {
					return ($scope.details.backup_type == 1 && $scope.details.encryption_key_type == 1 &&
						($scope.saveData.backup_type != 1 || $scope.saveData.encryption_key_type != 1));
				};

$scope.resetEncryptionKey = function() {

confirm.open({
						message: lang.t("Once you reset the account encryption key, ALL BACKUPS becomes inaccessible and will be deleted."),
						confirmLabel: lang.t("Delete Encryption Key"),
						confirm: function () {
							api.resetEncryptionKey({ 
								data: { _id: $scope.details._id }, 
								success: function (data, message) {
									$scope.details.secret_key = false;
									alert.success(message);
								},
								failed: function (message) {
									alert.error(message);
								}
							});
						}
					});
				};

$scope.saveChanges = function() {

if($scope.saveing) return;

$scope.saveing = true;

var apiParams = util.saveParams($scope.saveData, $scope.details);
					if($scope.currentEncryptionKey) apiParams.encryption_key = $scope.currentEncryptionKey;

$scope.encryptionKey = '';
					$scope.currentEncryptionKey = '';

api.manageMyAccount({ 
						data: apiParams,
						success: function(data, message) {
							$scope.saveing = false;
							$scope.changed = false;
							$scope.details = util.duplicateObject($scope.saveData);
							if(data.encryption_key !== undefined) $scope.encryptionKey = data.encryption_key;
							alert.success(message);
						},
						failed: function (message) {
							$scope.saveing = false;
							alert.error(message);
						}
					});
				};

$scope.fetchAccountData = function() {

api.getMyAccount({
						success: function(data) {
							$scope.info = data.info;
							delete data.info;
							$scope.details = data;
							$scope.saveData = util.duplicateObject($scope.details);
						}
					});
				};

$timeout(function () {
					$scope.fetchAccountData();
				});

}
		]
	);
});

define('controllers/agreement',['app'], function(app) {
	app.controller("agreement",
		["$rootScope", "$scope", "$location", "api", "alert", "lang", "permissions",
			function ($rootScope, $scope, $location, api, alert, lang, permissions) {

$scope.currYear = new Date().getYear() + 1900;

$scope.setAgree = function () {

api.approveAgreement({
						success: function() {
							window.PAGE.system.agreement = false;
							permissions.init(window.PAGE.permissions);
							$location.path('/');
						},
						failed: function (message) {
							alert.error(message);
						}
					});
				}
			}
		]
	);
});

define('controllers/agreementPanel',['app'], function(app) {
	app.controller("agreementPanel",
		["$rootScope", "$scope", "$location", "api", "alert", "lang", "permissions",
			function ($rootScope, $scope, $location, api, alert, lang, permissions) {

$scope.details = {};
				$scope.approve = {
					user_agreement: 0,
					privacy_policy: 0
				};

$scope.togglePrivacyPolicy = function() {
					$scope.approve.privacy_policy = $scope.approve.privacy_policy == 0 ? 1 : 0;
				};

$scope.toggleUserAgreement = function() {
					$scope.approve.user_agreement = $scope.approve.user_agreement == 0 ? 1 : 0;
				};

$scope.currYear = new Date().getYear() + 1900;

$scope.continueToPanel = function () {

if($scope.approve.user_agreement == 0 || $scope.approve.privacy_policy == 0) {
						alert.error(lang.t("You must accept User Agreement and Privacy Policy in order to continue to panel"));
						return;
					}

api.manageMyAccount({ 
						data: { terms: 1 }, 
						success: function() {
							window.PAGE.system.agreement_panel = false;
							permissions.init(window.PAGE.permissions);
							$location.path('/');
						},
						failed: function (message) {
							alert.error(message);
						}
					});
				};

api.getMyAccount({ 
					success: function(data) {
						$scope.details = data.info;
					}
				});

}
		]
	);
});
define('controllers/dashboard',[
	'app',
], function(app) {
	app.controller("dashboard",
		["$rootScope", "$scope", "$location", "$timeout", "$interval", "api", "meta", "lang", "consts", "permissions", "alert",
			function($rootScope, $scope, $location, $timeout, $interval, api, meta, lang, consts, permissions, alert) {

$rootScope.$emit('menuItem', 'Dashboard');

$scope.stats = {
					alerts: 0,
					accounts: 0,
					backup_jobs: 0,
					clone_jobs: 0,
					backups: 0,
					over_quota: 0,
					backup_jobs_running: 0,
					clone_jobs_running: 0
				};

$scope.loadingStatistics = true;
				$scope.loadingDestinations = false;
				$scope.loadingBackups = false;
				$scope.loadingClones = false;
				$scope.loadingQueues = false;
				$scope.loadingAlerts = false;
				$scope.destroyed = false;

$scope.lockDestinations = false;
				$scope.lockBackups = false;
				$scope.lockClones = false;

$scope.queue_summary = {};
				$scope.alerts = [];
				$scope.destinations = [];
				$scope.backups = [];
				$scope.clones = [];
				$scope.queues = [];
				$scope.reloadTimeout = undefined;

$scope.destinationMeta = meta.new("dashboard_destinations");
				$scope.destinationMetaData = $scope.destinationMeta.getData();
				$scope.destinationMeta.setSortBy("jobs_count");
				$scope.destinationMeta.setSortDirection("asc");
				$scope.destinationMeta.setTotalItems($scope.destinations.length);
				$scope.destinationMeta.setPageSizes([5,10,25]);
				$scope.destinationMeta.setPageSize(5);
				$scope.destinationMeta.setLimit(5);
				$scope.destinationMeta.setMaxPages(1);

$scope.backupMeta = meta.new("dashboard_backups");
				$scope.backupMetaData = $scope.backupMeta.getData();
				$scope.backupMeta.setSortBy("next_run");
				$scope.backupMeta.setSortDirection("asc");
				$scope.backupMeta.setTotalItems($scope.backups.length);
				$scope.backupMeta.setPageSizes([5,10,25]);
				$scope.backupMeta.setPageSize(5);
				$scope.backupMeta.setLimit(5);
				$scope.backupMeta.setMaxPages(1);

$scope.cloneMeta = meta.new("dashboard_clones");
				$scope.cloneMetaData = $scope.cloneMeta.getData();
				$scope.cloneMeta.setSortBy("next_run");
				$scope.cloneMeta.setSortDirection("asc");
				$scope.cloneMeta.setTotalItems($scope.clones.length);
				$scope.cloneMeta.setPageSizes([5,10,25]);
				$scope.cloneMeta.setPageSize(5);
				$scope.cloneMeta.setLimit(5);
				$scope.cloneMeta.setMaxPages(1);

$scope.queueMeta = meta.new("dashboard_queues");
				$scope.queueMetaData = $scope.queueMeta.getData();
				$scope.queueMeta.setSortBy("created");
				$scope.queueMeta.setSortDirection("desc");
				$scope.queueMeta.setTotalItems($scope.queues.length);
				$scope.queueMeta.setPageSizes([5,10,25]);
				$scope.queueMeta.setPageSize(5);
				$scope.queueMeta.setLimit(5);

$scope.fetchData = function(callback) {

if(callback === undefined | typeof callback !== 'function') callback = function() {};

api.getDashboardDetails({
						success: function(data, message) {

$scope.stats.alerts = data.statistics.total_new_alerts;
							$scope.stats.accounts = data.statistics.total_accounts;
							$scope.stats.backup_jobs = data.statistics.total_backup_jobs;
							$scope.stats.clone_jobs = data.statistics.total_clone_jobs;
							$scope.stats.backups = data.statistics.total_backups;
							$scope.stats.disk_usage = data.statistics.total_disk_usage;
							$scope.stats.backup_jobs_running = data.statistics.total_backup_jobs_running;
							$scope.stats.clone_jobs_running = data.statistics.total_clone_jobs_running;
							$scope.alerts = data.alerts.alerts;
							$scope.queue_summary = data.queue_summary;

$scope.destinationMeta.setTotalItems(data.destinations.total);
							$scope.destinationMeta.calculate(data.destinations.destinations);
							$scope.destinations = data.destinations.destinations;

$scope.backupMeta.setTotalItems(data.backup_jobs.total);
							$scope.backupMeta.calculate(data.backup_jobs.jobs);
							$scope.backups = data.backup_jobs.jobs;

for(var i = 0; i < $scope.backups.length; i++) {
								var names = [];
								var contains = parseInt($scope.backups[i].contains);

if(contains == consts.BACKUP_TYPE_ACCOUNT_FULL) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_FULL]);
								else if($scope.backups[i].type == consts.BACKUP_TYPE_DIRECTORY) names.push(consts.BACKUP_TYPE_DIRECTORY_NAMES[consts.BACKUP_TYPE_DIRECTORY_FULL]);
								else {
									if(contains & consts.BACKUP_TYPE_ACCOUNT_CONFIG) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_CONFIG]);
									if(contains & consts.BACKUP_TYPE_ACCOUNT_HOMEDIR) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_HOMEDIR]);
									if(contains & consts.BACKUP_TYPE_ACCOUNT_DATABASES) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_DATABASES]);
									if(contains & consts.BACKUP_TYPE_ACCOUNT_EMAILS) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_EMAILS]);
									if(contains & consts.BACKUP_TYPE_ACCOUNT_CRON_JOBS) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_CRON_JOBS]);
									if(contains & consts.BACKUP_TYPE_ACCOUNT_DOMAINS) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_DOMAINS]);
									if(contains & consts.BACKUP_TYPE_ACCOUNT_CERTIFICATES) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_CERTIFICATES]);
								}

$scope.backups[i].contains_name = names.join(', ');
							}

$scope.cloneMeta.setTotalItems(data.clone_jobs.total);
							$scope.cloneMeta.calculate(data.clone_jobs.jobs);
							$scope.clones = data.clone_jobs.jobs;

for(var i = 0; i < $scope.clones.length; i++) {
								var names = [];
								var contains = parseInt($scope.clones[i].contains);

if(contains == consts.BACKUP_TYPE_ACCOUNT_FULL) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_FULL]);
								else if($scope.clones[i].type == consts.BACKUP_TYPE_DIRECTORY) names.push(consts.BACKUP_TYPE_DIRECTORY_NAMES[consts.BACKUP_TYPE_DIRECTORY_FULL]);
								else {
									if(contains & consts.BACKUP_TYPE_ACCOUNT_CONFIG) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_CONFIG]);
									if(contains & consts.BACKUP_TYPE_ACCOUNT_HOMEDIR) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_HOMEDIR]);
									if(contains & consts.BACKUP_TYPE_ACCOUNT_DATABASES) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_DATABASES]);
									if(contains & consts.BACKUP_TYPE_ACCOUNT_EMAILS) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_EMAILS]);
									if(contains & consts.BACKUP_TYPE_ACCOUNT_CRON_JOBS) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_CRON_JOBS]);
									if(contains & consts.BACKUP_TYPE_ACCOUNT_DOMAINS) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_DOMAINS]);
									if(contains & consts.BACKUP_TYPE_ACCOUNT_CERTIFICATES) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_CERTIFICATES]);
								}

$scope.clones[i].contains_name = names.join(', ');
							}

$scope.queueMeta.setTotalItems(data.queue.total);
							$scope.queueMeta.calculate(data.queue.groups);

$scope.queues = [];
							for(var i = 0; i < data.queue.groups.length; i++) {
								var group = data.queue.groups[i];
								if(parseInt(group.items_completed) <= 0 || parseInt(group.items) <= 0) group.items_progress_percentage = 0
								else group.items_progress_percentage = parseInt((parseInt(group.items_completed) / parseInt(group.items)) * 100);
								$scope.queues.push(group);
							}

callback();
						},
						failed: function (message) {
							alert.error(message);
							callback();
						}
					});
				};

/*
				$scope.interval = $interval(function () {
					$scope.fetchData();
				}, 10000);

$scope.$on("$destroy", function() {
					if ($scope.interval === undefined) return;
					$interval.cancel($scope.interval);
					$scope.interval = undefined;
				});
				*/

$scope.$on('fetch', fetch);

function fetch() {
					$scope.loadingStatistics = true;
					$scope.fetchData(function() {
						$scope.loadingStatistics = false;
					});
				}

$scope.reloadData = function() {

api.getDashboardDetails({
						withLoader: false,
						success: function(data) {

$scope.stats.alerts = data.statistics.total_new_alerts;
							$scope.stats.accounts = data.statistics.total_accounts;
							$scope.stats.jobs = data.statistics.total_backup_jobs;
							$scope.stats.backups = data.statistics.total_backups;
							$scope.stats.disk_usage = data.statistics.total_disk_usage;
							$scope.stats.jobs_running = data.statistics.total_backup_jobs_running;
							$scope.alerts = data.alerts.alerts;
							$scope.queue_summary = data.queue_summary;

$scope.listDestinations(false, function () {
								$scope.listBackupJobs(false, function () {
									$scope.listQueueItems(false, function () {
										if($scope.destroyed) return;
										$scope.reloadTimeout = setTimeout($scope.reloadData, 5000);
									});
								});
							});
						}
					});
				};

$scope.reloadTimeout = setTimeout($scope.reloadData, 5000);
				
				$scope.toggleDestinationStatus = function(destination) {

if($scope.lockDestinations) return;

api.manageDestination({ 
						data: { action: 'modify', _id: destination._id, disabled: !destination.disabled },
						success: function(data) {
							destination.disabled = data.disabled;
						},
						failed: function (message) {
							alert.error(message);
						}
					});
				};

$scope.toggleBackupJobStatus = function(job) {

if($scope.lockBackups) return;

api.manageBackupJob({ 
						data: { action: 'modify', _id: job._id, disabled: !job.disabled }, 
						success: function(data) {
							job.disabled = data.disabled;
						},
						failed: function (message) {
							alert.error(message);
						}
					});
				};

$scope.toggleCloneJobStatus = function(job) {

if($scope.lockClones) return;

api.manageCloneJob({
						data: { action: 'modify', _id: job._id, disabled: !job.disabled },
						success: function(data) {
							job.disabled = data.disabled;
						},
						failed: function (message) {
							alert.error(message);
						}
					});
				};

$scope.listDestinations = function(loading, callback) {
					if(loading === undefined) loading = true;
					if(callback === undefined || typeof callback != 'function') callback = function(){};

if(!loading) {
						$scope.loadingDestinations = false;
						$scope.lockDestinations = true;
					} else {
						$scope.destinations = [];
						$scope.loadingDestinations = true;
					}

var sort = {};
					sort[$scope.destinationMeta.getSortBy()] = $scope.destinationMeta.getSortDirectionInt();

api.listDestinations({
						withLoader: loading,
						data: {
							sort: sort,
							skip: $scope.destinationMeta.getSkip(),
							limit: $scope.destinationMeta.getPageSize()
						}, 
						success: function(data) {
							callback();
							setTimeout(function () { $scope.lockDestinations = false; }, 300);
							$scope.destinationMeta.setTotalItems(data.total);
							$scope.destinationMeta.calculate(data.destinations);
							$scope.destinations = data.destinations;
							$scope.loadingDestinations = false;
						},
						failed: function () {
							callback();
							setTimeout(function () { $scope.lockDestinations = false; }, 300);
							$scope.loadingDestinations = false;
						}
					});
				};

$scope.listBackupJobs = function(loading, callback) {
					if(callback === undefined || typeof callback != 'function') callback = function(){};

if(loading !== undefined && !loading) {
						$scope.loadingBackups = false;
						$scope.lockBackups = true;
					} else {
						$scope.backups = [];
						$scope.loadingBackups = true;
					}

var sort = {};
					sort[$scope.backupMeta.getSortBy()] = $scope.backupMeta.getSortDirectionInt();

api.listBackupJobs({
						withLoader: loading,
						data: {
							sort: sort,
							skip: $scope.backupMeta.getSkip(),
							limit: $scope.backupMeta.getPageSize()
						}, 
						success: function(data) {
							callback();
							
							setTimeout(function () { $scope.lockBackups = false; }, 300);
	
							$scope.loadingBackups = false;
	
							$scope.backupMeta.setTotalItems(data.total);
							$scope.backupMeta.calculate(data.jobs);
							$scope.backups = data.jobs;
	
							for(var i = 0; i < $scope.backups.length; i++) {
								var names = [];
								var contains = parseInt($scope.backups[i].contains);
	
								if(contains == consts.BACKUP_TYPE_ACCOUNT_FULL) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_FULL]);
								else if($scope.backups[i].type == consts.BACKUP_TYPE_DIRECTORY) names.push(consts.BACKUP_TYPE_DIRECTORY_NAMES[consts.BACKUP_TYPE_DIRECTORY_FULL]);
								else {
									if(contains & consts.BACKUP_TYPE_ACCOUNT_CONFIG) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_CONFIG]);
									if(contains & consts.BACKUP_TYPE_ACCOUNT_HOMEDIR) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_HOMEDIR]);
									if(contains & consts.BACKUP_TYPE_ACCOUNT_DATABASES) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_DATABASES]);
									if(contains & consts.BACKUP_TYPE_ACCOUNT_EMAILS) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_EMAILS]);
									if(contains & consts.BACKUP_TYPE_ACCOUNT_CRON_JOBS) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_CRON_JOBS]);
									if(contains & consts.BACKUP_TYPE_ACCOUNT_DOMAINS) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_DOMAINS]);
									if(contains & consts.BACKUP_TYPE_ACCOUNT_CERTIFICATES) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_CERTIFICATES]);
								}
	
								$scope.backups[i].contains_name = names.join(', ');
							}
						},
						failed: function () {
							callback();
							setTimeout(function () { $scope.lockBackups = false; }, 300);
							$scope.loadingBackups = false;
						}
					});
				};
				
				$scope.listCloneJobs = function(loading, callback) {
					if(callback === undefined || typeof callback != 'function') callback = function(){};

if(loading !== undefined && !loading) {
						$scope.loadingClones = false;
						$scope.lockClones = true;
					} else {
						$scope.clones = [];
						$scope.loadingClones = true;
					}

var sort = {};
					sort[$scope.cloneMeta.getSortBy()] = $scope.cloneMeta.getSortDirectionInt();

api.listCloneJobs({
						withLoader: loading,
						data: {
							sort: sort,
							skip: $scope.cloneMeta.getSkip(),
							limit: $scope.cloneMeta.getPageSize()
						},
						success: function(data) {
							callback();

setTimeout(function () { $scope.lockClones = false; }, 300);

$scope.loadingClones = false;

$scope.cloneMeta.setTotalItems(data.total);
							$scope.cloneMeta.calculate(data.jobs);
							$scope.clones = data.jobs;

for(var i = 0; i < $scope.clones.length; i++) {
								var names = [];
								var contains = parseInt($scope.clones[i].contains);

$scope.clones[i].contains_name = names.join(', ');
							}
						},
						failed: function () {
							callback();
							setTimeout(function () { $scope.lockClones = false; }, 300);
							$scope.loadingClones = false;
						}
					});
				};

$scope.listQueueItems = function(loading, callback) {
					
					if(callback === undefined || typeof callback != 'function') callback = function(){};
					
					if(loading !== undefined && !loading) $scope.loadingQueues = false;
					else {
						$scope.queues = [];
						$scope.loadingQueues = true;
					}

var sort = {};
					sort[$scope.queueMeta.getSortBy()] = $scope.queueMeta.getSortDirectionInt();

var type = consts.QUEUE_ITEM_TYPE_BACKUP | consts.QUEUE_ITEM_TYPE_CLONE | consts.QUEUE_ITEM_TYPE_REINDEX;
					if(permissions.canRestoreBackups) type |= consts.QUEUE_ITEM_TYPE_RESTORE;
					if(permissions.canDownloadBackups) type |= consts.QUEUE_ITEM_TYPE_DOWNLOAD;
					if(permissions.isRoot) type |= (consts.QUEUE_ITEM_TYPE_SECURITY | consts.QUEUE_ITEM_TYPE_INTEGRITY_CHECK | consts.QUEUE_ITEM_TYPE_SNAPSHOT_DELETE | consts.QUEUE_ITEM_TYPE_EXTENSION_INSTALLATION | consts.QUEUE_ITEM_TYPE_EXTENSION_QUEUE);

api.listQueueGroups({
						withLoader: loading,
						data: {
							sort: sort,
							skip: $scope.queueMeta.getSkip(),
							limit: $scope.queueMeta.getPageSize(),
							type: type
						}, 
						success: function(data) {
							callback();
							$scope.loadingQueues = false;
							$scope.queueMeta.setTotalItems(data.total);
							$scope.queueMeta.calculate(data.groups);
	
							$scope.queues = [];
							for(var i = 0; i < data.groups.length; i++) {
								var group = data.groups[i];
								if(parseInt(group.items_completed) <= 0 || parseInt(group.items) <= 0) group.items_progress_percentage = 0
								else group.items_progress_percentage = parseInt((parseInt(group.items_completed) / parseInt(group.items)) * 100);
								$scope.queues.push(group);
							}
						},
						failed: function () {
							callback();
							$scope.loadingQueues = false;
						}
					});
				};

$scope.$on("$destroy", function() {
					$scope.destroyed = true;
					if ($scope.reloadTimeout === undefined) return;
					clearTimeout($scope.reloadTimeout);
					$scope.reloadTimeout = undefined;
				});

$timeout(fetch);
			}
		]
	);
});

define('controllers/alerts',['app'], function(app) {
	app.controller("alerts",
		["$rootScope", "$scope", "$location", "$timeout", "api", "meta", "consts", "lang", "confirm", "alert",
			function ($rootScope, $scope, $location, $timeout, api, meta, consts, lang, confirm, alert) {
				$rootScope.$emit('menuItem', 'Alerts');

$scope.alerts = [];
				$scope.loadingAlerts = false;
				$scope.saveing = false;
				$scope.filter = 0;
				$scope.filterOptions = [
					{ label: lang.t('All Alerts'), value: 0 },
					{ label: lang.t('Information Alerts'), value: consts.ALERT_LEVEL_INFO },
					{ label: lang.t('Warning Alerts'), value: consts.ALERT_LEVEL_WARNING },
					{ label: lang.t('Critical Alerts'), value: consts.ALERT_LEVEL_CRITICAL }
				];

meta = meta.new("alerts");
				$scope.meta = meta;
				$scope.metaData = meta.getData();

if(!meta.getSortBy()) meta.setSortBy("created");
				if(!meta.getSortDirection()) meta.setSortDirection("desc");
				meta.setSortFields(["created","message","owner","level"]);
				meta.setTotalItems($scope.alerts.length);

$scope.clearAlerts = function () {

if($scope.saveing) return;
					$scope.saveing = true;

confirm.open({
						message: lang.t("All alerts will be deleted and no future notifications will be sent"),
						confirm: function () {
							api.clearAlerts({
								success: function(data, message) {
									$scope.saveing = false;
									$scope.fetch();
									alert.success(message);
								},
								failed: function (message) {
									$scope.saveing = false;
									alert.error(message);
								}
							});
						},
						cancel: function () {
							$scope.saveing = false;
						}
					});
				};
				
				$scope.fetch = function() {

$scope.loadingAlerts = true;

var find = {};
					if(parseInt($scope.filter) > 0) find.level = parseInt($scope.filter);

var apiParams = {
						sort: {},
						skip: meta.getSkip(),
						limit: meta.getPageSize(),
						find: find,
						filter: meta.getFilter()
					};

apiParams.sort[meta.getSortBy()] = meta.getSortDirectionInt();

$scope.alerts = [];

api.listAlerts({ 
						data: apiParams, 
						success: function(data) {
							meta.setTotalItems(data.total);
							meta.calculate(data.alerts);
							$scope.alerts = data.alerts;
							$scope.loadingAlerts = false;
						}
					});
				};

$timeout($scope.fetch);
			}
		]
	);
});

define('controllers/accounts',['app'], function(app) {
	app.controller("accounts",
		["$rootScope", "$scope", "$location", "$timeout", "api", "lang", "meta", "confirm", "alert", "consts", "util", "permissions", "popup",
			function ($rootScope, $scope, $location, $timeout, api, lang, meta, confirm, alert, consts, util, permissions, popup) {

$rootScope.$emit('menuItem', 'Accounts');

$scope.accounts = [];
				$scope.tags = {};
				$scope.loadingAccounts = false;
				$scope.deleteTag = false;
				$scope.filter = '';

if(permissions.isRoot) {
					$scope.filterOptions = [
						{label: lang.t("No Tags Filter"), value: ""},
						{label: lang.t("Without Any Tags"), value: "none"}
					];
				} else {
					$scope.filterOptions = [];
				}

$scope.loaders = {
					quota: false,
					snapshot: false
				};

var metaAcct = meta.new("accounts");
				$scope.meta = metaAcct;
				$scope.metaData = metaAcct.getData();

metaAcct.setSortReverse(false);
				if(!metaAcct.getSortBy()) metaAcct.setSortBy("username");
				if(!metaAcct.getSortDirection()) metaAcct.setSortDirection("asc");
				metaAcct.setSortFields(["username", "owner"]);
				metaAcct.setTotalItems($scope.accounts.length);

$scope.manageTags = function(account) {
					popup.open({
						template: 'tagsSelection',
						resolve: {
							tags: function() { return account.tags; },
							type: function () { return consts.TAG_TYPE_ACCOUNT; }
						}
					}).result.then(function(selected) {

account.deletetags = true;
						api.manageAccount({ 
							data: { _id: account._id, tags: selected }, 
							success: function () {
								account.deletetags = false;
								account.tags = selected;
							},
							failed: function (message) {
								account.deletetags = false;
								alert.error(message);
							}
						});

}, function () {});
				};

$scope.removeTag = function(account, index) {

if($scope.deleteTag) return;
					$scope.deleteTag = true;

confirm.open({
						message: lang.t("This tag will be removed from this account"),
						confirm: function () {
							account.deletetags = true;

var tags = util.duplicateObject(account.tags);
							tags.splice(index, 1);

api.manageAccount({ 
								data: { _id: account._id, tags: tags }, 
								success: function () {
									$scope.deleteTag = false;
									account.deletetags = false;
									account.tags.splice(index, 1);
								},
								failed: function (message) {
									$scope.deleteTag = false;
									account.deletetags = false;
									alert.error(message);
								}
							});
						},
						cancel: function () {
							$scope.deleteTag = false;
						}
					});
				};

$scope.reassign = function (account) {
					popup.open({
						size: "lg",
						template: 'accountReassign',
						resolve: {
							account_details: function() { return account; }
						}
					}).result.then(function(refresh) {
						if(refresh) $scope.fetch();
					}, function(){
						$scope.fetch();
					});
				};

$scope.createSnapshot = function(account) {

if($scope.loaders.snapshot) return;
					$scope.loaders.snapshot = true;

confirm.open({
						message: lang.t("Are you sure you want to create backup on demand for this account?"),
						confirm: function () {

api.createBackupOnDemand({
								data: { account_id: account._id },
								success: function(data, message) {
									$scope.loaders.snapshot = false;
									alert.success(message);
								},
								failed: function(message) {
									$scope.loaders.snapshot = false;
									alert.error(message);
								}
							});
						},
						cancel: function () {
							$scope.loaders.snapshot = false;
						}
					});
				};

$scope.viewBackups = function (account) {
					popup.open({
						size: "xl",
						template: 'accountBackups',
						resolve: {
							account: function() { return account; }
						}
					}).result.then(function(refresh) {
						if(refresh) $scope.fetch();
					}, function(){});
				};

$scope.viewDownloads = function (account) {
					popup.open({
						size: "xl",
						template: 'accountDownloads',
						resolve: {
							account: function() { return account; }
						}
					}).result.then(function() {}, function(){});
				};

$scope.fetch = function() {

$scope.loadingAccounts = true;

var apiParams = {
						sort: {},
						skip: metaAcct.getSkip(),
						limit: metaAcct.getPageSize(),
						find: {},
						filter: metaAcct.getFilter()
					};

apiParams.sort[metaAcct.getSortBy()] = metaAcct.getSortDirectionInt();
					if($scope.filter) apiParams.find.tags = $scope.filter;

$scope.accounts = [];

api.listAccounts({ 
						data: apiParams, 
						success: function(data) {
							metaAcct.setTotalItems(data.total);
							metaAcct.calculate(data.accounts);
							$scope.accounts = data.accounts;
							$scope.loadingAccounts = false;
						}
					});
				};

if(permissions.isRoot) {
					api.listTags({ 
						data: { find: { type: consts.TAG_TYPE_ACCOUNT } }, 
						success: function (data) {
							for(var i = 0; i < data.tags.length; i++) {
								$scope.filterOptions.push({label: data.tags[i].name, value: data.tags[i]._id});
								$scope.tags[data.tags[i]._id] = data.tags[i];
							}
							$timeout($scope.fetch);
						}
					});
				} else {
					$timeout($scope.fetch);
				}
	}]);
});

define('controllers/accountsOrphans',['app'], function(app) {
	app.controller("accountsOrphans",
		["$rootScope", "$scope", "$location", "$timeout", "api", "lang", "meta", "popup", "permissions", "consts",
			function ($rootScope, $scope, $location, $timeout, api, lang, meta, popup, permissions, consts) {

$rootScope.$emit('menuItem', 'Accounts');

$scope.accounts = [];
				$scope.tags = {};
				$scope.loadingAccounts = false;
				$scope.deleteTag = false;
				$scope.filter = '';

$scope.loaders = {
					quota: false,
				};

var metaAcct = meta.new("accountsOrphans");
				$scope.meta = metaAcct;
				$scope.metaData = metaAcct.getData();

account.deletetags = true;
						api.manageAccount({
							data: { _id: account._id, tags: selected },
							success: function () {
								account.deletetags = false;
								account.tags = selected;
							},
							failed: function (message) {
								account.deletetags = false;
								alert.error(message);
							}
						});

}, function () {});
				};

$scope.removeTag = function(account, index) {

if($scope.deleteTag) return;
					$scope.deleteTag = true;

confirm.open({
						message: lang.t("This tag will be removed from this account"),
						confirm: function () {
							account.deletetags = true;

var tags = util.duplicateObject(account.tags);
							tags.splice(index, 1);

api.manageAccount({
								data: { _id: account._id, tags: tags },
								success: function () {
									$scope.deleteTag = false;
									account.deletetags = false;
									account.tags.splice(index, 1);
								},
								failed: function (message) {
									$scope.deleteTag = false;
									account.deletetags = false;
									alert.error(message);
								}
							});
						},
						cancel: function () {
							$scope.deleteTag = false;
						}
					});
				};

$scope.viewBackups = function (account) {

popup.open({
						size: "xl",
						template: 'accountBackups',
						resolve: {
							account: function() { return account; }
						}
					}).result.then(function(refresh) {
						if(refresh) $scope.fetch();
					}, function(){});

};

$scope.viewDownloads = function (account) {

popup.open({
						size: "xl",
						template: 'accountDownloads',
						resolve: {
							account: function() { return account; }
						}
					}).result.then(function() {}, function(){});

};

$scope.fetch = function() {

$scope.loadingAccounts = true;

var apiParams = {
						sort: {},
						skip: metaAcct.getSkip(),
						limit: metaAcct.getPageSize(),
						find: {},
						filter: metaAcct.getFilter()
					};

apiParams.sort[metaAcct.getSortBy()] = metaAcct.getSortDirectionInt();
					if($scope.filter) apiParams.find.tags = $scope.filter;
					apiParams.orphan = 1;

$scope.accounts = [];

if(permissions.isRoot) {
					api.listTags({
						data: { find: { type: consts.TAG_TYPE_ACCOUNT } },
						success: function (data) {
							for(var i = 0; i < data.tags.length; i++) {
								$scope.filterOptions.push({label: data.tags[i].name, value: data.tags[i]._id});
								$scope.tags[data.tags[i]._id] = data.tags[i];
							}
							$timeout($scope.fetch);
						}
					});
				} else {
					$timeout($scope.fetch);
				}
	}]);
});

define('controllers/accountManage',['app'], function(app) {
	
	app.controller("accountManage",
		["$rootScope", "$scope", "$routeParams", "$q", "$location", "$timeout", "api", "meta", "util", "lang", "confirm", "alert", "consts", "popup",
			function ($rootScope, $scope, $routeParams, $q, $location, $timeout, api, meta, util, lang, confirm, alert, consts, popup) {
				$rootScope.$emit('menuItem', 'Accounts');

if(!$routeParams.id) $location.path("/");

$scope.tags = {};
				$scope.details = {
					email: '',
					max_snapshots: '',
					queue_priority: ''
				};

$scope.saveData = util.duplicateObject($scope.details);

$scope.saveing = false;
				$scope.changed = false;
				$scope.cancelled = false;

$scope.queuePriorities = [
						{ _id: '', name: lang.t('Default') }
				];

$scope.$watch("saveData", function(){
					$scope.changed = util.isChanged($scope.saveData, $scope.details, ['_id']);
				}, true);

$scope.searchTags = function(query) {

if(!query) return [];

var deferred = $q.defer();

api.listTags({ 
						data: { filter: query, sort: { name: 1 }, find: { type: consts.TAG_TYPE_ACCOUNT } }, 
						success: function(data) {

var results = [];
							for(var i = 0; i < data.tags.length; i++) {
								var tag = data.tags[i];
								if($scope.saveData.tags.indexOf(tag._id) >= 0) continue;
								results.push(tag);
							}
							deferred.resolve( results );
						}
					});

return deferred.promise;
				};

$scope.selectItem = function(item, obj) {
					if(item === undefined) return;
					$scope.saveData.tags.push(item._id);
					obj.searchItemText = '';
				};

$scope.manageTags = function() {

popup.open({
						template: 'tagsSelection',
						scope: $scope,
						resolve: {
							tags: function() { return $scope.saveData.tags; },
							type: function () { return consts.TAG_TYPE_ACCOUNT; }
						}
					}).result.then(function(selected) {
						$scope.saveData.tags = selected;
					}, function () {});

};

$scope.resetEncryptionKey = function() {

confirm.open({
						message: lang.t("Once you reset the account encryption key, ALL BACKUPS becomes inaccessible and will be deleted."),
						confirmLabel: lang.t("Delete Encryption Key"),
						confirm: function () {
							api.resetEncryptionKey({ 
								data: { username: $scope.details.username }, 
								success: function (data, message) {
									$scope.details.secret_key = false;
									alert.success(message); 
								},
								failed: function (message) {
									alert.error(message);
								}
							});
						}
					});
				};

$scope.manageExcludes = function () {

popup.open({
						size: "lg",
						template: 'accountExcludeListSelection',
						resolve: {
							account: function() { return $scope.details; }
						}
					}).result.then(function() {}, function(){});

};

$scope.fetchQueuePriorities = function() {

api.listQueuePriorities({ 
						success: function (data) {
							var priorities = data.priorities;
							for(var i=0; i< priorities.length; i++ ){
								$scope.queuePriorities.push(priorities[i]);
							}
						},
						failed: function (message) {
							alert.error(message);
						}
					});
				};

$scope.cancel = function() {
					$scope.cancelled = true;
					$location.path('/accounts');
				};

$scope.saveChanges = function(apply) {

if($scope.saveing) return;

$scope.saveing = true;

var apiParams = util.saveParams($scope.saveData, $scope.details);

api.manageAccount({ 
						data: apiParams, 
						success: function(data, message) {
							$scope.saveing = false;
							$scope.changed = false;
							$scope.details.email = $scope.saveData.email;
							$scope.details.max_snapshots = $scope.saveData.max_snapshots;
							//$location.path('/accountManage/' + $scope.details._id);
							if(!apply) $location.path('/accounts');
							alert.success(message);
						},
						failed: function (message) {
							$scope.saveing = false;
							alert.error(message);
						}
					});
				};

$scope.fetchAccountData = function(id) {
					api.getAccount({ 
						data: { _id: id }, 
						success: function(data) {
							$scope.details = data;
							$scope.saveData = util.duplicateObject($scope.details);
						}
					});
				};

$scope.fetchTags = function() {
					api.listTags({ 
						data: { find: { type: consts.TAG_TYPE_ACCOUNT } }, 
						success: function (data) {
							for(var i = 0; i < data.tags.length; i++) $scope.tags[data.tags[i]._id] = data.tags[i];
						}
					});
				};

$timeout(function () {
					$scope.fetchTags();
					$scope.fetchQueuePriorities();
					$scope.fetchAccountData($routeParams.id);
				});
			}
		]
	);
});

define('controllers/accountReassign',['app'], function(app) {
	
	app.controller("accountReassign",
		["$uibModalInstance", "$scope", "$location", "$timeout", "api", "meta", "util", "lang", "confirm", "alert", "account_details",
			function ($uibModalInstance, $scope, $location, $timeout, api, meta, util, lang, confirm, alert, account_details) {

$scope.saveing = false;
				$scope.account = account_details;
				$scope.accounts = [];
				$scope.loadingAccounts = false;
				$scope.refresh = false;

var metaAcct = meta.new("account_reassign");
				$scope.meta = metaAcct;
				$scope.metaData = metaAcct.getData();

metaAcct.setSortReverse(false);
				if(!metaAcct.getSortBy()) metaAcct.setSortBy("active");
				if(!metaAcct.getSortDirection()) metaAcct.setSortDirection("desc");
				metaAcct.setPageSizes([5,10]);
				metaAcct.setPageSize(10);
				metaAcct.setSortFields(["active"]);
				metaAcct.setTotalItems($scope.accounts.length);

$scope.reassignAccount = function(account) {
					if($scope.saveing) return;
					$scope.saveing = true;

confirm.open({
						message: lang.t("This account will be reassign to different account data, including backups and personal information."),
						confirm: function () {
							api.reassignAccount({ 
								data: { _id: account._id }, 
								success: function(data, message) {
									$scope.saveing = false;
									$scope.refresh = true;
									$scope.fetch();
									alert.success(message);
								},
								failed: function (message) {
									$scope.saveing = false;
									alert.error(message);
								}
							});
						},
						cancel: function () {
							$scope.saveing = false;
						}
					});
				};

$scope.fetch = function() {

$scope.loadingAccounts = true;

var apiParams = {
						sort: {},
						skip: metaAcct.getSkip(),
						limit: metaAcct.getPageSize(),
						find: {},
						filter: metaAcct.getFilter()
					};

apiParams.account = $scope.account.username;
					apiParams.sort[metaAcct.getSortBy()] = metaAcct.getSortDirectionInt();

$scope.accounts = [];

api.listAssignableAccounts({ 
						data: apiParams, 
						success: function(data) {
							metaAcct.setTotalItems(data.total);
							metaAcct.calculate(data.accounts);
							$scope.accounts = data.accounts;
							$scope.loadingAccounts = false;
						},
						failed: function () {
							$location.path('/accounts');
						}
					});
				};

$timeout($scope.fetch);

$scope.ok = function () { $uibModalInstance.close($scope.refresh); };

}
		]
	);
});

define('controllers/accountExcludeListSelection',['app'], function(app) {

app.controller('accountExcludeListSelection',
		["$uibModalInstance", "$scope", "alert", "lang", "api", "consts", "popup", "account",
			function($uibModalInstance, $scope, alert, lang, api, consts, popup, account) {

$scope.account = account;
				$scope.excludes = {};
				$scope.excluderow = '';
				$scope.selected_job = "global";
				$scope.jobs = [
					{ _id: 'global', name: "- " + lang.t("All Backup Jobs (Global)") + " -" }
				];

api.getAccountExcludeList({ 
					data: { _id: account._id }, 
					success: function (data) {
						$scope.excludes = data;
					}
				});

api.listBackupJobs({ 
					data: { find: { type: consts.BACKUP_TYPE_ACCOUNT } }, 
					success: function (data) {
						for(var i = 0; i < data.jobs.length; i++) {
							$scope.jobs.push(data.jobs[i]);
							if($scope.excludes[data.jobs[i]._id] === undefined) $scope.excludes[data.jobs[i]._id] = [];
						}
					}
				});

var checkDuplicateItems = function(value) {
					var withoutTrailing = value.replace(/\/+$/, '');
					var withTrailing = withoutTrailing + '/';
					return ($scope.excludes[$scope.selected_job].indexOf(withoutTrailing) >= 0 || $scope.excludes[$scope.selected_job].indexOf(withTrailing) >= 0);
				};

var validateListPath = function (path) {
					if(!path.trim()) return false;
					return !consts.PATH_FILTER_PATTERNS.test(path);
				};

$scope.addMultiListRow = function() {

$scope.listTitle = lang.t("Directories and Files to exclude");
					$scope.listData = $scope.excludes[$scope.selected_job].join("\n");

$scope.listUIB = popup.open({
						size: "xl",
						template: 'listSelection',
						scope: $scope,
						noController: true
					});
					
					$scope.listUIB.result.then(function(records) {
						while($scope.excludes[$scope.selected_job].length) $scope.excludes[$scope.selected_job].pop();
						records = records.split("\n");
						var invalidPaths = [];
						var duplicatePaths = [];
						for(var i = 0; i < records.length; i++) {
							if(checkDuplicateItems(records[i])) duplicatePaths.push(records[i]);
							else if(validateListPath(records[i])) {
								if ($scope.excludes[$scope.selected_job].indexOf(records[i]) < 0 ) $scope.excludes[$scope.selected_job].push(records[i]);
							}
							else invalidPaths.push(records[i]);
						}

if(invalidPaths.length) alert.error(lang.t('The following paths ("%s") is invalid. The path must start with a "/" and can\'t have trailing "/"' + (type === 'include' ? ', also patterns are not allowed.' : '.'), invalidPaths.join(", ") ))
						if(duplicatePaths.length) alert.error(lang.t('The provided path(s) ("%s") already exists on the list.', duplicatePaths.join(", ")));
					}, function () { });
				};

$scope.addListRow = function() {

var path = $scope.excluderow.trim();

if(checkDuplicateItems(path)){
						alert.error(lang.t('The provided path ("%s") already exists on the list.', path));
					} else if(validateListPath(path)) {
						$scope.excludes[$scope.selected_job].push(path);
					} else {
						alert.error(lang.t('The provided path ("%s") is invalid. The path must start with a "/"', path ));
					}

$scope.excluderow = '';
				};

$scope.ok = function () {
					api.manageAccountExcludeList({ 
						data: { _id: $scope.account._id, excludes: $scope.excludes }, 
						success: function (data, message) {
							$uibModalInstance.close();
							alert.success(message);
						},
						failed: function (message) {
							alert.error(message);
						}
					});
				};

$scope.cancel = function () {
					$uibModalInstance.dismiss(lang.t('cancel'));
				};
	}]);

});

define('controllers/modifyDatabasesExcludes',['app'], function(app) {
	app.controller('modifyDatabasesExcludes',
		["$uibModalInstance", "$rootScope", "$scope", "$routeParams", "$location", "permissions", "lang", "db_excludes",
			function($uibModalInstance, $rootScope, $scope, $routeParams, $location, permissions, lang, db_excludes) {

$scope.dbExcludesSections = [
					{ _id: 'mysql',			name: lang.t('MySQL'),		template: 'modifyMySQLExcludes',		icon: 'fa-database', 	hidden: false },
					{ _id: 'postgresql',	name: lang.t('PostgreSQL'),	template: 'modifyPostgreSQLExcludes',	icon: 'fa-database', 	hidden: false },
					{ _id: 'mongodb',		name: lang.t('MongoDB'),	template: 'modifyMongoDBExcludes',		icon: 'fa-database', 	hidden: false },
				];

$scope.getDBExcludesSection = function (section_id) {
					for(var i = 0; i < $scope.dbExcludesSections.length; i++) {
						if($scope.dbExcludesSections[i]._id === section_id) {
							return $scope.dbExcludesSections[i];
						}
					}

return $scope.dbExcludesSections[0];
				};

$scope.loadDBExcludesSection = function (section) {
					$scope.currentDBExcludesSection = section;
					$scope.dbExcludesSection = $scope.includePath(section.template);
				};

$scope.loadDBExcludesSection($scope.getDBExcludesSection($routeParams.section ? $routeParams.section : 'mysql'));

if (db_excludes === undefined)
					db_excludes = { mysql_exclude_db_by_size: 0, postgresql_exclude_db_by_size: 0, mongodb_exclude_db_by_size: 0 };

$scope.excludes = {
					mysql_exclude_db_by_size: db_excludes.mysql_exclude_db_by_size,
					postgresql_exclude_db_by_size: db_excludes.postgresql_exclude_db_by_size,
					mongodb_exclude_db_by_size: db_excludes.mongodb_exclude_db_by_size,
				};

$scope.ok = function () {
					$uibModalInstance.close($scope.excludes);
				};
		
				$scope.cancel = function () {
					$uibModalInstance.dismiss(lang.t('cancel'));
				};
	}]);

});

define('controllers/destinations',['app'], function(app) {
	app.controller("destinations",
		["$rootScope", "$scope", "$location", "$timeout", "api", "meta", "lang", "alert", "confirm", "consts",
			function ($rootScope, $scope, $location, $timeout, api, meta, lang, alert, confirm, consts) {
				$rootScope.$emit('menuItem', 'Destinations');

$scope.loadingDestinations = false;
				$scope.destinations = [];
				$scope.checkReindexTimeout = undefined;
				$scope.types = {};
				$scope.filter = '';
				$scope.filterOptions = [{ label: lang.t('All Destinations'), value: '' }];
				$scope.saveing = false;
				$scope.jobs = {};

$scope.loaders = {
					state: false,
					validation: false,
					dr: false,
					hide: false,
					delete: false,
					reindex: false,
					speed: false
				};

meta = meta.new("destinations");
				$scope.meta = meta;
				$scope.metaData = meta.getData();

if(!meta.getSortBy()) meta.setSortBy("name");
				if(!meta.getSortDirection()) meta.setSortDirection("asc");
				meta.setSortFields(["name","type","owner","engine","count","disabled","dr"]);
				meta.setTotalItems($scope.destinations.length);

$scope.onClickDelete = function(destination) {

if($scope.saveing) return;

if(destination.jobs_count > 0) {
						alert.error(lang.t("This destination has an assigned jobs, Please remove those jobs before deleting this destination."));
						return false;
					}

$scope.saveing = true;
					$scope.loaders.delete = true;

confirm.open({
						message: lang.t("This destination will be permanently deleted!"),
						confirm: function () {
							api.deleteDestination({ 
								data: { _id: destination._id }, 
								success: function(data, message) {
									$scope.saveing = false;
									$scope.loaders.delete = false;
									$scope.fetch();
									alert.success(message);
								},
								failed: function (message) {
									$scope.saveing = false;
									$scope.loaders.delete = false;
									alert.error(message);
								}
							});
						},
						cancel: function () {
							$scope.saveing = false;
							$scope.loaders.delete = false;
						}
					});
				};

$scope.measureSpeed = function (destination) {
					if($scope.saveing) return;
					$scope.saveing = true;
					$scope.loaders.speed = true;

confirm.open({
						message: lang.t("JetBackup will use a 100MB file for the speed test, and depending on your destination, charges may apply."),
						confirm: function () {
							api.measureDestinationSpeed({
								data: { _id: destination._id },
								success: function(data, message) {
									$scope.saveing = false;
									$scope.loaders.speed = false;
									alert.success(message);
									destination.speed = data.speed;
								},
								failed: function (message) {
									$scope.saveing = false;
									$scope.loaders.speed = false;
									alert.error(message);
								}
							});
						},
						cancel: function () {
							$scope.saveing = false;
							$scope.loaders.speed = false;
						}
					});

};
				
				$scope.reindex = function(destination) {
					if($scope.saveing) return;
					$scope.saveing = true;
					$scope.loaders.reindex = true;

confirm.open({
						message: lang.t("All running processes (backup, restore and etc) related to this destination will be aborted"),
						confirm: function () {
							api.reindexDestination({ 
								data: { _id: destination._id }, 
								success: function(data, message) {
									$scope.saveing = false;
									$scope.loaders.reindex = false;
									alert.success(message);
									destination.reindex = true;
									$scope.checkReindex();
								},
								failed: function (message) {
									$scope.saveing = false;
									$scope.loaders.reindex = false;
									alert.error(message);
								}
							});
						},
						cancel: function () {
							$scope.saveing = false;
							$scope.loaders.reindex = false;
						}
					});
				};

$scope.toggleDR = function(destination) {
					$scope.loaders.dr = true;
					var dr = !destination.dr;
					apiDestination({
						_id: destination._id,
						action: 'modify',
						dr: dr
					}, function(response) {
						$scope.loaders.dr = false;
						if(response.success) destination.dr = dr;
					});
				};

$scope.toggleStatus = function(destination) {
					$scope.loaders.state = true;
					var disabled = !destination.disabled;

if(!disabled && destination.type !== 'Clones') {

var model = confirm.open({
							message: lang.t("WARNING: By Enabling the Destination you are also enabling automated tasks to run in the background for this destination. This could result in backups being cleaned using the Manual Backups TTL or Orphan Backups TTL settings. Are you sure you want to enable and perform background tasks on the destination?"),
							buttons: [
								{
									label: lang.t("Change Settings"),
									class: 'btn-primary',
									click: function () {
										$location.path("/settings");
										model.dismiss();
									}
								}
							],
							confirm: function () {

if($scope.saveing) return;
								$scope.saveing = true;

api.manageDestinationState({
									data: { 
										_id: destination._id,
										disabled: disabled
									},
									success: function(data, message) {
										$scope.saveing = false;
										$scope.loaders.state = false;
										destination.disabled = disabled;
										alert.success(message);
									},
									failed: function (message) {
										$scope.saveing = false;
										$scope.loaders.state = false;
										alert.error(message);
									}
								});
							},
							cancel: function () {
								$scope.loaders.state = false;
							}
						});

} else {

if($scope.saveing) return;
						$scope.saveing = true;

api.manageDestinationState({
							data: {
								_id: destination._id,
								disabled: disabled
							},
							success: function(data, message) {
								$scope.saveing = false;
								$scope.loaders.state = false;
								destination.disabled = disabled;
								alert.success(message);
							},
							failed: function (message) {
								$scope.saveing = false;
								$scope.loaders.state = false;
								alert.error(message);
							}
						});
					}
				};

$scope.toggleHidden = function(destination) {
					$scope.loaders.hide = true;
					var hidden = !destination.hidden;
					apiDestination({
						_id: destination._id,
						action: 'modify',
						hidden: hidden
					}, function(response) {
						$scope.loaders.hide = false;
						if(response.success) destination.hidden = hidden;
					});
				};

$scope.validateDestination = function(destination) {
					if($scope.saveing) return;
					$scope.saveing = true;
					$scope.loaders.validation = true;

api.validateDestination({ 
						data: { _id: destination._id }, 
						success: function(data, message) {
							$scope.saveing = false;
							$scope.loaders.validation = false;
							alert.success(message);
						},
						failed: function (message) {
							$scope.saveing = false;
							$scope.loaders.validation = false;
							alert.error(message);							
						}
					});
				};

$scope.listDestinations = function(callback) {
					if(callback === undefined || typeof callback != 'function') callback = function(){};

var apiParams = {
						sort: {},
						skip: meta.getSkip(),
						limit: meta.getPageSize(),
						find: {},
						filter: meta.getFilter()
					};

if($scope.filter) apiParams.find.type = $scope.filter;
					apiParams.sort[meta.getSortBy()] = meta.getSortDirectionInt();

api.listDestinations({ 
						data: apiParams, 
						success: function (data, message) { callback({ success: true, data: data, message: message}); },
						failed: function (data, message) { callback({ success: false, data: data, message: message}); }
					});
				};

$scope.fetch = function() {
					if($scope.loadingDestinations) return;
					$scope.loadingDestinations = true;
					$scope.listDestinations(function (response) {

$scope.destinations = [];
						$scope.loadingDestinations = false;
						meta.setTotalItems(response.data.total);
						meta.calculate(response.data.destinations);

var reindex = false;
						for(var i = 0; i < response.data.destinations.length; i++) {
							var destination = response.data.destinations[i];
							$scope.destinations.push(destination);
							if(destination.reindex) reindex = true;
						}

if(reindex) $scope.checkReindex();
					});
				};

$scope.getDestination = function(destination_id) {
					for(var i = 0; i < $scope.destinations.length; i++) {
						if($scope.destinations[i]._id == destination_id) return $scope.destinations[i];
					}
					return null;
				};

$scope.checkReindex = function() {
					$scope.listDestinations(function (response) {

var reindex = false;
						for(var i = 0; i < response.data.destinations.length; i++) {
							var destination_new = response.data.destinations[i];
							if(destination_new.reindex) reindex = true;

var destination = $scope.getDestination(destination_new._id);
							if(destination) destination.reindex = destination_new.reindex;
						}

if(reindex) $scope.checkReindexTimeout = setTimeout($scope.checkReindex, 3000);
					});
				};

$scope.$on('$destroy', function() {
					if(!$scope.checkReindexTimeout) return;
					clearTimeout($scope.checkReindexTimeout);
					$scope.checkReindexTimeout = null;
				});

api.listDestinationTypes({
					/*data: {
						types: consts.DESTINATION_JOB_TYPE_BACKUP
					},*/
					success: function (data) {
						$scope.types = data;
						for(var i = 0; i < data.types.length; i++) {
							$scope.filterOptions.push({ label: consts.DESTINATION_JOB_TYPE_NAMES[data.types[i].type] + ' - ' + data.types[i].name, value: data.types[i].key });
						}
					}
				});

api.listBackupJobs({ 
					success: function (data) {
						for(var i = 0; i < data.jobs.length; i++) {
							var job = data.jobs[i];
	
							for(var j = 0; j < job.destination.length; j++) {
								if($scope.jobs[job.destination[j]] === undefined) $scope.jobs[job.destination[j]] = [];
								$scope.jobs[job.destination[j]].push(job);
							}
						}
					}
				});

$timeout($scope.fetch);
			}
		]
	);
});

define('controllers/destinationManage',['app'], function(app) {
	app.controller("destinationManage",
		["$rootScope", "$scope", "$routeParams", "$q", "$location", "$timeout", "api", "meta", "util", "confirm", "permissions", "lang", "consts", "alert",
			function ($rootScope, $scope, $routeParams, $q, $location, $timeout, api, meta, util, confirm, permissions, lang, consts, alert) {
				$rootScope.$emit('menuItem', 'Destinations');

$scope.details = {};
				$scope.saveData = {
					job_type: consts.DESTINATION_JOB_TYPE_BACKUP,
					type: '',
					owner: $scope.loggedAccount._id,
					owner_name: $scope.loggedAccount.username,
					disk_limit: 95,
					threads: 150,
					readonly: 0,
					options: {}
				};

$scope.forks = {
					backup: 0,
					queueable: 0,
					system: 0,
					total: 0,
				};

$scope.autocomplete = { accountText: $scope.saveData.owner_name };

$scope.saveing = false;
				$scope.changed = true;
				$scope.forkThreads = 0;
				//$scope.cancelled = false;
				$scope.types = {};
				$scope.types[consts.DESTINATION_JOB_TYPE_BACKUP] = [];
				$scope.types[consts.DESTINATION_JOB_TYPE_CLONE] = [];
				$scope.publicDir = '';
				$scope.plugin = {};
				$scope.plugin_available = {};
				$scope.plugins_available = {};
				$scope.installing = false;
				$scope.experimental = '';

$scope.disklimits = [
					{ label: lang.t("Disabled"), value: 0 },
					{ label: "50%", value: 50 },
					{ label: "55%", value: 55 },
					{ label: "60%", value: 60 },
					{ label: "65%", value: 65 },
					{ label: "70%", value: 70 },
					{ label: "75%", value: 75 },
					{ label: "80%", value: 80 },
					{ label: "85%", value: 85 },
					{ label: "90%", value: 90 },
					{ label: "95%", value: 95 }
				];

$scope.isAvailableDestinations = function() {
					return $scope.saveData.type && $scope.saveData.type.indexOf('AvailableDestinations') >= 0;
				};

$scope.selectAccount = function(account) {
					if(account === undefined) return;
					$scope.saveData.owner = account._id;
					$scope.saveData.owner_name = account.username;
					$scope.autocomplete.accountText = account.username;
					var activeElement = document.activeElement;
					if (activeElement) activeElement.blur();
				};

$scope.searchAccounts = function(query) {
					if(query) {
						var deferred = $q.defer();
						api.listAccounts({ 
							data: { login_only: 1, filter: query, sort: { username: 1 } }, 
							success: function(data) {
								var results = [];
								for(var i = 0; i < data.accounts.length; i++) results.push(data.accounts[i]);
								deferred.resolve( results );
							}
						});

return deferred.promise;
					}

return [];
				};

$scope.resetOptions = function () {
					//$scope.saveData.options = {};
					$scope.options = {
						disklimit: true,
						threads: false
					};
				};
				
				$scope.loadTemplate = function(type) {
					if(!type) return;

if(type.indexOf('::') >= 0) {
						var parts = type.split('::');
						type = parts[0];
						$scope.plugin_available = $scope.plugins_available[parts[1]];
					}

$scope.resetOptions();

switch(type) {
						case 'AvailableDestinations':
							$scope.destinationType = $scope.includePath('destinations/' + type);
							$scope.experimental = $scope.plugin_available.experimental !== undefined ? $scope.plugin_available.experimental : '';
						break;

default:
							if($scope.plugin[type] === undefined) return;
							lang.setDefaultNS('plugins-destination-' + type);
							app.registerPluginController($scope.plugin[type], function(path) {
								$scope.publicDir = path;
								$scope.destinationType = $scope.publicDir + '/view.htm?v=' + $scope.plugin[type].version;
								$scope.experimental = $scope.plugin[type].experimental;
							});
						break;
					}
				};

$scope.loadDestinationType = function(resetOptions) {
					if(resetOptions === undefined) resetOptions = false;
					if(resetOptions) $scope.saveData.options = {};
					$scope.loadTemplate($scope.saveData.type);
				};

$scope.toggleEngine = function(details) {
					if(details === undefined) return;
					if(details.checked) details.engine = 1;
					return details.checked;
				};

$scope.resetOptions();

$scope.$on('options', function (event, options) {
					for(var key in options) $scope.options[key] = options[key];
				});

$scope.$watch("saveData.job_type", function(){
					if($routeParams.id) return;
					
					if($scope.types[$scope.saveData.job_type][0] !== undefined) {
						$scope.details.type = $scope.types[$scope.saveData.job_type][0].value;
						$scope.saveData.type = $scope.types[$scope.saveData.job_type][0].value;
						$scope.loadDestinationType();
					} else {
						$scope.details.type = '';
						$scope.saveData.type = '';
					}
				}, true);

$scope.$watch("saveData", function(){
					$scope.changed = util.isChanged($scope.saveData, $scope.details, ['_id']);
					$scope.forkThreads = $scope.forks.total > 0 ? Math.ceil($scope.saveData.threads / $scope.forks.total) : 0;
				}, true);

$scope.$on('$destroy', function() {
					if(!$scope.changed || $scope.cancelled || $scope.disasterRecovery) return;

confirm.open({
						message: lang.t("You didn't saved your changes"),
						confirm: $scope.saveChanges,
						cancelLabel: lang.t("Disregard Changes"),
						confirmLabel: lang.t("Save"),
					});
				});

$scope.cancel = function() {
					//$scope.cancelled = true;
					$location.path('/destinations');
				};

$scope.saveChanges = function(apply, callback) {

if($scope.saveing) return;

$scope.saveing = true;

var apiParams = util.saveParams($scope.saveData, $scope.details, [], function(key) {
						return ($scope.details._id === undefined && key === 'type');
					});

apiParams.action = $scope.details._id ? 'modify' : 'create';

api.manageDestination({ 
						data: apiParams, 
						success: function(data, message) {
							$scope.saveing = false;
							$scope.details = data;
							$scope.saveData = util.duplicateObject($scope.details);
	
							if(callback === undefined) {
								if(apply) $location.path('/destinationManage/' + data._id);
								else $location.path('/destinations');
								alert.success(message);
							}

if(callback !== undefined && typeof callback === 'function') callback();

},
						failed: function (message) {
							$scope.saveing = false;
							alert.error(message);
							if(callback !== undefined && typeof callback === 'function') callback();
						}
					});
				};

$scope.installDestination = function() {

if($scope.installing) return;
					$scope.installing = true;

confirm.open({
						message: lang.t("This destination will be installed on this server!"),
						confirm: function () {
							api.installPlugin({ 
								data: { package_id: $scope.plugin_available._id, disabled: 0 }, 
								success: function (data, message) {
									$scope.installing = false;

//$scope.installed_plugin = data;
									$scope.plugin_available = {};
	
									$scope.loadDestinations(function () {
										$scope.saveData.type = data.code;
										$scope.loadDestinationType();
										alert.success(message);
									});
								},
								failed: function (message) {
									$scope.installing = false;
									alert.error(message);
								}
							});
						},
						cancel: function () {
							$scope.installing = false;
						}
					});
				};

$scope.loadDestinations = function(callback) {

if(callback === undefined || typeof callback !== 'function') callback = function(){};
					
					$scope.types[consts.DESTINATION_JOB_TYPE_BACKUP] = [];
					$scope.types[consts.DESTINATION_JOB_TYPE_CLONE] = [];
					$scope.plugins_available = {};

api.listDestinationTypes({ 
						success: function (data) {

for(var i = 0; i < data.types.length; i++) {
	
								var type = data.types[i];
								if((type.key == 'Local' || type.key == 'Localv2') && !permissions.isRoot) continue;
	
								$scope.types[type.type].push({ label: type.name + (type.experimental ? " - " + lang.t("Experimental") : ''), value: type.key, group: lang.t('Installed Destinations') });
								$scope.plugin[type.key] = {
									type: consts.PLUGIN_TYPE_DESTINATION,
									code: type.key,
									job_type: type.type,
									version: type.version,
									experimental: type.experimental
								};
	
								if(!$scope.details.type && !$routeParams.id) {
									$scope.details.type = type.key;
									$scope.saveData.type = type.key;
									$scope.loadDestinationType();
								}

}

api.listPackagesAvailable({ 
								data: { find: { type: consts.PLUGIN_TYPE_DESTINATION } }, 
								success: function(data) {
									for(var i = 0; i < data.packages.length; i++) {
										var pkg = data.packages[i];
										$scope.plugins_available[pkg.code] = pkg;
										$scope.types[consts.DESTINATION_JOB_TYPE_BACKUP].push({ label: lang.t("%s via %s", pkg.name, pkg.repo_name) + (pkg.experimental ? " - " + lang.t("Experimental") : ''), value: "AvailableDestinations::" + pkg.code, group: lang.t('Available Destinations') });
									}
		
									callback();
								},
								failed: function () {
									callback();
								}
							});
						}
					});
				};

$scope.loadDestinations(function () {
					if(!$routeParams.id) return;
					api.getDestination({ 
						data: { _id: $routeParams.id }, 
						success: function(data) {
							$scope.details = data;
							if({}.toString.apply($scope.details.options) !== '[object Object]') {
								$scope.details.options = {};
							}

$scope.saveData = util.duplicateObject($scope.details);
							$scope.autocomplete.accountText = $scope.saveData.owner_name;
							//delete $scope.details.options;
							$scope.loadDestinationType();
						}
					});
				});
				
				api.getSettings({
					data: { section: 'performance' },
					success: function(data) { 
						$scope.forks = {
							backup: data.backup_forks,
							queueable: data.queueable_forks,
							system: data.system_forks,
							total: data.backup_forks + data.queueable_forks + data.system_forks,
						};
					}
				})

}]);
});

define('controllers/disasterRecovery',['app'], function(app) {
	app.controller("disasterRecovery",
		["$rootScope", "$scope", "$location", "$timeout", "api", "meta", "confirm", "PermPermissionStore", "lang", "alert",
			function ($rootScope, $scope, $location, $timeout, api, meta, confirm, PermPermissionStore, lang, alert) {

$scope.disasterRecovery = true;
				$scope.saveing = false;
				$scope.newInstallation = false;
				$scope.loadingMessage = "";

$scope.saveToDB = function() {
					sessionStorage.disasterRecovery = JSON.stringify({
						details: $scope.details,
						step: $scope.currentStep
					});
				};

$scope.steps = [
					{
						title: lang.t("What to do next?"),
						description: lang.t("Please select whether to start to recover your server from a disaster, continue with the default JetBackup configuration, or keep current configuration"),
						template: 'disasterRecovery/selection'
					},
					{
						title: lang.t("JB Configurations destination"),
						description: lang.t("Connect to the destination where the JetBackup configuration files are stored"),
						template: 'disasterRecovery/destination'
					},
					{
						title: lang.t("Available JB configuration files"),
						description: lang.t("Select the desired JB configuration file"),
						template: 'disasterRecovery/backups'
					},
					{
						title: lang.t("Adjust Settings"),
						description: lang.t("Adjust the settings"),
						template: 'disasterRecovery/settings'
					},
					{
						title: lang.t("Accounts to recover"),
						description: lang.t("Select the desired accounts you want to restore"),
						template: 'disasterRecovery/accounts'
					}
				];

if(sessionStorage.disasterRecovery)
				{
					var disasterRecovery = JSON.parse(sessionStorage.disasterRecovery);
					$scope.details = disasterRecovery.details;
					$scope.currentStep = disasterRecovery.step;
				}
				else
				{
					$scope.currentStep = 0;
					$scope.details = {
						destination_id: '',
						drbackups: [],
						drbackup: ''
					};

$scope.saveToDB();
				}

$scope.$watch("details", function(){
					$scope.saveToDB();
				}, true);

$scope.changeStep = function (step) {
					$scope.currentStep = step;
					$scope.saveToDB();
					$scope.currentStepView = $scope.includePath($scope.steps[step].template);
				};

/*
				$scope.concurrent = 1;
				api.getSettings({section: 'Performance'}, function (response) {
					if(response.success && response.data.concurrentqueueprocesses)
						$scope.concurrent = response.data.concurrentqueueprocesses;
				});

$scope.updateConcurrentProcess = function(val) {
					if($scope.concurrent + val <= 0) return;
					$scope.concurrent += val;

var apiParams = {
						section: 'Performance',
						concurrentqueueprocesses: $scope.concurrent
					};

jetapi.manageSettings(apiParams, function(response) {
						if(!response.success) console.log(response);
					});
				};

$scope.changeStep($scope.currentStep);

$scope.exitDRSure = function (apiCall) {

if (apiCall === undefined || typeof apiCall !== 'function') apiCall = function (callback) {};

confirm.open({
						message: lang.t("Are you sure you want to exit disaster recovery mode?"),
						confirm: function () {
							delete sessionStorage.disasterRecovery;

apiCall(function() {
								window.location = $rootScope.path.location + window.location.search;
							});
						}
					});
				};

$scope.freshInstallation = function() {
					$scope.exitDRSure(function (callback) {
						if(callback === undefined || typeof callback !== 'function') callback = function() {};

$scope.newInstallation = true;
						api.factoryReset({
							success: callback,
							failed: function (message) {
								$scope.newInstallation = false;
								alert.error(message);
							}
						});
					});
				};

$scope.startDR = function() {
					confirm.open({
						message: lang.t("Are you sure you want start disaster recovery? All current data will be lost"),
						confirm: function () {
							$scope.loadingMessage = lang.t("Dropping all JetBackup data from database");
							api.factoryReset({
								data: { drmode: true },
								success: function () {
									api.panelPreload({
										success: function (data) {
											$rootScope.loggedAccount = data.account;
											$scope.nextStep();
										},
										failed: function (message) { alert.error(message); }
									});
								},
								failed: function (message) { alert.error(message); }
							});
						}
					});
				};

$scope.exitDR = function() {
					$scope.exitDRSure(function (callback) {
						if(callback === undefined || typeof callback !== 'function') callback = function() {};
						api.exitDisasterRecovery({ 
							success: callback,
							failed: function (message) {
								alert.error(message);
							}
						});
					});
				};

$scope.nextStep = function() {
					if($scope.saveing) return;
					$scope.saveing = true;
					$scope.loadingMessage = '';
					$rootScope.$broadcast("nextStep");
				};

$scope.startOver = function() {
					if($scope.saveing) return;
					delete sessionStorage.disasterRecovery;
					$scope.changeStep(1);
				};

$scope.$on('nonrecoverable', function (event, message) {
					$scope.saveing = false;
					alert.error(lang.t("Failed restoring JB Configurations, the DR Wizard will now exit and start over. Error: %s", message));
					$scope.loadingMessage = lang.t("Dropping all JetBackup data from database");

api.factoryReset({
						data: { drmode: true },
						success: function () {
							$scope.loadingMessage = '';
							$scope.startOver() },
						failed: function (message) { alert.error(message); }
					});
				});

$scope.$on('error', function (event, message) {
					$scope.saveing = false;
					alert.error(message);
					$scope.loadingMessage = '';
				});

$scope.$on('loadingMessage', function (event, message) {
					$scope.loadingMessage = message;
				});

$scope.$on('commitNextStep', function (event, data) {
					for(var i in data) $scope.details[i] = data[i];
					$scope.saveing = false;
					$scope.changeStep($scope.currentStep+1);
					$scope.loadingMessage = '';
				});
			}
		]
	);
});

define('controllers/disasterRecovery/selection',['app'], function(app) {
	app.controller("disasterRecoverySelection",
		["$rootScope", "$scope", "api", function ($rootScope, $scope, api) {
		
			$scope.installed = false;
			
			api.getSettings({
				data: { section: 'general' },
				success: function (data) {
					$scope.installed = data.installed;
				}
			});
		
			$scope.$on('nextStep', function() {
				$scope.$emit("commitNextStep", {});
			});
		}]
	);
});

define('controllers/disasterRecovery/destination',['app'], function(app) {
	app.controller("disasterRecoveryDestination",
		["$rootScope", "$scope", "$routeParams", "$location", "$timeout", "api", "consts", "lang", "util",
			function ($rootScope, $scope, $routeParams, $location, $timeout, api, consts, lang, util) {

$scope.destination_id = '';

$scope.reindex = function(destination_id, callback) {
					if(callback === undefined || typeof callback !== 'function') callback = function() {};

api.reindexDestination({ 
						data: { _id: destination_id, backup_type: consts.BACKUP_TYPE_JB_CONFIG }, 
						success: function(data) {
	
							var checkQueueInterval = setInterval(function () {
								api.getQueueGroup({ 
									data: { _id: data._id }, 
									success: function (data) {
										if(data.status < consts.QUEUE_STATUS_COMPLETED) return;
		
										if(checkQueueInterval !== null) clearInterval(checkQueueInterval);
										checkQueueInterval = null;
		
										callback({ 
											success: data.status == consts.QUEUE_STATUS_COMPLETED, 
											message: lang.t("Reindex process finished with %s status", consts.QUEUE_STATUS_NAMES[data.status]) 
										});
									},
									failed: function (message) {

if(checkQueueInterval !== null) clearInterval(checkQueueInterval);
										checkQueueInterval = null;

callback({
											success: false,
											message: message
										});
									}
								});
							}, 5000);
						},
						failed: function (message) {
							callback({ success: false, message: message });
						}
					});
				};

var listBackups = function(contains, success) {
					if(success === undefined) success = function(){};

api.listBackups({
						data: {
							destination: $scope.destination_id,
							type: consts.BACKUP_TYPE_JB_CONFIG,
							contains:contains,
							sort: { created: -1 }
						},
						success: function (data) {
							success(data);
						},
						failed: function (message) {
							api.deleteDestination({ data: { _id: $scope.destination_id } });
							$scope.$emit("error", message);
						}
					});
				};

$scope.$on('nextStep', function() {

$scope.$emit("loadingMessage", lang.t("Creating destination and reindexing JB configurations backups..."));

var apiParams = util.saveParams($scope.saveData, $scope.details, [], function(key) {
						return ($scope.details._id === undefined && key === 'type');
					});

apiParams.name = "DR destination " + (new Date()).getTime();
					apiParams.readonly = true;
					apiParams.no_reindex = true;
					apiParams.action = 'create';

api.manageDestination({ 
						data: apiParams, 
						success: function(data) {

$scope.destination_id = data._id;
	
							$scope.reindex($scope.destination_id, function (response) {
								if(!response.success) {
									api.deleteDestination({ data: { _id: $scope.destination_id } });
									$scope.$emit("error", response.message);
									return;
								}

listBackups(consts.BACKUP_TYPE_JB_CONFIG_FULL, function (data) {
									var backups = data.backups;
									listBackups((consts.BACKUP_TYPE_JB_CONFIG_FULL^consts.BACKUP_TYPE_JB_CONFIG_WIREDTIGER), function (data) {
										for(var i = 0; i < data.backups.length; i++) backups.push(data.backups[i]);

if(!backups.length) {
											api.deleteDestination({ data: { _id: $scope.destination_id } });
											$scope.$emit("error", lang.t("No JetBackup 5 configuration files found on this destination. Please verify the Destination Path is set to a directory that includes JetBackup 5 Configuration Backups."));
											return;
										}

$scope.$emit("commitNextStep", {
											destination_id: $scope.destination_id,
											drbackups: backups,
											drbackup: backups[0]._id
										});
									});
								});
							});
						},
						failed: function (message) {
							$scope.$emit("error", message);
						}
					});
				});

}
		]
	);
});

define('controllers/disasterRecovery/settings',['app'], function(app) {
	app.controller("disasterRecoverySettings",
		["$rootScope", "$scope", "$routeParams", "$location", "$timeout", "api", "consts", "lang", "util",
			function ($rootScope, $scope, $routeParams, $location, $timeout, api, consts, lang, util) {

$scope.saveData = {
					general: {},
					performance: {},
					resource: {},
					options: {}
				};

$scope.validateOptions = {};
				$scope.settingsSection = '';
				
				api.getSettings({
					data: { section: 'general' },
					success: function (data) {
						$scope.saveData.general = data;
						$scope.general = util.duplicateObject($scope.saveData.general);
					}
				});

api.getSettings({
					data: { section: 'performance' },
					success: function (data) {
						$scope.saveData.performance = data;
						$scope.performance = util.duplicateObject($scope.saveData.performance);
					}
				});

api.getSettings({
					data: { section: 'resource' },
					success: function (data) {
						$scope.saveData.resource = data;
						$scope.resource = util.duplicateObject($scope.saveData.resource);
					}
				});

api.getSettings({
					data: { section: 'panel' },
					success: function (data) {
						$scope.saveData.options = data.options;
						$scope.panel = util.duplicateObject($scope.saveData.options);
					}
				});

$scope.$on('validateOptions', function (e, data) {
					$scope.validateOptions = data;
				});

app.registerController(
					'panelSettings',
					'plugins/panel',
					function(path) {
						$scope.settingsSection = $scope.includePath('panel/view', 'plugins');
					}
				);
				
				$scope.$on('nextStep', function() {

$scope.$emit("loadingMessage", lang.t("Adjusting settings..."));

for (var key in $scope.saveData.options) {
						if($scope.validateOptions[key] === undefined) continue;

if(!$scope.validateOptions[key].validation($scope.saveData.options[key])) {
							$scope.$emit("error", lang.t("Invalid value provided for %s", $scope.validateOptions[key].name));
							return;
						}
					}

var general = util.saveParams($scope.saveData.general, $scope.general);
					general.section = 'general';
					
					var performance = util.saveParams($scope.saveData.performance, $scope.performance);
					performance.section = 'performance';

var resource = util.saveParams($scope.saveData.resource, $scope.resource);
					resource.section = 'resource';

var panel = util.saveParams($scope.saveData.options, $scope.panel);

api.manageSettings({
						data: general,
						success: function () {

api.manageSettings({
								data: performance,
								success: function () {

api.manageSettings({
										data: resource,
										success: function () {

api.manageSettings({
												data: { section: 'panel', options: panel },
												success: function () {
													$scope.$emit("commitNextStep", {});
												},
												failed: function (message) {
													$scope.$emit("error", message);
												}
											});

},
										failed: function (message) {
											$scope.$emit("error", message);
										}
									});

},
								failed: function (message) {
									$scope.$emit("error", message);
								}
							});

},
						failed: function (message) {
							$scope.$emit("error", message);
						}
					});
				});

}
		]
	);
});

define('controllers/disasterRecovery/backups',['app'], function(app) {
	app.controller("disasterRecoveryBackups",
		["$rootScope", "$scope", "$routeParams", "$location", "$timeout", "api", "consts", "lang", "popup",
			function ($rootScope, $scope, $routeParams, $location, $timeout, api, consts, lang, popup) {

$scope.restore = function(_id, encryption_key) {

$scope.$emit("loadingMessage", lang.t("Restoring selected JB configurations backup..."));

var args = { type: consts.QUEUE_ITEM_TYPE_RESTORE, items: [_id] };
					if(encryption_key !== undefined) args.encryption_key = encryption_key;

api.addQueueItems({ 
						data: args, 
						success: function(data) {

$scope.failedCounter = 0;
							var checkQueueInterval = setInterval(function () {
								api.getQueueGroup({ 
									data: { _id: data._id }, 
									success: function (data) {

if(data.items[0].data.nonrecoverable)
													$scope.$emit("nonrecoverable", message);
												else
													$scope.$emit("error", message);
											},
											failed: function (message) {
												$scope.$emit("error", message);
											}
										});
									},
									failed: function (message) {
										if(($scope.failedCounter++ < 10)) return;

if(checkQueueInterval !== null) clearInterval(checkQueueInterval);
										checkQueueInterval = null;

$scope.$emit("error", message);
									}
								});
							}, 5000);
						},
						failed: function (message) {
							$scope.$emit("error", message);
						}
					});
				};

$scope.$on('nextStep', function() {

var backup = { _id: $scope.details.drbackup };

for(var i = 0; i < $scope.details.drbackups.length; i++) {
						if(backup._id === $scope.details.drbackups[i]._id) {
							backup = $scope.details.drbackups[i];
							break;
						}
					}

if(backup.encrypted) {

$scope.privateKeyUIB = popup.open({
							template: 'encryptionKeySelection',
							noController: true,
							scope: $scope
						});

$scope.privateKeyUIB.result.then(function(encryption_key) {

if(!encryption_key) {
								$scope.$emit("error", lang.t("You must provide root master key"));
								return;
							}

$scope.restore(backup._id, encryption_key);
						}, function() {
							$scope.$emit("error", lang.t("You must provide root master key"));
						});

} else {
						$scope.restore(backup._id);
					}

});
	}]);
});

define('controllers/disasterRecovery/accounts',['app'], function(app) {
	app.controller("disasterRecoveryAccounts",
		["$rootScope", "$scope",
			function ($rootScope, $scope) {
				$scope.drMode = true;
	}]);
});

define('controllers/restoreConditions',['app'], function(app) {
	app.controller("restoreConditions",
		["$rootScope", "$scope", "$location", "$timeout", "$interval", "$q", "api", "meta", "confirm", "alert", "lang",
			function ($rootScope, $scope, $location, $timeout, $interval, $q, api, meta, confirm, alert, lang) {
				$rootScope.$emit('menuItem', 'Settings');

$scope.conditions = [];
				$scope.loadingConditions = false;
				$scope.loaders = {
					state: false,
					delete: false
				};

meta = meta.new("restore_conditions");
				$scope.meta = meta;
				$scope.metaData = meta.getData();

if(!meta.getSortBy()) meta.setSortBy("title");
				if(!meta.getSortDirection()) meta.setSortDirection("asc");
				meta.setSortFields(["title", "content", "type"]);
				meta.setTotalItems($scope.conditions.length);

$scope.toggleState = function(condition) {
					api.manageRestoreCondition({
						data: { action: 'modify', _id: condition._id, disabled: !condition.disabled },
						success: function(data, message) {
							$scope.loaders.state = false;
							condition.disabled = data.disabled;
							alert.success(message);
						},
						failed: function (message) {
							alert.error(message);
						}
					});

$scope.loaders.state = true;
				};

$scope.onClickDelete = function(condition) {

if($scope.saveing) return;
					$scope.saveing = true;
					$scope.loaders.delete = true;

confirm.open({
						message: lang.t("This restore condition will be permanently deleted!"),
						confirm: function () {
							api.deleteRestoreCondition({ 
								data: { _id: condition._id }, 
								success: function(data, message) {
									$scope.loaders.delete = false;
									$scope.saveing = false;
									$scope.fetch();
									alert.success(message);
								},
								failed: function(message) {
									$scope.loaders.delete = false;
									$scope.saveing = false;
									alert.error(message);
								}
							});
						},
						cancel: function () {
							$scope.loaders.delete = false;
							$scope.saveing = false;
						}
					});
				};

$scope.fetch = function() {

$scope.loadingConditions = true;

var apiParams = {
						sort: {},
						skip: meta.getSkip(),
						limit: meta.getPageSize(),
						filter: meta.getFilter()
					};

apiParams.sort[meta.getSortBy()] = meta.getSortDirectionInt();

$scope.conditions = [];

api.listRestoreConditions({ 
						data: apiParams, 
						success: function(data) {
							meta.setTotalItems(data.total);
							meta.calculate(data.conditions);
							$scope.conditions = data.conditions;
							$scope.loadingConditions = false;
						}
					});
				};

$timeout($scope.fetch);
			}
		]
	);
});

define('controllers/restoreConditionManage',['app'], function(app) {
	app.controller("restoreConditionManage",
		["$rootScope", "$scope", "$routeParams", "$location", "$timeout", "$q", "api", "meta", "util", "confirm", "lang", "alert",
			function ($rootScope, $scope, $routeParams, $location, $timeout, $q, api, meta, util, confirm, lang, alert) {
				$rootScope.$emit('menuItem', 'Settings');

$scope.details = {};
				$scope.saveData = {
					condition: ''
				};

$scope.saveing = false;
				$scope.changed = false;
				$scope.cancelled = false;

$scope.$watch("saveData", function(){
					$scope.changed = util.isChanged($scope.saveData, $scope.details, ['_id']);
				}, true);

$scope.cancel = function() {
					$scope.cancelled = true;
					$location.path('/restoreConditions');
				};

$scope.saveChanges = function(apply) {

if($scope.saveing) return;

$scope.saveing = true;

var apiParams = util.saveParams($scope.saveData, $scope.details);

apiParams.action = $scope.details._id ? 'modify' : 'create';

api.manageRestoreCondition({ 
						data: apiParams, 
						success: function(data, message) {
							$scope.saveing = false;
							$scope.changed = false;
							$scope.saveData._id = response.data._id;
							$scope.details = util.duplicateObject($scope.saveData);
							if(apply) $location.path('/restoreConditionManage/' + data._id);
							else $location.path('/restoreConditions');
							alert.success(message);
						},
						failed: function(message) {
							$scope.saveing = false;
							alert.error(message);
						},
					});
				};

$scope.fetch = function() {
					api.getRestoreCondition({ 
						data: { _id: $routeParams.id }, 
						success: function(data) {
							$scope.details = data;
							$scope.saveData = util.duplicateObject($scope.details);
						}
					});

};

if($routeParams.id) $timeout($scope.fetch());
			}
		]
	);

});

define('controllers/backupJobs',['app'], function(app) {
	app.controller("backupJobs",
		["$rootScope", "$scope", "$location", "$timeout", "$sce", "$interval", "$q", "api", "meta", "lang", "filter", "consts", "confirm", "alert",
			function ($rootScope, $scope, $location, $timeout, $sce, $interval, $q, api, meta, lang, filter, consts, confirm, alert) {
				$rootScope.$emit('menuItem', 'BackupJobs');

$scope.jobs = [];
				$scope.checkingJob = {};
				$scope.loadingJobs = false;
				$scope.filters = {};
				$scope.destinations = undefined;
				$scope.running = {};
				$scope.checkRunningInterval = null;
				$scope.run_now = false;

$scope.currentTime = parseInt(Date.now() / 1000);
				$interval(function () { $scope.currentTime = parseInt(Date.now() / 1000); }, 100);

$scope.loaders = {
					state: false,
					quota: false,
					runnow: false,
					duplicate: false,
					delete: false
				};

meta = meta.new("backup_jobs");
				$scope.meta = meta;
				$scope.metaData = meta.getData();

if(!meta.getSortBy()) meta.setSortBy("name");
				if(!meta.getSortDirection()) meta.setSortDirection("asc");
				meta.setSortFields(["name","type","owner","retain","last_run","disabled"]);
				meta.setTotalItems($scope.jobs.length);

$scope.viewLogs = function(job) {
					var logsFilter = filter.new("logs_filter");
					logsFilter.setFilter(consts.LOG_TYPE_BACKUP);

var logsSubFilter = filter.new("logs_subfilter");
					logsSubFilter.setFilter(job._id);

$scope.changeView('/logs');
				};

$scope.duplicate = function(job) {

confirm.open({
						message: lang.t("This backup job will be duplicated!"),
						confirm: function () {
							$scope.loaders.duplicate = true;

api.duplicateBackupJob({ 
								data: { _id: job._id }, 
								success: function (data, message) {
									$scope.loaders.duplicate = false;
									$scope.fetch();
									alert.success(message);
								},
								failed: function (message) {
									$scope.loaders.duplicate = false;
									alert.error(message);
								}
							});
						},
						cancel: function () {
							$scope.saveing = false;
						}
					});
				};

$scope.toggleState = function(job) {
					$scope.loaders.state = true;
					var newState = !job.disabled;
					api.manageBackupJob({ 
						data: { action: 'modify', _id: job._id, disabled: newState }, 
						success: function(data) {
							$scope.loaders.state = false;
							job.disabled = data.disabled;
							job.next_run = data.next_run;
						},
						failed: function (message) {
							$scope.loaders.state = false;
							alert.error(message);
						}
					});
				};

$scope.runBackupJobManually = function(job) {

if($scope.loaders.runnow) return;
					$scope.loaders.runnow = true;

api.runBackupJobManually({ 
						data: { _id: job._id }, 
						success: function (data, message) {
							$scope.loaders.runnow = false;
							for(var key in data) job[key] = data[key];
							$scope.running[job._id] = job;
							alert.success(message);
						},
						failed: function (message) {
							$scope.loaders.runnow = false;
							alert.error(message);
						}
					});
				};

$scope.onClickDelete = function(job) {

if($scope.saveing) return;
					$scope.saveing = true;
					$scope.loaders.delete = true;

confirm.open({
						message: lang.t("This backup job will be permanently deleted!"),
						confirm: function () {

api.deleteBackupJob({ 
								data: { _id: job._id }, 
								success: function(data, message) {
									$scope.saveing = false;
									$scope.loaders.delete = false;
									$scope.fetch();
									alert.success(message);
								},
								failed: function (message) {
									$scope.saveing = false;
									$scope.loaders.delete = false;
									alert.error(message);
								}
							});
						},
						cancel: function () {
							$scope.saveing = false;
							$scope.loaders.delete = false;
						}
					});
				};

api.listAccountFilters({ 
					success: function (data) {
						for(var i = 0; i < data.filters.length; i++) {
							$scope.filters[data.filters[i].group_id] = data.filters[i].name;
						}
					}
				});

$scope.createBackupJob = function() {
					$scope.destinationsCheck(function () {
						$scope.changeView('/backupJobManage');
					});
				};
				
				$scope.destinationsCheck = function (callback) {
					if(callback === undefined) callback = function () {};

if($scope.destinations !== undefined) {

if(!$scope.destinations) {
							alert.error(lang.t("You must first create a destination before creating a backup job for this server"));
							return;
						}

callback();
						return;
					}

$scope.destinations = false;

api.listDestinations({ 
						data: { readonly:0 }, 
						success: function(data) {
							$scope.destinations = !!data.destinations.length;
							if(!$scope.destinations) {
								alert.error(lang.t("You must first create a destination before creating a backup job for this server"));
								return;
							}
	
							callback();
						},
						failed: function (message) {
							alert.error(message);
						}
					});
				};

$scope.checkRunning = function() {
					for(var id in $scope.running) {
						api.getBackupJob({ 
							data: { _id: id }, 
							success: function (data) {
								if(data.running) return;
								for(var key in data) $scope.running[id][key] = data[key];
								delete $scope.running[id];
							}
						});
					}
				};

$scope.$on('$destroy', function() {
					if($scope.checkRunningInterval === null) return;
					clearInterval($scope.checkRunningInterval);
					$scope.checkRunningInterval = null;
				});

$scope.fetch = function(callback) {
					if(callback === undefined || typeof callback !== 'function') callback = function() {};

$scope.loadingJobs = true;

var apiParams = {
						sort: {},
						skip: meta.getSkip(),
						limit: meta.getPageSize(),
						filter: meta.getFilter()
					};

apiParams.sort[meta.getSortBy()] = meta.getSortDirectionInt();

$scope.jobs = [];
					$scope.running = {};

api.listBackupJobs({ 
						data: apiParams, 
						success: function(data) {
							meta.setTotalItems(data.total);
							meta.calculate(data.jobs);
							$scope.jobs = data.jobs;
	
							for(var i = 0; i < $scope.jobs.length; i++) {
	
								var job = $scope.jobs[i];
								var type = parseInt(job.type);
								var contains = parseInt(job.contains);
								var names = [];
	
	
								switch(type) {
									case consts.BACKUP_TYPE_ACCOUNT:
										if(contains == consts.BACKUP_TYPE_ACCOUNT_FULL) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_FULL]);
										else {
											if(contains & consts.BACKUP_TYPE_ACCOUNT_CONFIG) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_CONFIG]);
											if(contains & consts.BACKUP_TYPE_ACCOUNT_HOMEDIR) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_HOMEDIR]);
											if(contains & consts.BACKUP_TYPE_ACCOUNT_DATABASES) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_DATABASES]);
											if(contains & consts.BACKUP_TYPE_ACCOUNT_EMAILS) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_EMAILS]);
											if(contains & consts.BACKUP_TYPE_ACCOUNT_CRON_JOBS) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_CRON_JOBS]);
											if(contains & consts.BACKUP_TYPE_ACCOUNT_DOMAINS) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_DOMAINS]);
											if(contains & consts.BACKUP_TYPE_ACCOUNT_CERTIFICATES) names.push(consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_CERTIFICATES]);
										}
									break;
									case consts.BACKUP_TYPE_DIRECTORY:
										names.push(consts.BACKUP_TYPE_DIRECTORY_NAMES[consts.BACKUP_TYPE_DIRECTORY_FULL]);
									break;
									case consts.BACKUP_TYPE_JB_CONFIG:
										names.push(consts.BACKUP_TYPE_JB_CONFIG_NAMES[consts.BACKUP_TYPE_JB_CONFIG_FULL]);
										break;
									case consts.BACKUP_TYPE_DR:
										names.push(consts.BACKUP_TYPE_DR_NAMES[consts.BACKUP_TYPE_DR_FULL]);
									break;
								}
	
								job.contains_name = names.join(', ');
	
								job.filters_sorted = [];
								if(job.filters !== undefined) {
									for(var j = 0; j < job.filters.length; j++) {
										for(var a = 0; a < job.filters[j].length; a++) {
											job.filters_sorted.push(job.filters[j][a]);
										}
									}
								}
	
								if(job.running) $scope.running[job._id] = job;
	
								var destinations_list = [];
								job.destinations = '';
	
								for(var k = 0; k < job.destination_details.length; k++) 
									destinations_list.push(job.destination_details[k].name + (job.destination_details[k].disabled ? " <span style=\"color: #cc0000; font-size: 11px;\">(" + lang.t("Disabled") + ")</span>" : ''));
	
								job.destinations = $sce.trustAsHtml(destinations_list.join(", "));
								//job.next_run_int = job.next_run ? parseInt((new Date(job.next_run)).getTime() / 1000) : 0;
							}
	
							$scope.loadingJobs = false;
							callback();
						}
					});
				};

$timeout(function () {
					$scope.fetch(function () {
						$scope.checkRunningInterval = setInterval($scope.checkRunning, 3000);
					});
				});
			}
		]
	);
});

define('controllers/backupJobManage',['app'], function(app) {
	app.controller("backupJobManage",
		["$rootScope", "$scope", "$routeParams", "$templateCache", "$route", "$location", "$timeout", "$q", "api", "meta", "util", "lang", "alert", "permissions", "consts", "filterManager", "confirm", "popup",
			function ($rootScope, $scope, $routeParams, $templateCache, $route, $location, $timeout, $q, api, meta, util, lang, alert, permissions, consts, filterManager, confirm, popup) {
				$rootScope.$emit('menuItem', 'BackupJobs');

$scope.saveData = {
					name: '',
					destination: [],
					owner: $scope.loggedAccount._id,
					owner_name: $scope.loggedAccount.username,
					type: consts.BACKUP_TYPE_ACCOUNT,
					contains: consts.BACKUP_TYPE_ACCOUNT_FULL,
					mysql_exclude_db_by_size: 0,
					postgresql_exclude_db_by_size: 0,
					mongodb_exclude_db_by_size: 0,
					encrypted: 0,
					retry_failed: 0,
					//options: 0,
					structure: consts.BACKUP_STRUCTURE_INCREMENTAL,
					time_parsed: '12:00 AM',
					time: 0,
					monitor: {ranfor:0,notran:0},
					schedules: [],
					filters: [],
					include_list: [],
					exclude_list: []
				};

$scope.autocomplete = { accountText: $scope.saveData.owner_name };

$scope.details = {};
				$scope.destinations = {};
				$scope.schedules = {};
				$scope.filters = {};
				$scope.backup_job_names = {};
				$scope.clone_job_names = {};
				$scope.cancelled = false;
				$scope.excluderow = '';
				$scope.includerow = '';
				$scope.type_description = lang.t("Backup the account data that you choose - Files, Emails, Databases, Cron Jobs, Domains, SSL & Panel Configs (If relevant)");
				$scope.type_experimental = '';

$scope.structures = [
					{ label: consts.BACKUP_STRUCTURE_NAMES[consts.BACKUP_STRUCTURE_INCREMENTAL], value: consts.BACKUP_STRUCTURE_INCREMENTAL },
					{ label: consts.BACKUP_STRUCTURE_NAMES[consts.BACKUP_STRUCTURE_ARCHIVED], value: consts.BACKUP_STRUCTURE_ARCHIVED },
					{ label: consts.BACKUP_STRUCTURE_NAMES[consts.BACKUP_STRUCTURE_COMPRESSED], value: consts.BACKUP_STRUCTURE_COMPRESSED }
				];

$scope.types = [
					{ label: consts.BACKUP_TYPE_NAMES[consts.BACKUP_TYPE_ACCOUNT], value: consts.BACKUP_TYPE_ACCOUNT }
				];
				
				if(permissions.isRoot) {
					$scope.types.push({ label: consts.BACKUP_TYPE_NAMES[consts.BACKUP_TYPE_DIRECTORY], value: consts.BACKUP_TYPE_DIRECTORY });
					$scope.types.push({ label: consts.BACKUP_TYPE_NAMES[consts.BACKUP_TYPE_DR], value: consts.BACKUP_TYPE_DR });
				}

$scope.account_types = [
					{ label: consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_CONFIG], value: consts.BACKUP_TYPE_ACCOUNT_CONFIG },
					{ label: consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_HOMEDIR], value: consts.BACKUP_TYPE_ACCOUNT_HOMEDIR },
					{ label: consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_DATABASES], value: consts.BACKUP_TYPE_ACCOUNT_DATABASES },
					{ label: consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_DATABASE_USERS], value: consts.BACKUP_TYPE_ACCOUNT_DATABASE_USERS },
					{ label: consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_EMAILS], value: consts.BACKUP_TYPE_ACCOUNT_EMAILS },
					{ label: consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_FTP], value: consts.BACKUP_TYPE_ACCOUNT_FTP },
					{ label: consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_CRON_JOBS], value: consts.BACKUP_TYPE_ACCOUNT_CRON_JOBS },
					{ label: consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_DOMAINS], value: consts.BACKUP_TYPE_ACCOUNT_DOMAINS },
					{ label: consts.BACKUP_TYPE_ACCOUNT_NAMES[consts.BACKUP_TYPE_ACCOUNT_CERTIFICATES], value: consts.BACKUP_TYPE_ACCOUNT_CERTIFICATES }
				];

$scope.filtersConditions = [
					{_id:1,name:lang.t("OR")},
					{_id:2,name:lang.t("AND")}
				];
				$scope.filtersStructure = [];

$scope.$watch("saveData.structure", function () {
					if($scope.saveData.structure == consts.BACKUP_STRUCTURE_ARCHIVED || $scope.saveData.structure == consts.BACKUP_STRUCTURE_COMPRESSED) return;
					$scope.saveData.encrypted = 0;
				});

$scope.$watch("filtersStructure", function(){
					$scope.buildFilters(true);
				}, true);

$scope.addRecommendedExcludes = function(list) {
					if(consts.RECOMMENDED_EXCLUDES_ACCOUNT[list] === undefined) return;
					var defaults = consts.RECOMMENDED_EXCLUDES_ACCOUNT[list];
					
					for(var i = 0; i < defaults.length; i++) {
						var exclude = defaults[i];
						if ($scope.saveData.exclude_list.indexOf(exclude) < 0) $scope.saveData.exclude_list.push(exclude);
					}
				};
				
				$scope.selectAccount = function(account) {
					if(account === undefined) return;
					$scope.saveData.owner = account._id;
					$scope.saveData.owner_name = account.username;
					$scope.autocomplete.accountText = account.username;
					var activeElement = document.activeElement;
					if (activeElement) activeElement.blur();
				};

return deferred.promise;
					}

return [];
				};

$scope.buildFilters = function(revert) {
					if(revert === undefined) revert = false;
					if(revert) $scope.saveData.filters = filterManager.buildFilters($scope.filtersStructure);
					else if($scope.saveData.filters !== undefined) $scope.filtersStructure = filterManager.reBuildStructure($scope.saveData.filters);
				};

$scope.removeFilter = function(index) {
					$scope.filtersStructure = filterManager.removeFilter($scope.filtersStructure, index);
				};

$scope.upFilter = function(index) {
					if(index === 0) return;

var clickedValue = $scope.filtersStructure[index];
					var upValue = $scope.filtersStructure[index-1];

if(index === 1) {
						upValue.cond = clickedValue.cond;
						delete clickedValue.cond;
					}

$scope.filtersStructure[index] = upValue;
					$scope.filtersStructure[index-1] = clickedValue;
				};

$scope.downFilter = function(index) {
					if(index === ($scope.filtersStructure.length-1)) return;

var clickedValue = $scope.filtersStructure[index];
					var downValue = $scope.filtersStructure[index+1];

if(index === 0) {
						clickedValue.cond = downValue.cond;
						delete downValue.cond;
					}

$scope.filtersStructure[index] = downValue;
					$scope.filtersStructure[index+1] = clickedValue;
				};

$scope.fileBrowse = function() {

popup.open({
						size: "lg",
						template: 'fileBrowse',
						scope: $scope,
						resolve: {
							listPaths: function () { return $scope.saveData.include_list; }
						}
					}).result.then(function(paths) {
						$scope.saveData.include_list = paths;
					}, function() {});
				};

$scope.filterSelection = function () {

popup.open({
						size: "lg",
						template: 'accountFilterGroupSelection',
						scope: $scope,
						resolve: {
							filters: function() { return $scope.filters; } ,
							details: function() { return $scope.details; }
						}
					}).result.then(function(filter_id) {

if(!filter_id) return;
						var data = { _id: filter_id };
						if($scope.filtersStructure.length > 0) data.cond = 1;
						$scope.filtersStructure.push(data);

}, function () {});
				};

$scope.manageDestination = function() {

popup.open({
						template: 'destinationsSelection',
						scope: $scope,
						resolve: {
							destinations: function() { return $scope.saveData.destination; },
							readonly: function () { return false; },
							types: function () { return consts.DESTINATION_JOB_TYPE_BACKUP; },
							legacy: function () { return consts.BACKUP_ALLOW_LEGACY_DESTINATION[$scope.saveData.type]; },
							local: function () { return consts.BACKUP_ALLOW_LOCAL_DESTINATION[$scope.saveData.type]; },
							timebased: function () { return consts.BACKUP_ALLOW_TIME_BASED_DESTINATION[$scope.saveData.type]; }
						}
					}).result.then(function(selected) {
						$scope.saveData.destination = selected;
					}, function () {});

};

$scope.databasesExcludes = function() {

popup.open({
						size: "lg",
						template: 'modifyDatabasesExcludes',
						scope: $scope,
						resolve: {
							db_excludes: function() {
								return {
									mysql_exclude_db_by_size: $scope.saveData.mysql_exclude_db_by_size,
									postgresql_exclude_db_by_size: $scope.saveData.postgresql_exclude_db_by_size,
									mongodb_exclude_db_by_size: $scope.saveData.mongodb_exclude_db_by_size
								}
							}
						}
					}).result.then(function(response) {
						$scope.saveData.mysql_exclude_db_by_size = response.mysql_exclude_db_by_size;
						$scope.saveData.postgresql_exclude_db_by_size = response.postgresql_exclude_db_by_size;
						$scope.saveData.mongodb_exclude_db_by_size = response.mongodb_exclude_db_by_size;
					}, function () {});

};

$scope.scheduleSelection = function (schedule) {
					
					popup.open({
						size: "lg",
						template: 'scheduleSelection',
						scope: $scope,
						resolve: {
							schedules: function() { return $scope.schedules; } ,
							schedule: function() { return schedule; },
							details: function() { return $scope.saveData; },
							retain: function () { return true; }
						}
					}).result.then(function(scheduleDetails) {

if(!scheduleDetails._id || scheduleDetails.retain <= 0) {
							alert.error(lang.t("No schedule and/or backups retain selected"));
							return;
						}

scheduleDetails.display = $scope.scheduleDisplay(scheduleDetails);

$scope.schedules[scheduleDetails._id] = scheduleDetails;

if(schedule !== undefined) {
							for(var i in scheduleDetails) {
								if(schedule[i] !== undefined) schedule[i] = scheduleDetails[i];
							}
						} else {
							$scope.saveData.schedules.push({
								_id: scheduleDetails._id,
								name: scheduleDetails.name,
								retain: scheduleDetails.retain,
								next_run: 0
							});
						}
						
						$scope.checkScheduleTimeMismatch();

}, function () {});
				};

$scope.checkScheduleTimeMismatch = function () {
					var time = 0;

for(var i = 0; i < $scope.saveData.schedules.length; i++)
					{
						if($scope.schedules[$scope.saveData.schedules[i]._id] === undefined) return;
						var currentSchedule = $scope.schedules[$scope.saveData.schedules[i]._id];
						if([1,2,3,4].indexOf(currentSchedule.type) < 0) continue;

if(currentSchedule.type === 1)
						{
							// TODO validate hourly times
							continue;
						}

if(!time) time = currentSchedule.time;

if(currentSchedule.time !== time)
						{
							$scope.scheduleTimeMismatch = true;
							return;
						}
					}

$scope.scheduleTimeMismatch = false;
				};

$scope.removeSchedule = function (schedule) {

confirm.open({
						message: lang.t("Are you sure you want to remove this schedule from this job? Please note that all snapshots assigned to this schedule will be deleted in the next job run."),
						confirm: function () {
							for(var i = 0; i < $scope.saveData.schedules.length; i++) {
								if(schedule._id === $scope.saveData.schedules[i]._id) {
									$scope.saveData.schedules.splice(i, 1);
									$scope.checkScheduleTimeMismatch();
									break;
								}
							}

alert.success("Schedule removed successfully");
						}
					});
				};

$scope.timeToStr = function(time) {

time = parseInt(time);

var ampm = 'AM';
					if(time >= 1200) {
						ampm = 'PM';
						time -= 1200;
					}

time = '' + time;
					if(time.length < 2) time = '0' + time;

var minute = time.substr(-2);
					var hour = time.length > 2 ? time.substr(0, time.length-2) : 12;
					if(parseInt(hour) < 10) hour = "0" + parseInt(hour);
					return hour + ":" + minute + " " + ampm;
				};

$scope.strToTime = function (str) {
					var matches = /^([0-9]+):([0-9]+)\s+(AM+|PM+)$/g.exec(str);
					if(!matches) return 0;
					var output = parseInt(matches[1] + matches[2]);
					if(output >= 1200) output -= 1200;
					if(matches[3] === 'PM') output += 1200;
					return output;
				};

$scope.validateListPath = function (path, allowPatterns) {
					if(!path.trim()) return false;
					if(allowPatterns) return !consts.PATH_FILTER_PATTERNS.test(path);
					return !consts.PATH_FILTER.test(path);
				};

$scope.typeChecked = function(type, types) {
					return ( type & types );
				};

$scope.toggleOptionsTypes = function(option) {
					if($scope.typeChecked(option, $scope.saveData.options)) $scope.saveData.options ^= option;
					else $scope.saveData.options |= option;
				};

$scope.checkChange = function() {
					$scope.changed = util.isChanged($scope.saveData, $scope.details, ['_id']);
				};

$scope.$watch("saveData", $scope.checkChange, true);
				$scope.$watch("details", $scope.checkChange, true);

$scope.validateSchedules = function(schedules, callback) {
					if(schedules.length) return callback(true);

confirm.open({
						message: lang.t("We noticed that you didn't set any schedule for this job. That means that this job will never run automatically, only manually"),
						cancelLabel: lang.t("No, let me set schedules"),
						confirm: function () { callback(true); },
						cancel: function () { callback(false); }
					});
				};

$scope.fetchSchedules = function(callback) {
					if(callback === undefined || typeof callback != 'function') callback = function() {};

api.listSchedules({ 
						success: function(data) {

for (var i = 0; i < data.schedules.length; i++) {
								var id = data.schedules[i]._id;
								$scope.schedules[id] = data.schedules[i];
								$scope.schedules[id].display = $scope.scheduleDisplay($scope.schedules[id]);
							}

callback();
						},
						failed: function () {
							callback();
						}
					});
				};

$scope.fetchFilters = function(callback) {
					if(callback === undefined || typeof callback != 'function') callback = function() {};

api.listAccountFilterGroups({ 
						success: function(data) {

for(var i = 0; i < data.groups.length; i++) {
								$scope.filters[data.groups[i]._id] = data.groups[i];
							}

callback();
						},
						failed: function () {
							callback();
						}
					});
				};

$scope.fetchDestinations = function(callback) {
					if(callback === undefined || typeof callback != 'function') callback = function() {};
					api.listDestinations({ 
						success: function(data) {
							
							for(var i = 0; i < data.destinations.length; i++) {
								var destination = data.destinations[i];
								destination.display = lang.t("%s destination", destination.type);
								$scope.destinations[destination._id] = destination;
							}
	
							callback();
						}
					});
				};

$scope.removeDestination = function (destination_id) {

for(var i = 0; i < $scope.saveData.destination.length; i++) {
						if(destination_id === $scope.saveData.destination[i]) {
							$scope.saveData.destination.splice(i, 1);
							break;
						}
					}
				};

$scope.updateData = function(details) {
					$scope.details = details;
					$scope.saveData = util.duplicateObject($scope.details);
					$scope.checkScheduleTimeMismatch();
					$scope.buildFilters();
				};

$scope.toggleBackupType = function(type) {

switch(type) {
						case consts.BACKUP_TYPE_ACCOUNT:
							$scope.saveData.contains = consts.BACKUP_TYPE_ACCOUNT_FULL;
							$scope.type_description = lang.t("Backup the account data that you choose - Files, Emails, Databases, Cron Jobs, Domains, SSL & Panel Configs (If relevant)");
							$scope.type_experimental = '';
						break;
						case consts.BACKUP_TYPE_DIRECTORY:
							$scope.saveData.contains = consts.BACKUP_TYPE_DIRECTORY_FULL;
							$scope.type_description = lang.t("Backup server files/folders that you choose to include (not necessarily related to accounts).");
							$scope.type_experimental = '';

if($scope.saveData.include_list === undefined) $scope.saveData.include_list = [];
							if($scope.saveData.exclude_list === undefined) $scope.saveData.exclude_list = [];
						break;
                        case consts.BACKUP_TYPE_DR:
                            $scope.saveData.contains = consts.BACKUP_TYPE_DR_FULL;
                            $scope.type_description = lang.t("Create an entire server backup (BMR) for disaster recovery restore, this will create a bootable ISO to restore from. Note that this works alongside the accounts, so for a full recovery you will need an active all-accounts backup job.");
                            $scope.type_experimental = '';
                            break;
					}

var newDestinations = [];
					for(var i = 0; i < $scope.saveData.destination.length; i++) {
						var details = $scope.destinations[$scope.saveData.destination[i]];
						
						if(!consts.BACKUP_ALLOW_LEGACY_DESTINATION[type] && details.legacy) continue;
						if(!consts.BACKUP_ALLOW_LOCAL_DESTINATION[type] && (details.type == 'Local' || details.type == 'Localv2')) continue;
						if(!consts.BACKUP_ALLOW_TIME_BASED_DESTINATION[type] && details.time_based) continue;

newDestinations.push($scope.saveData.destination[i]);
					}
					$scope.saveData.destination = newDestinations;
				};

$scope.toggleContains = function(type) {
					if($scope.typeChecked(type, $scope.saveData.contains)) $scope.saveData.contains ^= type;
					else $scope.saveData.contains |= type;
				};

var checkDuplicateIncludeItems = function(value, list) {
					var withoutTrailing = value.replace(/\/+$/, '');
					var withTrailing = withoutTrailing + '/';
					return (list.indexOf(withoutTrailing) >= 0 || list.indexOf(withTrailing) >= 0);
				};

$scope.addListRow = function (value, list) {
					if($scope[value] === undefined || !$scope[value].trim()) return;

if(checkDuplicateIncludeItems($scope[value].trim(), list)){
						alert.error(lang.t('The provided path ("%s") already exists on the list.', $scope[value].trim()));
					}
					else if($scope.validateListPath($scope[value].trim(), value === 'excluderow')) {
						list.push($scope[value].trim());
					}
					else {
						alert.error(lang.t('The provided path ("%s") is invalid. The path must start with a "/"' + (value !== 'excluderow' ? ', also patterns are not allowed.' : '.'), $scope[value].trim() ));
					}

$scope[value] = '';

};

$scope.addMultiListRow = function(type, list) {

if(type == 'include') {
						$scope.listTitle = lang.t("Directories and Files to include");
						$scope.listData = $scope.saveData.include_list.join("\n");
					} else {
						$scope.listTitle = lang.t("Directories and Files to exclude");
						$scope.listData = $scope.saveData.exclude_list.join("\n");
					}

$scope.listUIB = popup.open({
						template: 'listSelection',
						noController: true,
						scope: $scope
					});
					
					$scope.listUIB.result.then(function(records) {
						while(list.length) list.pop();
						records = records.split("\n");
						var invalidPaths = [];
						var duplicatePaths = [];
						for(var i = 0; i < records.length; i++) {
							if(type === 'include' && checkDuplicateIncludeItems(records[i], list)) duplicatePaths.push(records[i]);
							else if(!(type === 'include' && records[i] === '/') && $scope.validateListPath(records[i], type === 'exclude')) {
								if (list.indexOf(records[i]) < 0 ) list.push(records[i]);
							}
							else invalidPaths.push(records[i]);
						}

$scope.$on('$destroy', function() {

if(!$scope.changed || $scope.cancelled) return;

$scope.cancel = function() {
					$scope.cancelled = true;
					$location.path('/backupJobs');
				};

$scope.saveChanges = function(apply, callback) {

if($scope.saveing) return;

$scope.saveing = true;

var apiParams = util.saveParams($scope.saveData, $scope.details, ['backuptype']);

if(apiParams.time_parsed) apiParams.time = $scope.strToTime(apiParams.time_parsed);
					apiParams.action = $scope.details._id ? 'modify' : 'create';

$scope.validateSchedules($scope.saveData.schedules, function(isConfirm) {
						if(isConfirm) {
							api.manageBackupJob({ 
								data: apiParams, 
								success: function(data, message) {

$scope.saveing = false;
									$scope.details = util.duplicateObject($scope.saveData);
									$scope.updateData($scope.details);
	
									if(callback === undefined) {
										if (apply) $location.path('/backupJobManage/' + data._id);
										else $location.path('/backupJobs');
										alert.success(message);
									}

if(callback !== undefined && typeof callback === 'function') callback();
								},
								failed: function (message) {
									$scope.saveing = false;
									alert.error(message);
									if(callback !== undefined && typeof callback === 'function') callback();
								}
							});
						} else $scope.saveing = false;
					});
				};

$scope.hideTime = function() {
					if(!$scope.saveData.schedules || !$scope.saveData.schedules.length) return true;
					for(var i=0; i < $scope.saveData.schedules.length; i++) {
						if ($scope.schedules[$scope.saveData.schedules[i]._id].type < 5) return false;
					}
					return true;
				};

$scope.$on('fetchJobData', function(event, data) {
					$scope.fetchJobData(data._id, data.callback);
				});

$scope.fetchJobData = function() {
					api.getBackupJob({ 
						data: { _id: $routeParams.id }, 
						success: function(data) {
							$scope.details = data;
							$scope.details.time_parsed = $scope.timeToStr($scope.details.time);
	
							$scope.saveData = util.duplicateObject($scope.details);
							$scope.autocomplete.accountText = $scope.saveData.owner_name;
							$scope.buildFilters();
						}
					});
				};

$scope.fetchBackupJobs = function(callback) {
					if(callback === undefined || typeof callback != 'function') callback = function() {};
					api.listBackupJobs({ 
						success: function (data) {
							for(var i = 0; i < data.jobs.length; i++) {
								$scope.backup_job_names[data.jobs[i]._id] = data.jobs[i].name;
							}
							callback();
						},
						failed: function () {
							callback();
						}
					})
				};

$scope.fetchCloneJobs = function(callback) {
					if(callback === undefined || typeof callback != 'function') callback = function() {};
					api.listCloneJobs({
						success: function (data) {
							for(var i = 0; i < data.jobs.length; i++) {
								$scope.clone_job_names[data.jobs[i]._id] = data.jobs[i].name;
							}

callback();
						},
						failed: function () {
							callback();
						}
					})
				};

$scope.scheduleDisplay = function(schedule) {

var list = [];

switch(schedule.type) {
						case consts.SCHEDULE_TYPE_HOURLY:
							return lang.t("Hourly Schedule runs every %s Hours", schedule.type_data);
						case consts.SCHEDULE_TYPE_DAILY:
							list = schedule.type_data.map(function (value) { return consts.SCHEDULE_WEEK_DAYS_NAMES[value]; });
							return lang.t("Daily Schedule runs every %s", schedule.type_data.length === 7 ? lang.t("day") : list.join(", "));
						case consts.SCHEDULE_TYPE_WEEKLY:
							return lang.t("Weekly Schedule runs every %s", consts.SCHEDULE_WEEK_DAYS_NAMES[schedule.type_data]);
						case consts.SCHEDULE_TYPE_MONTHLY:
							list = schedule.type_data.map(function (value) {
								value = String(value);
								return value + consts.SCHEDULE_TYPE_MONTHLY_SUFFIX[value.substr(value.length-1)];
							});
							return lang.t("Monthly Schedule runs every %s of every month", list.join(", "));
						case consts.SCHEDULE_TYPE_BACKUP_DONE:
							return lang.t("Runs %safter the \"%s\" backup job End", (schedule.delay_amount > 0 ? schedule.delay_amount + ' ' + consts.SCHEDULE_DELAY_TYPE_NAMES[schedule.delay_type] + ' ' : ''), $scope.backup_job_names[schedule.type_data]);
						case consts.SCHEDULE_TYPE_CLONE_DONE:
							return lang.t("Runs %safter the \"%s\" clone job End", (schedule.delay_amount > 0 ? schedule.delay_amount + ' ' + consts.SCHEDULE_DELAY_TYPE_NAMES[schedule.delay_type] + ' ' : ''), $scope.clone_job_names[schedule.type_data]);
					}

};

$scope.fetchFilters(function () {
					$scope.fetchBackupJobs(function () {
						$scope.fetchCloneJobs(function () {
							$scope.fetchSchedules(function () {
								$scope.fetchDestinations(function () {
									$scope.fetchJobData();
								});
							});
						});
					});
				});
			}
		]
	);

});

define('controllers/cloneJobs',['app'], function(app) {
	app.controller("cloneJobs",
		["$rootScope", "$scope", "$location", "$timeout", "$sce", "$interval", "$q", "api", "meta", "lang", "filter", "consts", "confirm", "alert",
			function ($rootScope, $scope, $location, $timeout, $sce, $interval, $q, api, meta, lang, filter, consts, confirm, alert) {
				$rootScope.$emit('menuItem', 'CloneJobs');

$scope.currentTime = parseInt(Date.now() / 1000);
				$interval(function () { $scope.currentTime = parseInt(Date.now() / 1000); }, 100);

$scope.loaders = {
					state: false,
					quota: false,
					runnow: false,
					duplicate: false,
					delete: false
				};

meta = meta.new("clone_jobs");
				$scope.meta = meta;
				$scope.metaData = meta.getData();

$scope.viewLogs = function(job) {
					var logsFilter = filter.new("logs_filter");
					logsFilter.setFilter(consts.LOG_TYPE_CLONE);

var logsSubFilter = filter.new("logs_subfilter");
					logsSubFilter.setFilter(job._id);

$scope.changeView('/logs');
				};

$scope.duplicate = function(job) {

confirm.open({
						message: lang.t("This clone job will be duplicated!"),
						confirm: function () {
							$scope.loaders.duplicate = true;

api.duplicateCloneJob({ 
								data: { _id: job._id }, 
								success: function (data, message) {
									$scope.loaders.duplicate = false;
									$scope.fetch();
									alert.success(message);
								},
								failed: function (message) {
									$scope.loaders.duplicate = false;
									alert.error(message);
								}
							});
						},
						cancel: function () {
							$scope.saveing = false;
						}
					});
				};

$scope.toggleState = function(job) {
					$scope.loaders.state = true;
					var newState = !job.disabled;
					api.manageCloneJob({ 
						data: { action: 'modify', _id: job._id, disabled: newState }, 
						success: function(data) {
							$scope.loaders.state = false;
							job.disabled = data.disabled;
							job.next_run = data.next_run;
						},
						failed: function (message) {
							$scope.loaders.state = false;
							alert.error(message);
						}
					});
				};

$scope.runCloneJobManually = function(job) {

if($scope.loaders.runnow) return;
					$scope.loaders.runnow = true;

api.runCloneJobManually({ 
						data: { _id: job._id }, 
						success: function (data, message) {
							$scope.loaders.runnow = false;
							for(var key in data) job[key] = data[key];
							$scope.running[job._id] = job;
							alert.success(message);
						},
						failed: function (message) {
							$scope.loaders.runnow = false;
							alert.error(message);
						}
					});
				};

$scope.onClickDelete = function(job) {

if($scope.saveing) return;
					$scope.saveing = true;
					$scope.loaders.delete = true;

confirm.open({
						message: lang.t("This clone job will be permanently deleted!"),
						confirm: function () {

api.deleteCloneJob({ 
								data: { _id: job._id }, 
								success: function(data, message) {
									$scope.saveing = false;
									$scope.loaders.delete = false;
									$scope.fetch();
									alert.success(message);
								},
								failed: function (message) {
									$scope.saveing = false;
									$scope.loaders.delete = false;
									alert.error(message);
								}
							});
						},
						cancel: function () {
							$scope.saveing = false;
							$scope.loaders.delete = false;
						}
					});
				};

$scope.createCloneJob = function() {
					$scope.destinationsCheck(function () {
						$scope.changeView('/cloneJobManage');
					});
				};
				
				$scope.destinationsCheck = function (callback) {
					if(callback === undefined) callback = function () {};

if($scope.destinations !== undefined) {

if(!$scope.destinations) {
							alert.error(lang.t("You must first create a destination before creating a clone job for this server"));
							return;
						}

callback();
						return;
					}

$scope.destinations = false;

api.listDestinations({ 
						data: { readonly:0 }, 
						success: function(data) {
							$scope.destinations = !!data.destinations.length;
							if(!$scope.destinations) {
								alert.error(lang.t("You must first create a destination before creating a clone job for this server"));
								return;
							}
	
							callback();
						},
						failed: function (message) {
							alert.error(message);
						}
					});
				};

$scope.checkRunning = function() {
					for(var id in $scope.running) {
						api.getCloneJob({ 
							data: { _id: id }, 
							success: function (data) {
								if(data.running) return;
								for(var key in data) $scope.running[id][key] = data[key];
								delete $scope.running[id];
							}
						});
					}
				};

$scope.$on('$destroy', function() {
					if($scope.checkRunningInterval === null) return;
					clearInterval($scope.checkRunningInterval);
					$scope.checkRunningInterval = null;
				});

$scope.fetch = function(callback) {
					if(callback === undefined || typeof callback !== 'function') callback = function() {};

$scope.loadingJobs = true;

var apiParams = {
						sort: {},
						skip: meta.getSkip(),
						limit: meta.getPageSize(),
						filter: meta.getFilter()
					};

apiParams.sort[meta.getSortBy()] = meta.getSortDirectionInt();

$scope.jobs = [];
					$scope.running = {};

api.listCloneJobs({ 
						data: apiParams, 
						success: function(data) {
							meta.setTotalItems(data.total);
							meta.calculate(data.jobs);
							$scope.jobs = data.jobs;
	
							for(var i = 0; i < $scope.jobs.length; i++) {
	
								var job = $scope.jobs[i];
								var type = parseInt(job.type);
								var contains = parseInt(job.contains);
								var names = [];
	
	
								switch(type) {
									case consts.CLONE_TYPE_ACCOUNT:
										if(contains == consts.CLONE_TYPE_ACCOUNT_FULL) names.push(consts.CLONE_TYPE_ACCOUNT_NAMES[consts.CLONE_TYPE_ACCOUNT_FULL]);
										else {
											if(contains & consts.CLONE_TYPE_ACCOUNT_CONFIG) names.push(consts.CLONE_TYPE_ACCOUNT_NAMES[consts.CLONE_TYPE_ACCOUNT_CONFIG]);
											if(contains & consts.CLONE_TYPE_ACCOUNT_HOMEDIR) names.push(consts.CLONE_TYPE_ACCOUNT_NAMES[consts.CLONE_TYPE_ACCOUNT_HOMEDIR]);
											if(contains & consts.CLONE_TYPE_ACCOUNT_DATABASES) names.push(consts.CLONE_TYPE_ACCOUNT_NAMES[consts.CLONE_TYPE_ACCOUNT_DATABASES]);
											if(contains & consts.CLONE_TYPE_ACCOUNT_EMAILS) names.push(consts.CLONE_TYPE_ACCOUNT_NAMES[consts.CLONE_TYPE_ACCOUNT_EMAILS]);
											if(contains & consts.CLONE_TYPE_ACCOUNT_CRON_JOBS) names.push(consts.CLONE_TYPE_ACCOUNT_NAMES[consts.CLONE_TYPE_ACCOUNT_CRON_JOBS]);
											if(contains & consts.CLONE_TYPE_ACCOUNT_DOMAINS) names.push(consts.CLONE_TYPE_ACCOUNT_NAMES[consts.CLONE_TYPE_ACCOUNT_DOMAINS]);
											if(contains & consts.CLONE_TYPE_ACCOUNT_CERTIFICATES) names.push(consts.CLONE_TYPE_ACCOUNT_NAMES[consts.CLONE_TYPE_ACCOUNT_CERTIFICATES]);
										}
									break;
										/*
									case consts.CLONE_TYPE_DIRECTORY:
										names.push(consts.CLONE_TYPE_DIRECTORY_NAMES[consts.CLONE_TYPE_DIRECTORY_FULL]);
									break;
									
										 */
								}
	
								job.contains_name = names.join(', ');
	
								job.filters_sorted = [];
								if(job.filters !== undefined) {
									for(var j = 0; j < job.filters.length; j++) {
										for(var a = 0; a < job.filters[j].length; a++) {
											job.filters_sorted.push(job.filters[j][a]);
										}
									}
								}
	
								if(job.running) $scope.running[job._id] = job;
	
								var destinations_list = [];
								job.destinations = '';
	
								for(var k = 0; k < job.destination_details.length; k++) 
									destinations_list.push(job.destination_details[k].name + (job.destination_details[k].disabled ? " <span style=\"color: #cc0000; font-size: 11px;\">(" + lang.t("Disabled") + ")</span>" : ''));
	
								job.destinations = $sce.trustAsHtml(destinations_list.join(", "));
								//job.next_run_int = job.next_run ? parseInt((new Date(job.next_run)).getTime() / 1000) : 0;
							}
	
							$scope.loadingJobs = false;
							callback();
						}
					});
				};

$timeout(function () {
					$scope.fetch(function () {
						$scope.checkRunningInterval = setInterval($scope.checkRunning, 3000);
					});
				});
			}
		]
	);
});

define('controllers/cloneJobManage',['app'], function(app) {
	app.controller("cloneJobManage",
		["$rootScope", "$scope", "$routeParams", "$templateCache", "$route", "$location", "$timeout", "$q", "api", "meta", "util", "lang", "alert", "permissions", "consts", "filterManager", "confirm", "popup",
			function ($rootScope, $scope, $routeParams, $templateCache, $route, $location, $timeout, $q, api, meta, util, lang, alert, permissions, consts, filterManager, confirm, popup) {
				$rootScope.$emit('menuItem', 'cloneJobs');

$scope.saveData = {
					name: '',
					destination: '',
					owner: $scope.loggedAccount._id,
					owner_name: $scope.loggedAccount.username,
					type: consts.CLONE_TYPE_ACCOUNT,
					contains: consts.CLONE_TYPE_ACCOUNT_FULL,
					//options: 0,
					default_package: '',
					default_owner: '',
					suspend_after: 0,
					time_parsed: '12:00 AM',
					time: 0,
					monitor: {ranfor:0,notran:0},
					schedules: [],
					filters: [],
					include_list: [],
					exclude_list: []
				};

$scope.autocomplete = { accountText: $scope.saveData.owner_name };

$scope.details = {};
				$scope.destinations = {};
				$scope.schedules = {};
				$scope.filters = {};
				$scope.backup_job_names = {};
				$scope.clone_job_names = {};
				$scope.cancelled = false;
				$scope.excluderow = '';
				$scope.includerow = '';
				
				$scope.types = [
					{ label: consts.CLONE_TYPE_NAMES[consts.CLONE_TYPE_ACCOUNT], value: consts.CLONE_TYPE_ACCOUNT }
				];

$scope.account_types = [
					//{ label: consts.CLONE_TYPE_ACCOUNT_NAMES[consts.CLONE_TYPE_ACCOUNT_CONFIG], value: consts.CLONE_TYPE_ACCOUNT_CONFIG },
					{ label: consts.CLONE_TYPE_ACCOUNT_NAMES[consts.CLONE_TYPE_ACCOUNT_HOMEDIR], value: consts.CLONE_TYPE_ACCOUNT_HOMEDIR },
					{ label: consts.CLONE_TYPE_ACCOUNT_NAMES[consts.CLONE_TYPE_ACCOUNT_DATABASES], value: consts.CLONE_TYPE_ACCOUNT_DATABASES },
					{ label: consts.CLONE_TYPE_ACCOUNT_NAMES[consts.CLONE_TYPE_ACCOUNT_DATABASE_USERS], value: consts.CLONE_TYPE_ACCOUNT_DATABASE_USERS },
					{ label: consts.CLONE_TYPE_ACCOUNT_NAMES[consts.CLONE_TYPE_ACCOUNT_EMAILS], value: consts.CLONE_TYPE_ACCOUNT_EMAILS },
					{ label: consts.CLONE_TYPE_ACCOUNT_NAMES[consts.CLONE_TYPE_ACCOUNT_FTP], value: consts.CLONE_TYPE_ACCOUNT_FTP },
					{ label: consts.CLONE_TYPE_ACCOUNT_NAMES[consts.CLONE_TYPE_ACCOUNT_CRON_JOBS], value: consts.CLONE_TYPE_ACCOUNT_CRON_JOBS },
					{ label: consts.CLONE_TYPE_ACCOUNT_NAMES[consts.CLONE_TYPE_ACCOUNT_DOMAINS], value: consts.CLONE_TYPE_ACCOUNT_DOMAINS },
					{ label: consts.CLONE_TYPE_ACCOUNT_NAMES[consts.CLONE_TYPE_ACCOUNT_CERTIFICATES], value: consts.CLONE_TYPE_ACCOUNT_CERTIFICATES }
				];

$scope.filtersConditions = [
					{_id:1,name:lang.t("OR")},
					{_id:2,name:lang.t("AND")}
				];

$scope.filtersStructure = [];