| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| /** |
| * The controller for editing or creating connection groups. |
| */ |
| angular.module('manage').controller('manageConnectionGroupController', ['$scope', '$injector', |
| function manageConnectionGroupController($scope, $injector) { |
| |
| // Required types |
| var ConnectionGroup = $injector.get('ConnectionGroup'); |
| var ManagementPermissions = $injector.get('ManagementPermissions'); |
| var PermissionSet = $injector.get('PermissionSet'); |
| |
| // Required services |
| var $location = $injector.get('$location'); |
| var $q = $injector.get('$q'); |
| var $routeParams = $injector.get('$routeParams'); |
| var authenticationService = $injector.get('authenticationService'); |
| 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 group |
| * being edited. |
| * |
| * @type String |
| */ |
| $scope.selectedDataSource = $routeParams.dataSource; |
| |
| /** |
| * The identifier of the original connection group from which this |
| * connection group is being cloned. Only valid if this is a new |
| * connection group. |
| * |
| * @type String |
| */ |
| var cloneSourceIdentifier = $location.search().clone; |
| |
| /** |
| * The identifier of the connection group being edited. If a new connection |
| * group is being created, this will not be defined. |
| * |
| * @type String |
| */ |
| var identifier = $routeParams.id; |
| |
| /** |
| * Available connection group types, as translation string / internal value |
| * pairs. |
| * |
| * @type Object[] |
| */ |
| $scope.types = [ |
| { |
| label: "MANAGE_CONNECTION_GROUP.NAME_TYPE_ORGANIZATIONAL", |
| value: ConnectionGroup.Type.ORGANIZATIONAL |
| }, |
| { |
| label: "MANAGE_CONNECTION_GROUP.NAME_TYPE_BALANCING", |
| value : ConnectionGroup.Type.BALANCING |
| } |
| ]; |
| |
| /** |
| * The root connection group of the connection group hierarchy. |
| * |
| * @type ConnectionGroup |
| */ |
| $scope.rootGroup = null; |
| |
| /** |
| * The connection group being modified. |
| * |
| * @type ConnectionGroup |
| */ |
| $scope.connectionGroup = null; |
| |
| /** |
| * The management-related actions that the current user may perform on the |
| * connection group 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 group 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.rootGroup !== null |
| && $scope.connectionGroup !== null |
| && $scope.managementPermissions !== null |
| && $scope.attributes !== null; |
| |
| }; |
| |
| /** |
| * Loads the data associated with the connection group having the given |
| * identifier, preparing the interface for making modifications to that |
| * existing connection group. |
| * |
| * @param {String} dataSource |
| * The unique identifier of the data source containing the connection |
| * group to load. |
| * |
| * @param {String} identifier |
| * The identifier of the connection group to load. |
| * |
| * @returns {Promise} |
| * A promise which is resolved when the interface has been prepared for |
| * editing the given connection group. |
| */ |
| var loadExistingConnectionGroup = function loadExistingConnectionGroup(dataSource, identifier) { |
| return connectionGroupService.getConnectionGroup( |
| dataSource, |
| identifier |
| ) |
| .then(function connectionGroupReceived(connectionGroup) { |
| $scope.connectionGroup = connectionGroup; |
| }); |
| }; |
| |
| /** |
| * Loads the data associated with the connection group having the given |
| * identifier, preparing the interface for cloning that existing |
| * connection group. |
| * |
| * @param {String} dataSource |
| * The unique identifier of the data source containing the connection |
| * group to be cloned. |
| * |
| * @param {String} identifier |
| * The identifier of the connection group being cloned. |
| * |
| * @returns {Promise} |
| * A promise which is resolved when the interface has been prepared for |
| * cloning the given connection group. |
| */ |
| var loadClonedConnectionGroup = function loadClonedConnectionGroup(dataSource, identifier) { |
| return connectionGroupService.getConnectionGroup( |
| dataSource, |
| identifier |
| ) |
| .then(function connectionGroupReceived(connectionGroup) { |
| $scope.connectionGroup = connectionGroup; |
| delete $scope.connectionGroup.identifier; |
| }); |
| }; |
| |
| /** |
| * Loads skeleton connection group data, preparing the interface for |
| * creating a new connection group. |
| * |
| * @returns {Promise} |
| * A promise which is resolved when the interface has been prepared for |
| * creating a new connection group. |
| */ |
| var loadSkeletonConnectionGroup = function loadSkeletonConnectionGroup() { |
| |
| // Use skeleton connection group object with specified parent |
| $scope.connectionGroup = new ConnectionGroup({ |
| parentIdentifier : $location.search().parent |
| }); |
| |
| 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 group, cloning an |
| * existing connection group, or creating an entirely new connection group. |
| * |
| * @returns {Promise} |
| * A promise which is resolved when the interface has been prepared |
| * for performing the requested management task. |
| */ |
| var loadRequestedConnectionGroup = function loadRequestedConnectionGroup() { |
| |
| // If we are editing an existing connection group, pull its data |
| if (identifier) |
| return loadExistingConnectionGroup($scope.selectedDataSource, identifier); |
| |
| // If we are cloning an existing connection group, pull its data |
| // instead |
| if (cloneSourceIdentifier) |
| return loadClonedConnectionGroup($scope.selectedDataSource, cloneSourceIdentifier); |
| |
| // If we are creating a new connection group, populate skeleton |
| // connection group data |
| return loadSkeletonConnectionGroup(); |
| |
| }; |
| |
| // Query the user's permissions for the current connection group |
| $q.all({ |
| connectionGroupData : loadRequestedConnectionGroup(), |
| attributes : schemaService.getConnectionGroupAttributes($scope.selectedDataSource), |
| permissions : permissionService.getEffectivePermissions($scope.selectedDataSource, authenticationService.getCurrentUsername()), |
| rootGroup : connectionGroupService.getConnectionGroupTree($scope.selectedDataSource, ConnectionGroup.ROOT_IDENTIFIER, [PermissionSet.ObjectPermissionType.ADMINISTER]) |
| }) |
| .then(function connectionGroupDataRetrieved(values) { |
| |
| $scope.attributes = values.attributes; |
| $scope.rootGroup = values.rootGroup; |
| |
| $scope.managementPermissions = ManagementPermissions.fromPermissionSet( |
| values.permissions, |
| PermissionSet.SystemPermissionType.CREATE_CONNECTION, |
| PermissionSet.hasConnectionPermission, |
| identifier); |
| |
| }, requestService.DIE); |
| |
| /** |
| * Cancels all pending edits, returning to the main list of connections |
| * within the selected data source. |
| */ |
| $scope.returnToConnectionList = function returnToConnectionList() { |
| $location.path('/settings/' + encodeURIComponent($scope.selectedDataSource) + '/connections'); |
| }; |
| |
| /** |
| * Cancels all pending edits, opening an edit page for a new connection |
| * group which is prepopulated with the data from the connection group |
| * currently being edited. |
| */ |
| $scope.cloneConnectionGroup = function cloneConnectionGRoup() { |
| $location.path('/manage/' + encodeURIComponent($scope.selectedDataSource) + '/connectionGroups').search('clone', identifier); |
| }; |
| |
| /** |
| * Saves the current connection group, creating a new connection group or |
| * updating the existing connection group, 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.saveConnectionGroup = function saveConnectionGroup() { |
| return connectionGroupService.saveConnectionGroup($scope.selectedDataSource, $scope.connectionGroup); |
| }; |
| |
| /** |
| * Deletes the current connection group, 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.deleteConnectionGroup = function deleteConnectionGroup() { |
| return connectionGroupService.deleteConnectionGroup($scope.selectedDataSource, $scope.connectionGroup); |
| }; |
| |
| }]); |