in guacamole/src/main/frontend/src/app/import/directives/connectionImportErrors.js [59:315]
function connectionImportErrorsController($scope, $injector) {
// Required types
const DirectoryPatch = $injector.get('DirectoryPatch');
const DisplayErrorList = $injector.get('DisplayErrorList');
const ImportConnectionError = $injector.get('ImportConnectionError');
const ParseError = $injector.get('ParseError');
const SortOrder = $injector.get('SortOrder');
// Required services
const $q = $injector.get('$q');
const $translate = $injector.get('$translate');
// There are errors to display if the parse result generated errors, or
// if the patch request failed
$scope.hasErrors = () =>
!!_.get($scope, 'parseResult.hasErrors') || !!$scope.patchFailure;
/**
* All connections with their associated errors for display. These may
* be either parsing failures, or errors returned from the API. Both
* error types will be adapted to a common display format, though the
* error types will never be mixed, because no REST request should ever
* be made if there are client-side parse errors.
*
* @type {ImportConnectionError[]}
*/
$scope.connectionErrors = [];
/**
* SortOrder instance which maintains the sort order of the visible
* connection errors.
*
* @type SortOrder
*/
$scope.errorOrder = new SortOrder([
'rowNumber',
'name',
'group',
'protocol',
'errors',
]);
/**
* Array of all connection error properties that are filterable.
*
* @type String[]
*/
$scope.filteredErrorProperties = [
'rowNumber',
'name',
'group',
'protocol',
'errors',
];
/**
* Generate a ImportConnectionError representing any errors associated
* with the row at the given index within the given parse result.
*
* @param {ParseResult} parseResult
* The result of parsing the connection import file.
*
* @param {Integer} index
* The current row within the patches array, 0-indexed.
*
* @param {Integer} row
* The current row within the original connection, 0-indexed.
* If any REMOVE patches are present, this may be greater than
* the index.
*
* @returns {ImportConnectionError}
* The connection error object associated with the given row in the
* given parse result.
*/
const generateConnectionError = (parseResult, index, row) => {
// Get the patch associated with the current row
const patch = parseResult.patches[index];
// The value of a patch is just the Connection object
const connection = patch.value;
return new ImportConnectionError({
// Add 1 to the provided row to get the position in the file
rowNumber: row + 1,
// Basic connection information - name, group, and protocol.
name: connection.name,
group: parseResult.groupPaths[index],
protocol: connection.protocol,
// The human-readable error messages
errors: new DisplayErrorList(
[ ...(parseResult.errors[index] || []) ])
});
};
// If a new connection patch failure is seen, update the display list
$scope.$watch('patchFailure', function patchFailureChanged(patchFailure) {
const { parseResult } = $scope;
// Do not attempt to process anything before the data has loaded
if (!patchFailure || !parseResult)
return;
// All promises from all translation requests. The scope will not be
// updated until all translations are ready.
const translationPromises = [];
// Any error returned from the API specifically associated with the
// preceding REMOVE patch
let removeError = null;
// Fetch the API error, if any, of the patch at the given index
const getAPIError = index =>
_.get(patchFailure, ['patches', index, 'error']);
// The row number for display. Unlike the index, this number will
// skip any REMOVE patches. In other words, this is the index of
// connections within the original import file.
let row = 0;
// Set up the list of connection errors based on the existing parse
// result, with error messages fetched from the patch failure
const connectionErrors = parseResult.patches.reduce(
(errors, patch, index) => {
// Do not process display REMOVE patches - they are always
// followed by ADD patches containing the actual content
// (and errors, if any)
if (patch.op === DirectoryPatch.Operation.REMOVE) {
// Save the API error, if any, so it can be displayed
// alongside the connection information associated with the
// following ADD patch
removeError = getAPIError(index);
// Do not add an entry for this remove patch - it should
// always be followed by a corresponding CREATE patch
// containing the relevant connection information
return errors;
}
// Generate a connection error for display
const connectionError = generateConnectionError(
parseResult, index, row++);
// Add the error associated with the previous REMOVE patch, if
// any, to the error associated with the current patch, if any
const apiErrors = [ removeError, getAPIError(index) ];
// Clear the previous REMOVE patch error after consuming it
removeError = null;
// Go through each potential API error
apiErrors.forEach(error =>
// If the API error exists, fetch the translation and
// update it when it's ready
error && translationPromises.push($translate(
error.key, error.variables)
.then(translatedError =>
connectionError.errors.getArray().push(translatedError)
)));
errors.push(connectionError);
return errors;
}, []);
// Once all the translations have been completed, update the
// connectionErrors all in one go, to ensure no excessive reloading
$q.all(translationPromises).then(() => {
$scope.connectionErrors = connectionErrors;
});
});
// If a new parse result with errors is seen, update the display list
$scope.$watch('parseResult', function parseResultChanged(parseResult) {
// Do not process if there are no errors in the provided result
if (!parseResult || !parseResult.hasErrors)
return;
// All promises from all translation requests. The scope will not be
// updated until all translations are ready.
const translationPromises = [];
// The parse result should only be updated on a fresh file import;
// therefore it should be safe to skip checking the patch errors
// entirely - if set, they will be from the previous file and no
// longer relevant.
// The row number for display. Unlike the index, this number will
// skip any REMOVE patches. In other words, this is the index of
// connections within the original import file.
let row = 0;
// Set up the list of connection errors based on the updated parse
// result
const connectionErrors = parseResult.patches.reduce(
(errors, patch, index) => {
// Do not process display REMOVE patches - they are always
// followed by ADD patches containing the actual content
// (and errors, if any)
if (patch.op === DirectoryPatch.Operation.REMOVE)
return errors;
// Generate a connection error for display
const connectionError = generateConnectionError(
parseResult, index, row++);
// Go through the errors and check if any are translateable
connectionError.errors.getArray().forEach(
(error, errorIndex) => {
// If this error is a ParseError, it can be translated.
// NOTE: Generally one would translate error messages in the
// template, but in this case, the connection errors need to
// be raw strings in order to enable sorting and filtering.
if (error instanceof ParseError)
// Fetch the translation and update it when it's ready
translationPromises.push($translate(
error.key, error.variables)
.then(translatedError => {
connectionError.errors.getArray()[errorIndex] = translatedError;
}));
// If the error is not a known translatable type, add the
// message directly to the error array
else
connectionError.errors.getArray()[errorIndex] = (
error.message ? error.message : error);
});
errors.push(connectionError);
return errors;
}, []);
// Once all the translations have been completed, update the
// connectionErrors all in one go, to ensure no excessive reloading
$q.all(translationPromises).then(() => {
$scope.connectionErrors = connectionErrors;
});
});
}];