in guacamole/src/main/frontend/src/app/import/controllers/importConnectionsController.js [106:699]
function importConnectionsController($scope, $injector) {
// Required services
const $location = $injector.get('$location');
const $q = $injector.get('$q');
const $routeParams = $injector.get('$routeParams');
const connectionParseService = $injector.get('connectionParseService');
const connectionService = $injector.get('connectionService');
const guacNotification = $injector.get('guacNotification');
const permissionService = $injector.get('permissionService');
const userService = $injector.get('userService');
const userGroupService = $injector.get('userGroupService');
// Required types
const ConnectionImportConfig = $injector.get('ConnectionImportConfig');
const DirectoryPatch = $injector.get('DirectoryPatch');
const Error = $injector.get('Error');
const ParseError = $injector.get('ParseError');
const PermissionSet = $injector.get('PermissionSet');
const User = $injector.get('User');
const UserGroup = $injector.get('UserGroup');
/**
* The result of parsing the current upload, if successful.
*
* @type {ParseResult}
*/
$scope.parseResult = null;
/**
* The failure associated with the current attempt to create connections
* through the API, if any.
*
* @type {Error}
*/
$scope.patchFailure = null;;
/**
* True if the file is fully uploaded and ready to be processed, or false
* otherwise.
*
* @type {Boolean}
*/
$scope.dataReady = false;
/**
* True if the file upload has been aborted mid-upload, or false otherwise.
*/
$scope.aborted = false;
/**
* True if fully-uploaded data is being processed, or false otherwise.
*/
$scope.processing = false;
/**
* The MIME type of the uploaded file, if any.
*
* @type {String}
*/
$scope.mimeType = null;
/**
* The name of the file that's currently being uploaded, or has yet to
* be imported, if any.
*
* @type {String}
*/
$scope.fileName = null;
/**
* The raw string contents of the uploaded file, if any.
*
* @type {String}
*/
$scope.fileData = null;
/**
* The file reader currently being used to upload the file, if any. If
* null, no file upload is currently in progress.
*
* @type {FileReader}
*/
$scope.fileReader = null;
/**
* The configuration options for this import, to be chosen by the user.
*
* @type {ConnectionImportConfig}
*/
$scope.importConfig = new ConnectionImportConfig();
/**
* Clear all file upload state.
*/
function resetUploadState() {
$scope.aborted = false;
$scope.dataReady = false;
$scope.processing = false;
$scope.fileData = null;
$scope.mimeType = null;
$scope.fileReader = null;
$scope.parseResult = null;
$scope.patchFailure = null;
$scope.fileName = null;
}
// Indicate that data is currently being loaded / processed if the the file
// has been provided but not yet fully uploaded, or if the the file is
// fully loaded and is currently being processed.
$scope.isLoading = () => (
($scope.fileName && !$scope.dataReady && !$scope.patchFailure)
|| $scope.processing);
/**
* Create all users and user groups mentioned in the import file that don't
* already exist in the current data source. Return an object describing the
* result of the creation requests.
*
* @param {ParseResult} parseResult
* The result of parsing the user-supplied import file.
*
* @return {Promise.<Object>}
* A promise resolving to an object containing the results of the calls
* to create the users and groups.
*/
function createUsersAndGroups(parseResult) {
const dataSource = $routeParams.dataSource;
return $q.all({
existingUsers : userService.getUsers(dataSource),
existingGroups : userGroupService.getUserGroups(dataSource)
}).then(({existingUsers, existingGroups}) => {
const userPatches = Object.keys(parseResult.users)
// Filter out any existing users
.filter(identifier => !existingUsers[identifier])
// A patch to create each new user
.map(username => new DirectoryPatch({
op: 'add',
path: '/',
value: new User({ username })
}));
const groupPatches = Object.keys(parseResult.groups)
// Filter out any existing groups
.filter(identifier => !existingGroups[identifier])
// A patch to create each new user group
.map(identifier => new DirectoryPatch({
op: 'add',
path: '/',
value: new UserGroup({ identifier })
}));
// Create all the users and groups
return $q.all({
userResponse: userService.patchUsers(dataSource, userPatches),
userGroupResponse: userGroupService.patchUserGroups(
dataSource, groupPatches)
});
});
}
/**
* Grant read permissions for each user and group in the supplied parse
* result to each connection in their connection list. Note that there will
* be a seperate request for each user and group.
*
* @param {ParseResult} parseResult
* The result of successfully parsing a user-supplied import file.
*
* @param {Object} response
* The response from the PATCH API request.
*
* @returns {Promise.<Object>}
* A promise that will resolve with the result of every permission
* granting request.
*/
function grantConnectionPermissions(parseResult, response) {
const dataSource = $routeParams.dataSource;
// All connection grant requests, one per user/group
const userRequests = {};
const groupRequests = {};
// Create a PermissionSet granting access to all connections at
// the provided indices within the provided parse result
const createPermissionSet = indices =>
new PermissionSet({ connectionPermissions: indices.reduce(
(permissions, index) => {
const connectionId = response.patches[index].identifier;
permissions[connectionId] = [
PermissionSet.ObjectPermissionType.READ];
return permissions;
}, {}) });
// Now that we've created all the users, grant access to each
_.forEach(parseResult.users, (connectionIndices, identifier) =>
// Grant the permissions - note the group flag is `false`
userRequests[identifier] = permissionService.patchPermissions(
dataSource, identifier,
// Create the permissions to these connections for this user
createPermissionSet(connectionIndices),
// Do not remove any permissions
new PermissionSet(),
// This call is not for a group
false));
// Now that we've created all the groups, grant access to each
_.forEach(parseResult.groups, (connectionIndices, identifier) =>
// Grant the permissions - note the group flag is `true`
groupRequests[identifier] = permissionService.patchPermissions(
dataSource, identifier,
// Create the permissions to these connections for this user
createPermissionSet(connectionIndices),
// Do not remove any permissions
new PermissionSet(),
// This call is for a group
true));
// Return the result from all the permission granting calls
return $q.all({ ...userRequests, ...groupRequests });
}
/**
* Process a successfully parsed import file, creating any specified
* connections, creating and granting permissions to any specified users
* and user groups. If successful, the user will be shown a success message.
* If not, any errors will be displayed and any already-created entities
* will be rolled back.
*
* @param {ParseResult} parseResult
* The result of parsing the user-supplied import file.
*/
function handleParseSuccess(parseResult) {
$scope.processing = false;
$scope.parseResult = parseResult;
// If errors were encounted during file parsing, abort further
// processing - the user will have a chance to fix the errors and try
// again
if (parseResult.hasErrors)
return;
const dataSource = $routeParams.dataSource;
// First, attempt to create the connections
connectionService.patchConnections(dataSource, parseResult.patches)
.then(connectionResponse =>
// If connection creation is successful, create users and groups
createUsersAndGroups(parseResult).then(() =>
// Grant any new permissions to users and groups. NOTE: Any
// existing permissions for updated connections will NOT be
// removed - only new permissions will be added.
grantConnectionPermissions(parseResult, connectionResponse)
.then(() => {
$scope.processing = false;
// Display a success message if everything worked
guacNotification.showStatus({
className : 'success',
title : 'IMPORT.DIALOG_HEADER_SUCCESS',
text : {
key: 'IMPORT.INFO_CONNECTIONS_IMPORTED_SUCCESS',
variables: { NUMBER: parseResult.connectionCount }
},
// Add a button to acknowledge and redirect to
// the connection listing page
actions : [{
name : 'IMPORT.ACTION_ACKNOWLEDGE',
callback : () => {
// Close the notification
guacNotification.showStatus(false);
// Redirect to connection list page
$location.url('/settings/' + dataSource + '/connections');
}
}]
});
}))
// If an error occurs while trying to create users or groups,
// display the error to the user.
.catch(handleError)
)
// If an error occurred when the call to create the connections was made,
// skip any further processing - the user will have a chance to fix the
// problems and try again
.catch(patchFailure => {
$scope.processing = false;
$scope.patchFailure = patchFailure;
});
}
/**
* Display the provided error to the user in a dismissable dialog.
*
* @argument {ParseError|Error} error
* The error to display.
*/
const handleError = error => {
// Any error indicates that processing of the file has failed, so clear
// all upload state to allow for a fresh retry
resetUploadState();
let text;
// If it's a import file parsing error
if (error instanceof ParseError)
text = {
// Use the translation key if available
key: error.key || error.message,
variables: error.variables
};
// If it's a generic REST error
else if (error instanceof Error)
text = error.translatableMessage;
// If it's an unknown type, just use the message directly
else
text = { key: error };
guacNotification.showStatus({
className : 'error',
title : 'IMPORT.DIALOG_HEADER_ERROR',
text,
// Add a button to hide the error
actions : [{
name : 'IMPORT.ACTION_ACKNOWLEDGE',
callback : () => guacNotification.showStatus(false)
}]
});
};
/**
* Process the uploaded import file, importing the connections, granting
* connection permissions, or displaying errors to the user if there are
* problems with the provided file.
*
* @param {String} mimeType
* The MIME type of the uploaded data file.
*
* @param {String} data
* The raw string contents of the import file.
*/
function processData(mimeType, data) {
// Data processing has begun
$scope.processing = true;
// The function that will process all the raw data and return a list of
// patches to be submitted to the API
let processDataCallback;
// Choose the appropriate parse function based on the mimetype
if (mimeType === JSON_MIME_TYPE)
processDataCallback = connectionParseService.parseJSON;
else if (mimeType === CSV_MIME_TYPE)
processDataCallback = connectionParseService.parseCSV;
else if (YAML_MIME_TYPES.indexOf(mimeType) >= 0)
processDataCallback = connectionParseService.parseYAML;
// The file type was validated before being uploaded - this should
// never happen
else
processDataCallback = () => {
throw new ParseError({
message: "Unexpected invalid file type: " + mimeType
});
};
// Make the call to process the data into a series of patches
processDataCallback($scope.importConfig, data)
// Send the data off to be imported if parsing is successful
.then(handleParseSuccess)
// Display any error found while parsing the file
.catch(handleError);
}
/**
* Process the uploaded import data. Only usuable if the upload is fully
* complete.
*/
$scope.import = () => processData($scope.mimeType, $scope.fileData);
/**
* Returns true if import should be disabled, or false if import should be
* allowed.
*
* @return {Boolean}
* True if import should be disabled, otherwise false.
*/
$scope.importDisabled = () =>
// Disable import if no data is ready
!$scope.dataReady ||
// Disable import if the file is currently being processed
$scope.processing;
/**
* Cancel any in-progress upload, or clear any uploaded-but-errored-out
* batch.
*/
$scope.cancel = function() {
// If the upload is in progress, stop it now; the FileReader will
// reset the upload state when it stops
if ($scope.fileReader) {
$scope.aborted = true;
$scope.fileReader.abort();
}
// Clear any upload state - there's no FileReader handler to do it
else
resetUploadState();
};
/**
* Returns true if cancellation should be disabled, or false if
* cancellation should be allowed.
*
* @return {Boolean}
* True if cancellation should be disabled, or false if cancellation
* should be allowed.
*/
$scope.cancelDisabled = () =>
// Disable cancellation if the import has already been cancelled
$scope.aborted ||
// Disable cancellation if the file is currently being processed
$scope.processing ||
// Disable cancellation if no data is ready or being uploaded
!($scope.fileReader || $scope.dataReady);
/**
* Handle a provided File upload, reading all data onto the scope for
* import processing, should the user request an import. Note that this
* function is used as a callback for directives that invoke it with a file
* list, but directive-level checking should ensure that there is only ever
* one file provided at a time.
*
* @argument {File[]} files
* The files to upload onto the scope for further processing. There
* should only ever be a single file in the array.
*/
$scope.handleFiles = files => {
// There should only ever be a single file in the array
const file = files[0];
// The name and MIME type of the file as provided by the browser
let fileName = file.name;
let mimeType = file.type;
// If no MIME type was provided by the browser at all, use REGEXes as a
// fallback to try to determine the file type. NOTE: Windows 10/11 are
// known to do this with YAML files.
if (!_.trim(mimeType).length) {
// If the file name matches what we'd expect for a CSV file, set the
// CSV MIME type and move on
if (CSV_FILENAME_REGEX.test(fileName))
mimeType = CSV_MIME_TYPE;
// If the file name matches what we'd expect for a JSON file, set
// the JSON MIME type and move on
else if (JSON_FILENAME_REGEX.test(fileName))
mimeType = JSON_MIME_TYPE;
// If the file name matches what we'd expect for a JSON file, set
// one of the allowed YAML MIME types and move on
else if (YAML_FILENAME_REGEX.test(fileName))
mimeType = YAML_MIME_TYPES[0];
else {
// If none of the REGEXes pass, there's nothing more to be tried
handleError(new ParseError({
message: "Unknown type for file: " + fileName,
key: 'IMPORT.ERROR_DETECTED_INVALID_TYPE'
}));
return;
}
}
// Check if the mimetype is one of the supported types,
// e.g. "application/json" or "text/csv"
else if (LEGAL_MIME_TYPES.indexOf(mimeType) < 0) {
// If the provided file is not one of the supported types,
// display an error and abort processing
handleError(new ParseError({
message: "Invalid file type: " + mimeType,
key: 'IMPORT.ERROR_INVALID_MIME_TYPE',
variables: { TYPE: mimeType }
}));
return;
}
// Save the name and type to the scope
$scope.fileName = fileName;
$scope.mimeType = mimeType;
// Initialize upload state
$scope.aborted = false;
$scope.dataReady = false;
$scope.processing = false;
$scope.uploadStarted = true;
// Save the file to the scope when ready
$scope.fileReader = new FileReader();
$scope.fileReader.onloadend = (e => {
// If the upload was explicitly aborted, clear any upload state and
// do not process the data
if ($scope.aborted)
resetUploadState();
else {
const fileData = e.target.result;
// Check if the file has a header of a known-bad type
if (_.some(ZIP_SIGNATURES,
signature => fileData.startsWith(signature))) {
// Throw an error and abort processing
handleError(new ParseError({
message: "Invalid file type detected",
key: 'IMPORT.ERROR_DETECTED_INVALID_TYPE'
}));
return;
}
// Save the uploaded data
$scope.fileData = fileData;
// Mark the data as ready
$scope.dataReady = true;
// Clear the file reader from the scope now that this file is
// fully uploaded
$scope.fileReader = null;
}
});
// Read all the data into memory
$scope.fileReader.readAsText(file);
};
}]);