in guacamole/src/main/frontend/src/app/manage/controllers/manageConnectionController.js [24:353]
function manageConnectionController($scope, $injector) {
// Required types
var Connection = $injector.get('Connection');
var ConnectionGroup = $injector.get('ConnectionGroup');
var HistoryEntryWrapper = $injector.get('HistoryEntryWrapper');
var ManagementPermissions = $injector.get('ManagementPermissions');
var PermissionSet = $injector.get('PermissionSet');
var Protocol = $injector.get('Protocol');
// Required services
var $location = $injector.get('$location');
var $q = $injector.get('$q');
var $routeParams = $injector.get('$routeParams');
var $translate = $injector.get('$translate');
var authenticationService = $injector.get('authenticationService');
var connectionService = $injector.get('connectionService');
var connectionGroupService = $injector.get('connectionGroupService');
var permissionService = $injector.get('permissionService');
var requestService = $injector.get('requestService');
var schemaService = $injector.get('schemaService');
/**
* The unique identifier of the data source containing the connection being
* edited.
*
* @type String
*/
$scope.selectedDataSource = $routeParams.dataSource;
/**
* The identifier of the original connection from which this connection is
* being cloned. Only valid if this is a new connection.
*
* @type String
*/
var cloneSourceIdentifier = $location.search().clone;
/**
* The identifier of the connection being edited. If a new connection is
* being created, this will not be defined.
*
* @type String
*/
var identifier = $routeParams.id;
/**
* All known protocols.
*
* @type Object.<String, Protocol>
*/
$scope.protocols = null;
/**
* The root connection group of the connection group hierarchy.
*
* @type ConnectionGroup
*/
$scope.rootGroup = null;
/**
* The connection being modified.
*
* @type Connection
*/
$scope.connection = null;
/**
* The parameter name/value pairs associated with the connection being
* modified.
*
* @type Object.<String, String>
*/
$scope.parameters = null;
/**
* The date format for use within the connection history.
*
* @type String
*/
$scope.historyDateFormat = null;
/**
* The usage history of the connection being modified.
*
* @type HistoryEntryWrapper[]
*/
$scope.historyEntryWrappers = null;
/**
* The management-related actions that the current user may perform on the
* connection currently being created/modified, or null if the current
* user's permissions have not yet been loaded.
*
* @type ManagementPermissions
*/
$scope.managementPermissions = null;
/**
* All available connection attributes. This is only the set of attribute
* definitions, organized as logical groupings of attributes, not attribute
* values.
*
* @type Form[]
*/
$scope.attributes = null;
/**
* Returns whether critical data has completed being loaded.
*
* @returns {Boolean}
* true if enough data has been loaded for the user interface to be
* useful, false otherwise.
*/
$scope.isLoaded = function isLoaded() {
return $scope.protocols !== null
&& $scope.rootGroup !== null
&& $scope.connection !== null
&& $scope.parameters !== null
&& $scope.historyDateFormat !== null
&& $scope.historyEntryWrappers !== null
&& $scope.managementPermissions !== null
&& $scope.attributes !== null;
};
/**
* Loads the data associated with the connection having the given
* identifier, preparing the interface for making modifications to that
* existing connection.
*
* @param {String} dataSource
* The unique identifier of the data source containing the connection to
* load.
*
* @param {String} identifier
* The identifier of the connection to load.
*
* @returns {Promise}
* A promise which is resolved when the interface has been prepared for
* editing the given connection.
*/
var loadExistingConnection = function loadExistingConnection(dataSource, identifier) {
return $q.all({
connection : connectionService.getConnection(dataSource, identifier),
historyEntries : connectionService.getConnectionHistory(dataSource, identifier),
parameters : connectionService.getConnectionParameters(dataSource, identifier)
})
.then(function connectionDataRetrieved(values) {
$scope.connection = values.connection;
$scope.parameters = values.parameters;
// Wrap all history entries for sake of display
$scope.historyEntryWrappers = [];
angular.forEach(values.historyEntries, function wrapHistoryEntry(historyEntry) {
$scope.historyEntryWrappers.push(new HistoryEntryWrapper(historyEntry));
});
});
};
/**
* Loads the data associated with the connection having the given
* identifier, preparing the interface for cloning that existing
* connection.
*
* @param {String} dataSource
* The unique identifier of the data source containing the connection
* to be cloned.
*
* @param {String} identifier
* The identifier of the connection being cloned.
*
* @returns {Promise}
* A promise which is resolved when the interface has been prepared for
* cloning the given connection.
*/
var loadClonedConnection = function loadClonedConnection(dataSource, identifier) {
return $q.all({
connection : connectionService.getConnection(dataSource, identifier),
parameters : connectionService.getConnectionParameters(dataSource, identifier)
})
.then(function connectionDataRetrieved(values) {
$scope.connection = values.connection;
$scope.parameters = values.parameters;
// Clear the identifier field because this connection is new
delete $scope.connection.identifier;
// Cloned connections have no history
$scope.historyEntryWrappers = [];
});
};
/**
* Loads skeleton connection data, preparing the interface for creating a
* new connection.
*
* @returns {Promise}
* A promise which is resolved when the interface has been prepared for
* creating a new connection.
*/
var loadSkeletonConnection = function loadSkeletonConnection() {
// Use skeleton connection object with no associated permissions,
// history, or parameters
$scope.connection = new Connection({
protocol : 'vnc',
parentIdentifier : $location.search().parent
});
$scope.historyEntryWrappers = [];
$scope.parameters = {};
return $q.resolve();
};
/**
* Loads the data required for performing the management task requested
* through the route parameters given at load time, automatically preparing
* the interface for editing an existing connection, cloning an existing
* connection, or creating an entirely new connection.
*
* @returns {Promise}
* A promise which is resolved when the interface has been prepared
* for performing the requested management task.
*/
var loadRequestedConnection = function loadRequestedConnection() {
// If we are editing an existing connection, pull its data
if (identifier)
return loadExistingConnection($scope.selectedDataSource, identifier);
// If we are cloning an existing connection, pull its data instead
if (cloneSourceIdentifier)
return loadClonedConnection($scope.selectedDataSource, cloneSourceIdentifier);
// If we are creating a new connection, populate skeleton connection data
return loadSkeletonConnection();
};
// Populate interface with requested data
$q.all({
connectionData : loadRequestedConnection(),
attributes : schemaService.getConnectionAttributes($scope.selectedDataSource),
permissions : permissionService.getEffectivePermissions($scope.selectedDataSource, authenticationService.getCurrentUsername()),
protocols : schemaService.getProtocols($scope.selectedDataSource),
rootGroup : connectionGroupService.getConnectionGroupTree($scope.selectedDataSource, ConnectionGroup.ROOT_IDENTIFIER, [PermissionSet.ObjectPermissionType.ADMINISTER])
})
.then(function dataRetrieved(values) {
$scope.attributes = values.attributes;
$scope.protocols = values.protocols;
$scope.rootGroup = values.rootGroup;
$scope.managementPermissions = ManagementPermissions.fromPermissionSet(
values.permissions,
PermissionSet.SystemPermissionType.CREATE_CONNECTION,
PermissionSet.hasConnectionPermission,
identifier);
}, requestService.DIE);
// Get history date format
$translate('MANAGE_CONNECTION.FORMAT_HISTORY_START').then(function historyDateFormatReceived(historyDateFormat) {
$scope.historyDateFormat = historyDateFormat;
}, angular.noop);
/**
* @borrows Protocol.getNamespace
*/
$scope.getNamespace = Protocol.getNamespace;
/**
* @borrows Protocol.getName
*/
$scope.getProtocolName = Protocol.getName;
/**
* Cancels all pending edits, returning to the main list of connections
* within the selected data source.
*/
$scope.returnToConnectionList = function returnToConnectionList() {
$location.url('/settings/' + encodeURIComponent($scope.selectedDataSource) + '/connections');
};
/**
* Cancels all pending edits, opening an edit page for a new connection
* which is prepopulated with the data from the connection currently being edited.
*/
$scope.cloneConnection = function cloneConnection() {
$location.path('/manage/' + encodeURIComponent($scope.selectedDataSource) + '/connections').search('clone', identifier);
};
/**
* Saves the current connection, creating a new connection or updating the
* existing connection, returning a promise which is resolved if the save
* operation succeeds and rejected if the save operation fails.
*
* @returns {Promise}
* A promise which is resolved if the save operation succeeds and is
* rejected with an {@link Error} if the save operation fails.
*/
$scope.saveConnection = function saveConnection() {
$scope.connection.parameters = $scope.parameters;
// Save the connection
return connectionService.saveConnection($scope.selectedDataSource, $scope.connection);
};
/**
* Deletes the current connection, returning a promise which is resolved if
* the delete operation succeeds and rejected if the delete operation fails.
*
* @returns {Promise}
* A promise which is resolved if the delete operation succeeds and is
* rejected with an {@link Error} if the delete operation fails.
*/
$scope.deleteConnection = function deleteConnection() {
return connectionService.deleteConnection($scope.selectedDataSource, $scope.connection);
};
}]);